Почему этот код C ++ намного медленнее, чем ржавчина? ⇐ C++

[Anonymous]

Я создал две идентичные программы (одна в ржавчине и одна в C ++). Они однопоточные, и нет распределений кучи. Версия C ++ (составленная с выпуском MSVC /O2 или GCC) работает через 17 сек. Оптимизация профиля не улучшила производительность. Core (S), 12 логический процессор. />
Может быть, ржавчина лучше разворачивается, чем c ++? < /li>
< /ul>
< /li>
< P> Что можно сделать для повышения производительности версии C ++? />use std::time::SystemTime;

pub struct BWRNG {
pub seed:u64,
}

impl BWRNG {
const ADD: u64 = 0x269ec3;
const MULT: u64 = 0x5d588b656c078965;

pub fn new(seed:u64) -> BWRNG {
BWRNG { seed }
}
pub fn next(&mut self) -> u64
{
self.seed = self.seed.wrapping_mul(Self::MULT).wrapping_add(Self::ADD);
self.seed
}
pub fn advance(&mut self, advances:u32){
for _ in 0..advances
{
self.next();
}
}
pub fn next_uint2(&mut self, max:u32) -> u32
{
(((self.next() >> 32) * (max as u64)) >> 32) as u32
}
pub fn get_seed(&self) -> u64
{
self.seed
}
pub fn get_current_value(&self) -> u64
{
self.seed
}
pub fn next_uint(&mut self) -> u32
{
(self.next() >> 32) as u32
}

fn advance_probability_table(&mut self) -> u32 {
let mut count:u32 = 0;

count += 1;
self.advance(1);

count += 1;
if self.next_uint2(101) > 50
{
count += 1;
self.advance(1);
}

count += 1;
if self.next_uint2(101) > 30
{
count += 1;
self.advance(1);
}

count += 1;
if self.next_uint2(101) > 25
{
count += 1;
if self.next_uint2(101) > 30
{
count += 1;
self.advance(1);
}
}

count += 1;
if self.next_uint2(101) > 20
{
count += 1;
if self.next_uint2(101) > 25
{
count += 1;
if self.next_uint2(101) > 33
{
count += 1;
self.advance(1);
}
}
}

return count;
}

pub fn initial_advances_bw2(seed:u64) -> u32 {
let mut rng = BWRNG::new(seed);
let mut count:u32 = 0;

for i in 0..5 {
count += rng.advance_probability_table();

if i == 0{
count += 3;
rng.advance(3);
}
}

for _limit in 0..100 {
count += 3;
let rand1 = rng.next_uint2(15);
let rand2 = rng.next_uint2(15);
let rand3 = rng.next_uint2(15);

if rand1 != rand2 && rand1 != rand3 && rand2 != rand3
{
break;
}
}

return count;
}

}

fn main() {
let time_start = SystemTime::now();

let mut result = 0u64;

for i in 0..100_000_000u64 {
result += BWRNG::initial_advances_bw2(i) as u64;
}

let dur = SystemTime::now().duration_since(time_start).unwrap().as_secs();
println!("Dur={}sec. Result={}", dur, result % 255);
}

< /code>
c ++: < /p>

using u64 = unsigned long long;
using u32 = unsigned int;
using u16 = unsigned short;
using u8 = unsigned char;

class BWRNG
{
public:
BWRNG(u64 seed = 0) : seed(seed)
{
}

void advance(u32 advances)
{
for (u32 advance = 0; advance < advances; advance++)
{
next();
}
}

u64 next()
{
return seed = seed * 0x5d588b656c078965 + 0x269ec3;
}

u32 nextUInt(u32 max)
{
return ((next() >> 32) * max) >> 32;
}

u32 nextUInt()
{
return next() >> 32;
}

u64 getSeed() const
{
return seed;
}

static u32 initialAdvancesBW2(u64 seed)
{
BWRNG rng(seed);
u32 count = 0;

for (u8 i = 0; i < 5; i++)
{
count += advanceProbabilityTable(rng);

if (i == 0)
{
count += 3;
rng.advance(3);
}
}

for (u8 limit = 0; limit < 100; limit++)
{
count += 3;
u8 rand1 = rng.nextUInt(15);
u8 rand2 = rng.nextUInt(15);
u8 rand3 = rng.nextUInt(15);

if (rand1 != rand2 && rand1 != rand3 && rand2 != rand3)
{
break;
}
}

return count;
}

static u32 advanceProbabilityTable(BWRNG& rng)
{
u32 count = 0;

count++;
rng.advance(1);

count++;
if (rng.nextUInt(101) > 50)
{
count++;
rng.advance(1);
}

count++;
if (rng.nextUInt(101) > 30)
{
count++;
rng.advance(1);
}

count++;
if (rng.nextUInt(101) > 25)
{
count++;
if (rng.nextUInt(101) > 30)
{
count++;
rng.advance(1);
}
}

count++;
if (rng.nextUInt(101) > 20)
{
count++;
if (rng.nextUInt(101) > 25)
{
count++;
if (rng.nextUInt(101) > 33)
{
count++;
rng.advance(1);
}
}
}

return count;
}

private:
u64 seed;
};

int main()
{
u64 result = 0;
for (u64 i = 0; i < 100000000; i++)
result += BWRNG::initialAdvancesBW2(i);

return (int)(result % 255); // 169
}


Подробнее здесь: https://stackoverflow.com/questions/794 ... -than-rust