Threading Performance Comparison

goroutines.go

package main

import (
	"fmt"
	"os"
	"runtime"
	"sync"
	"time"
)

func compute() {
	wg := sync.WaitGroup{}
	wg.Add(1000)
	for i := 0; i < 1000; i++ {
		go func() {
			defer wg.Done()
			buffer := make([]byte, 10)
			devUrandom, err := os.Open("/dev/urandom")
			if err != nil {
				panic(err)
			}
			if _, err = devUrandom.Read(buffer); err != nil {
				panic(err)
			}
			if err = devUrandom.Close(); err != nil {
				panic(err)
			}
			devNull, err := os.Create("/dev/null")
			if err != nil {
				panic(err)
			}
			if _, err = devNull.Write(buffer); err != nil {
				panic(err)
			}
			if err = devNull.Close(); err != nil {
				panic(err)
			}
		}()
	}
	wg.Wait()
	runtime.GC()
}

func main() {
	// warmup
	compute()

	before := time.Now()
	for i := 0; i < 1000; i++ {
		compute()
	}
	elapsed := time.Now().Sub(before)
	fmt.Println(elapsed, "total,", elapsed/1000, "avg per iteration")
}

rust_threads.rs

use std::time::Instant;
use std::{
    fs::File,
    io::{Read, Write},
    thread::JoinHandle,
};

fn compute() {
    let handles: Vec<JoinHandle<_>> = (0..1000)
        .map(|_| {
            std::thread::spawn(move || {
                let mut buffer = [0; 10];
                {
                    let mut dev_urandom = File::open("/dev/urandom").unwrap();
                    dev_urandom.read(&mut buffer).unwrap();
                }
                let mut dev_null = File::create("/dev/null").unwrap();
                dev_null.write(&mut buffer).unwrap();
            })
        })
        .collect();
    for handle in handles {
        handle.join().unwrap();
    }
}

fn main() {
    // warmup
    compute();

    let before = Instant::now();
    for _ in 0..1000 {
        compute();
    }
    let elapsed = before.elapsed();
    println!(
        "{:?} total, {:?} avg per iteration",
        elapsed,
        elapsed / 1000
    );
}

rust_tokio.rs

use std::time::Instant;
use tokio::{
    fs::File,
    io::{AsyncReadExt, AsyncWriteExt},
    task::JoinHandle,
};

async fn compute() {
    let handles: Vec<JoinHandle<_>> = (0..1000)
        .map(|_| {
            tokio::spawn(async move {
                let mut buffer = [0; 10];
                {
                    let mut dev_urandom = File::open("/dev/urandom").await.unwrap();
                    dev_urandom.read(&mut buffer).await.unwrap();
                }
                let mut dev_null = File::create("/dev/null").await.unwrap();
                dev_null.write(&mut buffer).await.unwrap();
            })
        })
        .collect();
    for handle in handles {
        handle.await.unwrap();
    }
}

#[tokio::main]
async fn main() {
    // warmup
    compute().await;

    let before = Instant::now();
    for _ in 0..1000 {
        compute().await;
    }
    let elapsed = before.elapsed();
    println!(
        "{:?} total, {:?} avg per iteration",
        elapsed,
        elapsed / 1000
    );
}