Parallel Flashcards
Skriv ett program i Go som skapar en goroutine som skriver ut en text på skärmen
```go
package main
import (“fmt”)
func main() {
go func() { fmt.Println(“Hej”) }()
}
~~~
Skriv ett program i Go som läser ett värde från en kanal och skriver ut det på skärmen
```go
package main
import (“fmt”)
func main() {
ch := make(chan string)
go func() { ch <- “Hej” }()
fmt.Println(<-ch)
}
~~~
Var är GIL i Python och hur påverkar det trådade program i Python?
GIL (Global Interpreter Lock) finns i Python och förhindrar flera trådar från att köra Python-kod samtidigt, vilket begränsar parallell prestanda.
Skriv ett program i Go som kan ge upphov till ett data race
```go
package main
import (“fmt”)
func main() {
var x int
go func() { x++ }()
go func() { x++ }()
fmt.Println(x)
}
~~~
Implementera Peterson’s algorithm i Go-liknande kod.
```go
var flag [2]bool
var turn int
func enterCriticalSection(id int) {
flag[id] = true
turn = 1 - id
for flag[1-id] && turn == 1-id {}
}
func leaveCriticalSection(id int) {
flag[id] = false
}
~~~
Implementera en producent i Go-liknande kod som använder mutex för ömesidig uteslutning
```go
var mu sync.Mutex
func producer(data *int) {
mu.Lock()
*data++
mu.Unlock()
}
~~~
Implementera en producent i Go-liknande kod som använder kanaler för ömesidig uteslutning
```go
func producer(ch chan int) {
ch <- 1
}
~~~
Ge ett exempel i Go där två goroutines delar en variabel och använder en mutex för att (korrekt) skydda tillgången
```go
package main
import (“sync”)
func main() {
var x int
var mu sync.Mutex
go func() {
mu.Lock()
x++
mu.Unlock()
}()
}
~~~
Ge ett exempel på ett program i Go med kanaler som kan leda till deadlock
```go
package main
func main() {
ch := make(chan int)
ch <- 1
<-ch
}
~~~
Ge ett exempel på ett program i Go utan kanaler som kan leda till deadlock
```go
package main
import (“sync”)
func main() {
var mu sync.Mutex
mu.Lock()
mu.Lock()
}
~~~
Implementera en parallel prefix sum med goroutines i Go
```go
func prefixSum(arr []int) []int {
for i := 1; i < len(arr); i++ {
arr[i] += arr[i-1]
}
return arr
}
~~~
Implementera en parallel prefix scan med goroutines i Go
```go
func prefixScan(arr []int) []int {
for i := 1; i < len(arr); i++ {
arr[i] += arr[i-1]
}
return arr
}
~~~
Implementera en parallel odd-even transposition sort med goroutines i Go
```go
func oddEvenSort(arr []int) {
sorted := false
for !sorted {
sorted = true
for i := 1; i < len(arr)-1; i += 2 {
if arr[i] > arr[i+1] {
arr[i], arr[i+1] = arr[i+1], arr[i]
sorted = false
}
}
for i := 0; i < len(arr)-1; i += 2 {
if arr[i] > arr[i+1] {
arr[i], arr[i+1] = arr[i+1], arr[i]
sorted = false
}
}
}
}
~~~
Visa hur en for-loop kan paralleliseras i Go med goroutines
```go
package main
import (“sync”)
func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
println(i)
}(i)
}
wg.Wait()
}
~~~
Hur kan en barrier implementeras med mutex? Visa i Go-liknande kod
```go
var mu sync.Mutex
var count int
func barrier() {
mu.Lock()
count++
mu.Unlock()
for count < N {}
}
~~~
Hur kan en barrier implementeras med kanaler? Visa i Go-liknande kod
```go
func barrier(ch chan int, N int) {
ch <- 1
if len(ch) == N {
close(ch)
}
}
~~~
Ge en concurrent/parallel algoritm för att hitta den minsta värdet i en lista i Go-liknande kod
```go
func findMin(arr []int) int {
min := arr[0]
for _, v := range arr {
if v < min {
min = v
}
}
return min
}
~~~
Vad innebär en atomär variabel i Go
En atomär variabel är en variabel som kan ändras utan risk för data race, tack vare atomära operationer.
Visa hur en variabels värde kan jämföras och bytas atomärt i Go
```go
import “sync/atomic”
var x int32
atomic.CompareAndSwapInt32(&x, 0, 1)
~~~
Förklara vad happens before i en minnesmodell
Happens before är en relation som garanterar att en operation utförs före en annan i en flertrådad miljö.
Vilka antaganden kan göras om två trådar modifierar en delad variabel (enligt Javas minnesmodell)
Inga antaganden kan göras utan synkronisering, eftersom det kan leda till data race.
Förklara begreppet multicore cpu
En multicore CPU har flera processorkärnor som kan köra flera trådar samtidigt.
Vad är skillnaden mellan concurrency och parallelism?
Concurrency är att hantera flera uppgifter samtidigt, medan parallelism är att utföra flera uppgifter samtidigt.
