Hey,
first of all: I am completly new to Rust. It might absolutly be the case that I implemented a “non optimal version” in rust.
I made a little benchmark for rust and c++. Both benchmarks check the numbers from 2 to 100000 if they are prime numbers and if they are they are added to a counter. Both implementations use the same algorithm. The algorithm itself is pretty bad, I know that you could do a “Sieve of Eratosthenes” approach instead or atleast calc the sqrt of the number to check - but thats not the point of this benchmark. Even though the algorithm itself is bad the results should be more or less equal because “the book” states: “Rust is a systems programming language focused on three goals: safety, speed,
and concurrency.”. However, they are not.
In my environment the C++ code took around 1.2 seconds (Visual Studio, default release settings).
Rust took around 1.7 seconds (cargo run --release).
2 Questions:
- Why is rust around 30% slower in this benchmark?
- Is there some way to improve the speed of the rust version without changeing the algorithm?
Rust src:
extern crate time;
fn main(){
let mut anti_optimization = 0;
let t1 = time::now();
for i in 2..100000{
if is_prim(i){
anti_optimization += i;
}
}
let t2 = time::now();
let diff = t2-t1;
println!("{}", diff.num_milliseconds());
println!("{}", anti_optimization);
}
fn is_prim(x: i32) -> bool{
for i in 2..x{
if x%i == 0 {
return false;
}
}
true
}
C++ src:
#include <iostream>
#include <chrono>
bool isPrim(int n);
int main()
{
int antiOptimization = 0;
auto t1 = std::chrono::high_resolution_clock::now();
for (int i = 2; i < 100000; i++) {
if (isPrim(i)) {
antiOptimization += i;
}
}
auto t2 = std::chrono::high_resolution_clock::now();
auto diff = t2 - t1;
int ms = std::chrono::duration_cast<std::chrono::milliseconds>(diff).count();
std::cout << ms << std::endl;
std::cout << antiOptimization << std::endl;
while (true);
return 0;
}
bool isPrim(int n)
{
for (int i = 2; i < n; i++) {
if (n%i == 0) {
return false;
}
}
return true;
}
Thanks!
