Initial commit

Author: George Burgess IV

Presentation.pdf

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+)
+
+func main() {
+	const NUM = 50000
+	ch := make(chan int)
+	runtime.GOMAXPROCS(1) // Force 1 process, tops.
+	fmt.Println("Brb, spawning", NUM, "goroutines")
+
+	memStatsNow := runtime.MemStats{}
+	memStatsAfter := runtime.MemStats{}
+	runtime.ReadMemStats(&memStatsNow)
+	startTime := time.Now()
+	for i := 0; i < NUM; i++ {
+		go func(num int) { ch <- num }(i)
+	}
+	duration := time.Since(startTime)
+
+	fmt.Println("Done")
+	fmt.Println("To prove it, we're running", runtime.NumGoroutine(), "goroutines")
+	runtime.ReadMemStats(&memStatsAfter)
+	diff := memStatsAfter.Alloc - memStatsNow.Alloc
+	fmt.Println("That took", duration)
+	fmt.Println("...Which means an average of", duration/(NUM), "per goroutine")
+	fmt.Println("Also,", NUM, "goroutines takes", diff, "bytes")
+	fmt.Println("...Which leaves approx", int(diff/NUM), "bytes allocated for each gorotuine. Tiny, eh?")
+
+	fmt.Println("\nThat's cool. Let's see how long it takes to swap the currently running goroutine", NUM*2, "times.")
+	fmt.Println("In the interest of transparency, GOMAXPROCS =", runtime.GOMAXPROCS(0))
+
+	startTime2 := time.Now()
+	for i := 0; i < NUM; i++ {
+		<-ch
+	}
+	duration2 := time.Since(startTime2)
+
+	fmt.Println("Took", duration2)
+	fmt.Println("...Which means", duration2/(2*NUM), "per goroutine swap")
+	fmt.Println("Pretty good, right?")
+}

benchmark.go

