Initial commit

Author: aynp

.gitignore

@@ -0,0 +1,10 @@
+# Counting Primes
+
+Various multithreaded implimentations of counting prime numbers upto a given number.
+
+# Implimentations
+- Serial
+- Range Cluster Global Mutex 
+- Range Cluster Channel
+- Fair Global Mutex
+

README.md

@@ -0,0 +1,41 @@
+package benchmarks
+
+import (
+	"testing"
+
+	"github.com/aynp/counting-primes/config"
+	"github.com/aynp/counting-primes/implementations/precompute"
+	"github.com/aynp/counting-primes/implementations/range_cluster_channel"
+	"github.com/aynp/counting-primes/implementations/range_cluster_global_mutex"
+	"github.com/aynp/counting-primes/implementations/serial"
+)
+
+func BenchmarkSerial(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		serial.CountPrimes(config.MAX_TEST)
+	}
+}
+
+func BenchmarkRangeClusterGlobalMutex(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		range_cluster_global_mutex.CountPrimes(config.MAX_TEST)
+	}
+}
+
+func BenchmarkRangeClusterChannel(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		range_cluster_channel.CountPrimes(config.MAX_TEST)
+	}
+}
+
+func BenchmarkFairGlobalMutex(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		range_cluster_global_mutex.CountPrimes(config.MAX_TEST)
+	}
+}
+
+func BenchmarkPrecompute(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		precompute.CountPrimes(config.MAX_TEST)
+	}
+}

benchmarks/benchmark_test.go

@@ -0,0 +1,5 @@
+package config
+
+var NUM_THREADS = 4
+var MAX_TEST = 1_000_000
+

config/config.go

@@ -0,0 +1,3 @@
+module github.com/aynp/counting-primes
+
+go 1.21.5

go.mod

@@ -0,0 +1,42 @@
+package range_cluster_channel
+
+import (
+	"sync"
+	"sync/atomic"
+
+	"github.com/aynp/counting-primes/config"
+	"github.com/aynp/counting-primes/lib"
+)
+
+var current atomic.Int32
+var totalPrimes atomic.Int32
+
+func worker(max_test int, wg *sync.WaitGroup) {
+	defer wg.Done()
+
+	for {
+		i := current.Add(1)
+		if i > int32(max_test) {
+			break
+		}
+
+		if lib.IsPrime(int(i)) {
+			totalPrimes.Add(1)
+		}
+	}
+}
+
+func CountPrimes(max_test int) int {
+	thread_count := config.NUM_THREADS
+
+	var wg sync.WaitGroup
+
+	current.Store(0)
+	totalPrimes.Store(0)
+
+	for i := 0; i < thread_count; i++ {
+		go worker(max_test, &wg)
+	}
+
+	return int(current.Load())
+}

implementations/fair_global_mutex/count.go

@@ -0,0 +1,24 @@
+package precompute
+
+import (
+	"github.com/aynp/counting-primes/config"
+	"github.com/aynp/counting-primes/lib"
+)
+
+var ans int
+
+func init() {
+	count := 0
+	for i := 0; i < config.MAX_TEST; i++ {
+		if lib.IsPrime(i) {
+			count++
+		}
+	}
+
+	ans = count
+}
+
+// This implimentation is a bit of cheating, but I'll allow it
+func CountPrimes(n int) int {
+	return ans
+}

implementations/precompute/count.go

@@ -0,0 +1,37 @@
+package range_cluster_channel
+
+import (
+	"github.com/aynp/counting-primes/config"
+	"github.com/aynp/counting-primes/lib"
+)
+
+func countPrimesInRange(start, end int, ch chan int) {
+	count := 0
+
+	for i := start; i < end; i++ {
+		if lib.IsPrime(i) {
+			count++
+		}
+	}
+
+	ch <- count
+}
+
+func CountPrimes(n int) int {
+	thread_count := config.NUM_THREADS
+
+	count := 0
+	chunk_size := n / thread_count
+
+	ch := make(chan int, thread_count)
+
+	for i := 0; i < thread_count; i++ {
+		go countPrimesInRange(i*chunk_size, (i+1)*chunk_size, ch)
+	}
+
+	for i := 0; i < thread_count; i++ {
+		count += <-ch
+	}
+
+	return count
+}

implementations/range_cluster_channel/count.go

@@ -0,0 +1,38 @@
+package range_cluster_global_mutex
+
+import (
+	"sync"
+	"sync/atomic"
+
+	"github.com/aynp/counting-primes/config"
+	"github.com/aynp/counting-primes/lib"
+)
+
+var wg sync.WaitGroup
+var count atomic.Int64
+
+func countPrimesInRange(start, end int) {
+	defer wg.Done()
+
+	for i := start; i < end; i++ {
+		if lib.IsPrime(i) {
+			count.Add(1)
+		}
+	}
+}
+
+func CountPrimes(n int) int {
+	count.Store(0)
+
+	thread_count := config.NUM_THREADS
+	chunk_size := n / thread_count
+
+	for i := 0; i < thread_count; i++ {
+		wg.Add(1)
+		go countPrimesInRange(i*chunk_size, (i+1)*chunk_size)
+	}
+
+	wg.Wait()
+
+	return int(count.Load())
+}

implementations/range_cluster_global_mutex/count.go

@@ -0,0 +1,15 @@
+package serial
+
+import (
+	"github.com/aynp/counting-primes/lib"
+)
+
+func CountPrimes(n int) int {
+	count := 0
+	for i := 2; i < n; i++ {
+		if lib.IsPrime(i) {
+			count++
+		}
+	}
+	return count
+}

implementations/serial/count.go

@@ -0,0 +1,12 @@
+package lib
+
+// IsPrime returns true if n is prime, false otherwise.
+// This takes O(sqrt(n)) time.
+func IsPrime(n int) bool {
+	for i := 2; i*i <= n; i++ {
+		if n%i == 0 {
+			return false
+		}
+	}
+	return true
+}