Initial data commit

Task/Atomic-updates/F-Sharp/atomic-updates-1.fs

@@ -0,0 +1,73 @@
+open System.Threading
+
+type Buckets(n) =
+  let rand = System.Random()
+  let mutex = Array.init n (fun _ -> new Mutex())
+  let bucket = Array.init n (fun _ -> 100)
+
+  member this.Count = n
+
+  member this.Item n = bucket.[n]
+
+  member private this.Lock is k =
+    let is = Seq.sort is
+    for i in is do
+      mutex.[i].WaitOne() |> ignore
+    try k() finally
+    for i in is do
+      mutex.[i].ReleaseMutex()
+
+  member this.Transfer i j d =
+    if i <> j && d <> 0 then
+      let i, j, d = if d > 0 then i, j, d else j, i, -d
+      this.Lock [i; j] (fun () ->
+        let d = min d bucket.[i]
+        bucket.[i] <- bucket.[i] - d
+        bucket.[j] <- bucket.[j] + d)
+
+  member this.Read =
+    this.Lock [0..n-1] (fun () -> Array.copy bucket)
+
+  member this.Print() =
+    let xs = this.Read
+    printf "%A = %d\n" xs (Seq.sum xs)
+
+  interface System.IDisposable with
+    member this.Dispose() =
+      for m in mutex do
+        (m :> System.IDisposable).Dispose()
+
+let transfers = ref 0
+let max_transfers = 1000000
+
+let rand_pair (rand: System.Random) n =
+  let i, j = rand.Next n, rand.Next(n-1)
+  i, if j<i then j else j+1
+
+let equalizer (bucket: Buckets) () =
+  let rand = System.Random()
+  while System.Threading.Interlocked.Increment transfers < max_transfers do
+    let i, j = rand_pair rand bucket.Count
+    let d = (bucket.[i] - bucket.[j]) / 2
+    if d > 0 then
+      bucket.Transfer i j d
+    else
+      bucket.Transfer j i -d
+
+let randomizer (bucket: Buckets) () =
+  let rand = System.Random()
+  while System.Threading.Interlocked.Increment transfers < max_transfers do
+    let i, j = rand_pair rand bucket.Count
+    let d = 1 + rand.Next bucket.[i]
+    bucket.Transfer i j d
+
+do
+  use bucket = new Buckets(10)
+  let equalizer = Thread(equalizer bucket)
+  let randomizer = Thread(randomizer bucket)
+  bucket.Print()
+  equalizer.Start()
+  randomizer.Start()
+  while !transfers < max_transfers do
+    Thread.Sleep 100
+    bucket.Print()

Task/Atomic-updates/F-Sharp/atomic-updates-2.fs