@@ -0,0 +1,183 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+	"time"
+)
+
+func bitonicComp(a, b *int) {
+	if *a >= *b {
+		*b, *a = *a, *b
+	}
+}
+
+func findPowerOfTwo(n int) int {
+	var i int
+	for i = 0; n != 0; i++ {
+		n >>= 1
+	}
+	return i
+}
+
+func bitonicSort(array []int) {
+	lock := &sync.Mutex{}
+	cond := sync.NewCond(lock)
+	numToWait := 0
+
+	incSig := func(howMany int) {
+		lock.Lock()
+		numToWait += howMany
+		lock.Unlock()
+	}
+
+	decSig := func(howMany int) {
+		incSig(-howMany)
+		if numToWait <= 0 {
+			lock.Lock()
+			numToWait = 0
+			cond.Broadcast()
+			lock.Unlock()
+		}
+	}
+
+	blockOrSig := func() {
+		lock.Lock()
+		numToWait -= 1
+		if numToWait == 0 {
+			cond.Broadcast()
+		} else {
+			cond.Wait()
+		}
+		lock.Unlock()
+	}
+
+	var bitonicSliceSecond func([]int, bool)
+	bitonicSliceSecond = func(array []int, wait bool) {
+		jmp := len(array) / 2
+		start := 0
+		end := start + jmp
+		for end < len(array) {
+			bitonicComp(&array[start], &array[end])
+			start++
+			end++
+		}
+
+		if len(array) > 10000 {
+			incBy := 1
+			if wait {
+				incBy++
+			}
+			incSig(1)
+			go bitonicSliceSecond(array[:len(array)/2], true)
+			go bitonicSliceSecond(array[len(array)/2:], true)
+		} else {
+			if len(array) > 2 {
+				bitonicSliceSecond(array[:len(array)/2], false)
+				bitonicSliceSecond(array[len(array)/2:], false)
+			}
+
+			if wait {
+				decSig(1)
+			}
+		}
+	}
+
+	bitonicSliceFirst := func(array []int) {
+		start := 0
+		end := len(array) - 1
+		for end > start {
+			bitonicComp(&array[start], &array[end])
+			start++
+			end--
+		}
+
+		if len(array) > 10000 {
+			incSig(1)
+			go bitonicSliceSecond(array[:len(array)/2], true)
+			go bitonicSliceSecond(array[len(array)/2:], true)
+		} else {
+			if len(array) > 2 {
+				bitonicSliceSecond(array[:len(array)/2], false)
+				bitonicSliceSecond(array[len(array)/2:], false)
+			}
+			decSig(1)
+		}
+	}
+
+	for i := 2; i <= len(array); i <<= 1 {
+		incSig(len(array)/i + 1)
+		for s := 0; s < len(array); s += i {
+			go bitonicSliceFirst(array[s : s+i])
+		}
+		blockOrSig()
+	}
+}
+
+func isSorted(array []int) bool {
+	if len(array) < 2 {
+		return true
+	}
+
+	old := array[0]
+	for _, n := range array[1:] {
+		if n < old {
+			return false
+		}
+		old = n
+	}
+	return true
+}
+
+func parallelIsSorted(array []int, numProcs int) bool {
+	step := len(array) / numProcs
+	chans := []chan bool{}
+	for i := 0; i < numProcs; i++ {
+		c := make(chan bool, 1)
+		chans = append(chans, c)
+		go func(n int) {
+			start := n * step
+			end := (n + 1) * step
+			if n > 0 {
+				start--
+			}
+			if n+1 < numProcs {
+				end++
+			}
+			c <- isSorted(array[start:end])
+			close(c)
+		}(i)
+	}
+
+	for _, c := range chans {
+		if !<-c {
+			return false
+		}
+	}
+	return true
+}
+
+func main() {
+	const PROCS = 4
+	const NUM_ELEMENTS = 1 << 20
+	runtime.GOMAXPROCS(4)
+	array := make([]int, NUM_ELEMENTS)
+	for i := 0; i < NUM_ELEMENTS; i++ {
+		array[i] = NUM_ELEMENTS - i
+	}
+
+	start := time.Now()
+	bitonicSort(array)
+	diff := time.Since(start)
+
+	if parallelIsSorted(array, PROCS) {
+		fmt.Println("Array is sorted in", diff)
+	} else {
+		fmt.Println("NOOOOOOOOOOOOOOOO")
+		for _, n := range array {
+			fmt.Printf("%d ", n)
+		}
+		fmt.Println()
+	}
+}

bitonic.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+)
+
+func main() {
+	buf := bytes.NewBuffer(nil)
+	fmt.Fprintf(buf, "Stop! %s time!", "hammer")
+	fmt.Println("Buffer says:", string(buf.Bytes()))
+}

bufprintf.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+func main() {
+	fmt.Println("Start typing, please.")
+	io.Copy(os.Stdout, os.Stdin)
+}

copy.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+func main() {
+	buf := bytes.NewBuffer(nil)
+	speshulReader := io.TeeReader(os.Stdin, buf)
+	fmt.Println("Type anything!")
+	io.Copy(os.Stdout, speshulReader)
+
+	fmt.Println("Thanks for visiting! Here's a record of everything you typed, courtesy of the NSA:")
+	buf.WriteTo(os.Stdout)
+}

copy2.go

@@ -0,0 +1,26 @@
+package main
+
+import "fmt"
+
+func fibs(c chan int64) {
+	var a, b int64 = 1, 0
+
+	for i := 0; i < 10; i++ {
+		c <- a
+		a, b = a+b, a
+	}
+
+	close(c)
+}
+
+func main() {
+	ch := make(chan int64)
+	go fibs(ch)
+	for i := 0; i < 50; i++ {
+		num, ok := <-ch
+		if !ok {
+			break
+		}
+		fmt.Println("Got fib", num) // ok glass
+	}
+}

fibs.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+)
+
+var nextInt = func() func() *int {
+	i := 0
+	return func() *int {
+		i++
+		next := i
+		return &next
+	}
+}()
+
+func main() {
+	ints := []*int{}
+	for i := 0; i < 100; i++ {
+		ints = append(ints, nextInt())
+	}
+
+	for _, n := range ints {
+		fmt.Println(*n)
+	}
+}