initial commit

Author: nklizhe

.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+bin

concurrency/README.md

@@ -0,0 +1,23 @@
+# Concurrency
+
+This tests compares Rust and Go on concurrent code.
+
+# Run Test
+```
+./build-and-run.sh
+```
+
+1. hello1 creates 10 concurrent rountines and print hello to the stdout
+2. hello2 creates 1000 concurrent routines and print hello to the stdout
+
+# Testing Result
+|  # | Go  |  Rust | Ruby  |
+|---|---|---|---|
+|  10 | 0.23s  | 0.14s  | 0.170s   |
+|  1000 | 0.21s  | 0.97s  | 14.895s  |
+
+* Testing platform: Macbook Air (Late 2010). Processor: 2.13 GHz Intel Core 2 Duo, Memory: 4 GB 1067 MHz DDR3
+
+# Conclusion
+
+The result clearly shows that Go's `goroutine` is more lightweight and faster than Rust's `spawn` or Ruby's Thread.

concurrency/build_and_run.sh

@@ -0,0 +1,38 @@
+#!/bin/sh -e
+
+# Build
+mkdir -p bin
+go build -o bin/hello1_go go/hello1/main.go
+go build -o bin/hello2_go go/hello2/main.go
+rustc -o bin/hello1_rust rust/hello1.rs
+rustc -o bin/hello2_rust rust/hello2.rs
+
+# Run
+
+echo
+echo "## Go"
+echo "###   hello1:"
+time bin/hello1_go > /tmp/hello1_go.out
+
+echo
+echo "###   hello2:"
+time bin/hello2_go > /tmp/hello2_go.out
+
+echo
+echo "## Rust"
+echo "###   hello1"
+time bin/hello1_rust > /tmp/hello1_rust.out
+
+echo
+echo "###   hello2"
+time bin/hello2_rust > /tmp/hello2_rust.out
+
+echo
+echo "## Ruby"
+echo "###   hello1"
+time ruby ruby/hello1.rb > /tmp/hello1_ruby.out
+
+echo
+echo "###   hello2"
+time ruby ruby/hello2.rb > /tmp/hello2_ruby.out
+

concurrency/go/hello1/main.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func main() {
+	quitSignal := make(chan int)
+
+	greetings := "hello"
+	for i := 0; i < 1000; i++ {
+		go func(i int, signal chan int) {
+            fmt.Printf("%s from goroutine          number %d\n", greetings, i)
+			signal <- 1
+		}(i, quitSignal)
+	}
+
+	// make the program don't exit until all
+	// 10 goroutines are finished
+	for i := 0; i < 1000; i++ {
+		<-quitSignal
+	}
+}

concurrency/go/hello2/main.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func main() {
+	quitSignal := make(chan int)
+
+	greetings := "hello"
+	for i := 0; i < 1000; i++ {
+		go func(i int, signal chan int) {
+            fmt.Printf("%s from goroutine          number %d\n", greetings, i)
+			signal <- 1
+		}(i, quitSignal)
+	}
+
+	// make the program don't exit until all
+	// 10 goroutines are finished
+	for i := 0; i < 1000; i++ {
+		<-quitSignal
+	}
+}

concurrency/go/main

@@ -0,0 +1,18 @@
+count = 0
+
+10.times do |i|
+  Thread.new do
+    greeting_message = "Hello"
+
+    # This is weird in Ruby but it's closer to the println! macro
+    # usage in the Rust example.
+    puts "#{greeting_message} from lightweight thread number #{i}\n"
+
+    count = count + 1
+  end
+end
+
+# wait for all thread finishes
+while count < 10 do
+    # do nothing
+  end

concurrency/ruby/hello1.rb

@@ -0,0 +1,18 @@
+count = 0
+
+1000.times do |i|
+  Thread.new do
+    greeting_message = "Hello"
+
+    # This is weird in Ruby but it's closer to the println! macro
+    # usage in the Rust example.
+    puts "#{greeting_message} from lightweight thread number #{i}\n"
+
+    count = count + 1
+  end
+end
+
+# wait for all thread finishes
+while count < 1000 do
+    # do nothing
+  end

concurrency/ruby/hello2.rb

@@ -0,0 +1,15 @@
+/* This function creates ten "tasks" that all execute concurrently.
+   To verify this, run the program several times and observe the irregular
+   order in which each task's output is printed. */
+fn main() {
+    // This string is immutable, so it can safely be accessed from multiple tasks.
+    let greeting = "Hello";
+    // `for` loops work with any type that implements the `Iterator` trait.
+    for num in range(0i, 10) {
+        spawn(proc() {
+            // `println!` is a macro that statically typechecks a format string.
+            // Macros are structural (as in Scheme) rather than textual (as in C).
+            println!("{:s} from lightweight thread number {:i}", greeting, num);
+        });
+    }
+}

concurrency/rust/hello1.rs

@@ -0,0 +1,15 @@
+/* This function creates ten "tasks" that all execute concurrently.
+   To verify this, run the program several times and observe the irregular
+   order in which each task's output is printed. */
+fn main() {
+    // This string is immutable, so it can safely be accessed from multiple tasks.
+    let greeting = "Hello";
+    // `for` loops work with any type that implements the `Iterator` trait.
+    for num in range(0i, 1000) {
+        spawn(proc() {
+            // `println!` is a macro that statically typechecks a format string.
+            // Macros are structural (as in Scheme) rather than textual (as in C).
+            println!("{:s} from lightweight thread number {:i}", greeting, num);
+        });
+    }
+}