Почему итерация по вектору целых чисел в Rust медленнее, чем в Python, C # и C ++?

Question

Я изучаю Rust прямо сейчас и использую эту простую реализацию Sieve of Erathostenes:

fn get_primes(known_primes: &Vec<i64>, start: i64, stop: i64) -> Vec<i64> {
    let mut new_primes = Vec::new();
    for number in start..stop {
        let mut is_prime = true;
        let limit = (number as f64).sqrt() as i64;
        for prime in known_primes {
            if number % prime == 0 {
                is_prime = false;
                break;
            }
            if *prime > limit {
                break;
            }
        }
        if is_prime {
            new_primes.push(number);
        }
    }
    return new_primes;
}

Я сравниваю ее практически с одним и тем же кодом (по модулю синтаксиса) в Python (с помощью numba).), C # и C ++ (gcc / clang).Все они примерно в 3 раза быстрее, чем эта реализация на моей машине.

Я компилирую в режиме выпуска.Чтобы быть точным, я добавил это в свой Cargo.toml, который, кажется, имеет тот же эффект:

[profile.dev]
opt-level = 3 

Я также проверил цепочку инструментов, есть небольшая (15% или около того)разница между MSVC и GNU, но ничего, что могло бы объяснить этот пробел.

Я что-то здесь не так понял?Я где-нибудь делаю копию?

Этот код эквивалентен следующему коду C ++?

vector<int> getPrimes(vector<int> &knownPrimes, int start, int stop) {
    vector<int> newPrimes;
    for (int number = start; number < stop; number += 1) {
        bool isPrime = true;
        int limit = (int)sqrt(number);
        for (auto& prime : knownPrimes) {
            if (number % prime == 0) {
                isPrime = false;
                break;
            }
            if (prime > limit)
                break;
        }
        if (isPrime) {
            newPrimes.push_back(number);
        }
    }
    return newPrimes;
}

Answer 1

Размер C ++ int зависит от целевой архитектуры, параметров компилятора и т. Д. В коде Rust вы явно указываете 64-битное целое число.Возможно, вы сравниваете код, используя разные размеры базовых типов.