@@ -0,0 +1,58 @@
+[|100; 100; 100; 100; 100; 100; 100; 100; 100; 100|] = 1000
+[|119; 61; 138; 115; 157; 54; 82; 58; 157; 59|] = 1000
+[|109; 90; 78; 268; 55; 104; 91; 46; 105; 54|] = 1000
+[|101; 75; 38; 114; 161; 160; 2; 234; 14; 101|] = 1000
+[|104; 30; 114; 37; 32; 117; 50; 236; 127; 153|] = 1000
+[|102; 32; 6; 55; 367; 69; 157; 80; 77; 55|] = 1000
+[|211; 12; 319; 18; 11; 25; 73; 154; 154; 23|] = 1000
+[|23; 373; 110; 108; 64; 33; 109; 8; 63; 109|] = 1000
+[|72; 106; 174; 99; 115; 141; 98; 63; 123; 9|] = 1000
+[|188; 67; 271; 30; 76; 134; 1; 74; 91; 68|] = 1000
+[|2; 46; 240; 198; 63; 63; 113; 57; 136; 82|] = 1000
+[|5; 151; 11; 191; 88; 236; 14; 0; 152; 152|] = 1000
+[|162; 97; 102; 97; 122; 123; 0; 86; 84; 127|] = 1000
+[|9; 11; 204; 50; 169; 206; 137; 26; 137; 51|] = 1000
+[|175; 55; 157; 150; 116; 54; 10; 168; 114; 1|] = 1000
+[|73; 85; 124; 3; 63; 62; 189; 115; 172; 114|] = 1000
+[|112; 102; 253; 124; 39; 67; 197; 77; 20; 9|] = 1000
+[|139; 172; 102; 1; 101; 64; 127; 55; 92; 147|] = 1000
+[|54; 72; 130; 31; 99; 99; 130; 38; 186; 161|] = 1000
+[|90; 0; 43; 46; 84; 335; 77; 79; 90; 156|] = 1000
+[|20; 7; 128; 115; 24; 26; 128; 105; 240; 207|] = 1000
+[|42; 79; 45; 60; 312; 37; 26; 61; 47; 291|] = 1000
+[|176; 25; 10; 44; 126; 268; 78; 94; 46; 133|] = 1000
+[|117; 153; 74; 63; 214; 44; 43; 93; 96; 103|] = 1000
+[|56; 11; 106; 54; 1; 135; 174; 140; 174; 149|] = 1000
+[|84; 153; 108; 77; 118; 140; 96; 102; 103; 19|] = 1000
+[|59; 64; 85; 118; 215; 127; 42; 42; 120; 128|] = 1000
+[|147; 95; 175; 116; 117; 0; 74; 116; 117; 43|] = 1000
+[|131; 24; 128; 140; 45; 139; 155; 23; 68; 147|] = 1000
+[|63; 184; 70; 24; 64; 84; 254; 14; 184; 59|] = 1000
+[|119; 0; 234; 0; 98; 130; 94; 53; 99; 173|] = 1000
+[|101; 0; 114; 129; 162; 176; 86; 84; 64; 84|] = 1000
+[|95; 49; 57; 38; 73; 153; 276; 10; 147; 102|] = 1000
+[|109; 182; 3; 147; 81; 107; 2; 142; 147; 80|] = 1000
+[|45; 2; 103; 43; 103; 79; 65; 314; 57; 189|] = 1000
+[|86; 86; 202; 47; 69; 11; 31; 246; 157; 65|] = 1000
+[|82; 27; 107; 86; 106; 182; 64; 120; 82; 144|] = 1000
+[|32; 158; 248; 50; 83; 109; 85; 16; 134; 85|] = 1000
+[|49; 15; 246; 68; 69; 13; 219; 123; 130; 68|] = 1000
+[|125; 133; 70; 23; 266; 30; 30; 44; 44; 235|] = 1000
+[|18; 40; 174; 145; 146; 131; 62; 46; 138; 100|] = 1000
+[|24; 128; 64; 104; 65; 109; 231; 101; 87; 87|] = 1000
+[|107; 82; 40; 8; 133; 110; 180; 82; 102; 156|] = 1000
+[|129; 122; 122; 52; 22; 143; 45; 49; 217; 99|] = 1000
+[|15; 13; 71; 55; 55; 120; 115; 192; 192; 172|] = 1000
+[|3; 95; 136; 76; 74; 37; 309; 44; 137; 89|] = 1000
+[|14; 185; 47; 47; 97; 164; 180; 74; 98; 94|] = 1000
+[|152; 145; 148; 83; 27; 35; 35; 77; 289; 9|] = 1000
+[|78; 133; 147; 148; 83; 84; 142; 21; 141; 23|] = 1000
+[|101; 63; 94; 168; 63; 90; 55; 94; 209; 63|] = 1000
+[|73; 131; 182; 172; 130; 43; 102; 102; 5; 60|] = 1000
+[|84; 61; 102; 9; 164; 175; 56; 4; 266; 79|] = 1000
+[|89; 95; 29; 78; 200; 82; 152; 87; 101; 87|] = 1000
+[|32; 33; 100; 7; 132; 75; 134; 234; 85; 168|] = 1000
+[|197; 53; 81; 27; 1; 264; 100; 130; 34; 113|] = 1000
+[|120; 198; 102; 51; 102; 64; 178; 45; 64; 76|] = 1000
+[|208; 147; 18; 25; 178; 159; 23; 170; 36; 36|] = 1000
+Press any key to continue . . .