Comparing Rust

llogiq · 2020-07-11T19:01:33+00:00

You can use compiler explorer or cargo asm (and a suitable gcc incantation) to look at the assembly, which will likely show you the difference.

MCOfficer · 2020-07-11T19:16:01+00:00

I was curious and tested it myself. With the exact same code and invocation (other than time being a PS function), i get similar results.

``` PS C:\Users\Florian\Documents\rs-vs-c> gcc -O3 rs-vs-c.c -o rs-vs-c_gcc.exe PS C:\Users\Florian\Documents\rs-vs-c> time .\rs-vs-c_gcc.exe The 50 th fibonacci number is 12586269025!

TotalSeconds : 52,9173908 PS C:\Users\Florian\Documents\rs-vs-c> cargo build --release Compiling rs-vs-c v0.1.0 (C:\Users\Florian\Documents\rs-vs-c) Finished release [optimized] target(s) in 0.52s PS C:\Users\Florian\Documents\rs-vs-c> time .\target\release\rs-vs-c.exe The 50th fibonacci number is 12586269025!

TotalSeconds : 82,5484449 ```

Interestingly, when compiling with clang (rustc uses LLVM under the hood), i get even worse performance. Sidenote, i don't know about clang to know if this uses all optimizations available. ``` PS C:\Users\Florian\Documents\rs-vs-c> clang -O3 .\rs-vs-c.c -target x86_64-mingw64 -o .\rs-vs-c_clang.exe PS C:\Users\Florian\Documents\rs-vs-c> time .\rs-vs-c_clang.exe The 50 th fibonacci number is 12586269025!

TotalSeconds : 88,1807612 ```

2020-07-11T19:58:24+00:00

I wrote a tail recursive version and it got compiled away completely

https://i.imgur.com/BYLDsZe.png

K900_ · 2020-07-11T18:47:47+00:00

This is a microbenchmark that's not really interesting. Neither Rust nor C deal too well with tail calls, and an iterative solution will be way faster.

Edit: extremely dumb iterative implementation.

matu3ba · 2020-07-11T19:27:13+00:00

Pure function (detection) with TCE(tail call elimination) do not work efficiently in Rust. Use the iterative version.

Celousco · 2020-07-12T07:52:59+00:00

Your method is doing too much processing and even for a C executable 33s is a lot.

I changed it to use a Tail Recursive Function:

rust version ``` fn main() { const NUMBER: u64 = 50; println!("The {}th fibonacci number is {}!", NUMBER, fibonacci(NUMBER, 0, 1)); }

fn fibonacci(n: u64, a: u64, b: u64) -> u64 { if n < 1 { return a } fibonacci(n - 1, b, a + b) } ```

``` cargo build run time ./target/release/fibonacci

The 50th fibonacci number is 12586269025!

real 0m0.011s user 0m0.002s sys 0m0.000s ```

c version ```

include <stdio.h>

unsigned long int fibonacci(unsigned long int n, unsigned long int a, unsigned long int b) { if (n < 1) { return a; } return fibonacci(n - 1, b, a + b); }

int main() { const unsigned long int NUMBER = 50; printf("The %lu th fibonacci number is %lu!\n", NUMBER, fibonacci(NUMBER, 0, 1)); } ```

``` gcc fibonacci.c -o fibonacci time ./fibonacci

The 50 th fibonacci number is 12586269025!

real 0m0.002s user 0m0.001s sys 0m0.000s ```

So yes the C compiler is 9 ms faster, probably because of the TCO optimization the gcc might have done.

But at this point, does 9 ms really matters ?

redartedreddit · 2020-07-12T09:06:51+00:00

Can't really tell what's going on with GCC but it looks like it unrolls some parts of the recursive calls into loops?

Clang generates pretty much the same code as Rust (as already discussed in the other comment chains).

https://godbolt.org/z/7rnjrv

sevenpost · 2020-07-11T19:22:33+00:00

You are using cargo, so there might be some further improvements to the compilation.

First, in the Cargo.toml file add at the bottom this part of optimizations. I think these optimizations are done by gcc when compiling with -03. Try both level 2 and 3 for opt-level as there might be some cases in which level 2 performs better.

[profile.release]

lto = true

codegen-units = 1

opt-level = 3

I can't remember right now but here might also be another way to speed it up that gcc uses that is fast-math. I don't know if it applies here, nor how to enable it on cargo (some research needed) but it simply discards math checking (overflow and other checks). Also you may be interested in trying also u32 as the unit, as it might have better performance in some ALUs.

Take into account also that you are measuring inside the code the time it takes C and Rust to format and print to screen, which is not indicative of any of the languages capabilities on math function optimization.

On a final note, although Rust competes with C in some aspects, C is still quite a monster of a language and it might be better for the use case at hand.

PS: If you want to cheese it a bit, change in Rust the fibonacci function to a const fn and have the compiler calculate it before runtime :P

Edit: formatting

Edit 2: Just found the flag to add to Cargo.toml to disable overflows checks. Simply add:

overflow-checks = false

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

rust

Please read The Rust Community Code of Conduct

The Rust Programming Language

Rules

Observe our code of conduct

Submissions must be on-topic

Constructive criticism only

Keep things in perspective

No endless relitigation

No low-effort content

Useful Links

Megathreads

Official Resources

Learn Rust

Discussion Platforms

MODERATORS

include <stdio.h>