switch to fastrand (not actually any faster)

combinators.nim

@@ -1,5 +1,5 @@
 import algorithm, random, sugar
-import fixedseq, game
+import fastrand, fixedseq, game
 
 
 proc nextPermutation(x: var FixedSeq): bool =
@@ -93,4 +93,4 @@ proc randomFuture*(dice: FixedSeq, r: var Rand): FixedSeq[5, Die, int8] =
   result.initFixedSeq
   let order = dice.dup(shuffle(r))
   for i, color in order:
-    result.add((color, r.rand(1..3)))
+    result.add((color, r.fastRand(1..3)))

config.nims

@@ -1,5 +1,5 @@
-# --threads: on
+--threads: on
-# --d: release
+--d: release
-# --opt: speed
+--opt: speed
-# --passC: -flto
+--passC: -flto
-# --passL: -flto
+--passL: -flto

fastrand.nim

@@ -0,0 +1,74 @@
+import random, math
+import times, std/monotimes, strformat, strutils
+
+
+proc formatNum(n: SomeNumber): string =
+  let s = $(n.round)
+  let t = s[0 .. s.len - 3]
+  var count = 1
+  for i in countdown(t.high, 0):
+    result.insert($t[i], 0)
+    if count mod 3 == 0 and i != 0:
+      result.insert(",", 0)
+    count += 1
+
+
+proc formatRate(n: Natural, d: Duration): string =
+  result = formatNum(1_000_000'f64 * n.float64 / d.inMicroseconds.float64)
+
+
+const upperBound = uint64(uint32.high)
+
+
+proc fastRand*[T: Natural](r: var Rand, x: T): T =
+  # Nim ranges are usually inclusive, but this algorithm is exclusive
+  let x = x.uint64 + 1
+  let num = if x <= upperBound:
+    ((r.next shr 32) * x.uint64) shr 32
+  else:
+    r.next mod x.uint64
+  result = T(num)
+
+
+proc fastRand*(r: var Rand; x, y: Natural): Natural =
+  let lim = (y - x)
+  result = fastRand(r, lim) + x
+
+
+proc fastRand*[T](r: var Rand, slice: HSlice[T, T]): T =
+  let n = fastRand(r, slice.a.Natural, slice.b.Natural)
+  result = T(n)
+
+
+proc testFastRand(num = 1_000_000_000): Duration =
+  var r = initRand(rand(int64))
+  let start = getMonoTime()
+  for i in 1 .. num:
+    discard r.fastRand(5)
+  result = getMonoTime() - start
+  # echo "fastrand execution rate: ",  1000 * num / dur.inMilliseconds.int, " generated per second."
+
+
+proc testStdRand(num = 1_000_000_000): Duration =
+  var r = initRand(rand(int64))
+  let start = getMonoTime()
+  for i in 1 .. num:
+    discard r.rand(4)
+  result = getMonoTime() - start
+  # echo "std rand execution rate: ", 1000 * num / dur.inMilliseconds.int, " generated per second."
+
+
+when isMainModule:
+  randomize()
+  var r = initRand(rand(int64))
+  let runs = 100_000_000
+  var totals: array[5..9, int]
+  for i in 1 .. runs:
+    let n = r.fastRand(5..9)
+    totals[n] += 1
+  echo totals
+
+  # let fr = testFastRand(runs)
+  # echo "fastrand execution rate: ", formatNum(1_000_000 * runs / fr.inMicroseconds.int)
+  # let sr = testStdRand(runs)
+  # echo "standard execution rate: ", formatNum(1_000_000 * runs / sr.inMicroseconds.int)

faststack.nim

@@ -1,197 +0,0 @@
-import bitops, strutils, random
-
-
-proc show(i: SomeInteger, bitlength = 16) =
-  echo BiggestInt(i).toBin(bitlength)
-
-
-type
-  Color = enum
-    cRed, cGreen, cBlue, cYellow, cPurple
-
-  ColorStack = object
-    data: uint16
-    len: uint8
-
-
-const
-  masks = [
-    0'u16, # dummy value just to get the indices right
-    0b0_000_000_000_000_111,
-    0b0_000_000_000_111_111,
-    0b0_000_000_111_111_111,
-    0b0_000_111_111_111_111,
-    0b0_111_111_111_111_111,
-  ]
-
-
-template offset(s: ColorStack, idx: Natural): uint8 =
-  # Compute the bit offset for a given index. 
-  # Dependent on the stack's length.
-  (s.len - 1 - cast[uint8](idx)) * 3
-  # items are stored from left to right but right-aligned, so we
-  # need to shift right to access anything other than the last
-
-
-template offset(s: ColorStack, idx: BackwardsIndex): uint8 =
-  # for backwards index, we are still shifting right but
-  # the lower the index the less we have to shift
-  (cast[uint8](idx) - 1) * 3
-
-
-proc add(s: var ColorStack, c: Color) =
-  # e.g. if stack is 0b0000000000000100:
-  # and color is 0b00000011
-  # shift: 0b0000000000100000
-  # bitor: 0b0000000000100000 and 0b00000011
-  # results in 0b0000000000100011
-  s.data = (s.data shl 3).bitor(cast[uint8](c))
-  inc s.len
-
-
-proc high(s: ColorStack): uint8 = s.len - 1
-
-proc low(s: ColorStack): uint8 = 0 # just... always 0, I guess
-
-
-proc `[]`(s: ColorStack, i: uint8 | BackwardsIndex): Color =
-  # shift, then mask everything but the three rightmost bits
-  result = cast[Color](
-    (s.data shr s.offset(i)) and masks[1]
-  )
-
-
-proc `[]=`(s: var ColorStack, i: uint8 | BackwardsIndex, c: Color) =
-  let offset = s.offset(i)
-  s.data = (s.data and bitnot(masks[1] shl offset)) or (cast[uint16](c) shl offset)
-
-
-iterator items(s: ColorStack): Color =
-  # s.len is unsigned so it will wrap around if we do s.len - 1 in that case
-  if s.len != 0:
-    for i in countdown(s.len - 1, 0'u8):
-      yield cast[Color]((s.data shr (i * 3)) and masks[1])
-
-
-iterator pairs(s: ColorStack): (int, Color) =
-  var count = 0
-  for color in s:
-    yield (count, color)
-    inc count
-
-
-proc find(s: ColorStack, needle: Color): uint8 =
-  for i in 0'u8 .. s.high:
-    if s[i] == needle:
-      return i
-
-
-proc moveSubstack(src, dst: var ColorStack, nToMove: uint8) =
-  # Moves a sub-stack from the top of src to the top of dst
-  # shift the dst stack by the length of the substack to make room
-  let shift = nToMove * 3
-  dst.data = dst.data shl shift
-  # then we mask the source data to present only the items 
-  # being moved, and OR that with the shifted dst data
-  dst.data = dst.data or (src.data and masks[src.len])
-  dst.len += nToMove
-  # then we shift the source to get rid of the moved items
-  src.data = src.data shr shift
-  src.len -= nToMove
-
-
-proc moveSubstackPre(src, dst: var ColorStack, nToMove: uint8) =
-  # Moves a sub-stack from the top of src to the bottom of dst
-  # shift src stack to position substack above its destination,
-  # get rid of everything to the left of the substack,
-  # and OR that with the existing dst data
-  dst.data = dst.data or ( (src.data shl (dst.len * 3)) and masks[src.len])
-  dst.len += nToMove
-  # get rid of the substack we just moved
-  src.data = src.data shr (nToMove * 3)
-  src.len -= nToMove
-
-
-proc swap(s: var ColorStack, i1, i2: uint8) =
-  # Swap the values at two indices in the stack
-  if i1 == i2: return
-
-  # i1 and i2 are unsigned, so we have to watch out for underflows
-  let diff = if i1 > i2:
-    (i1 - i2) * 3
-  else:
-    (i2 - i1) * 3
-
-  # take masks[1] from above (rightmost position) and shift to position of i1.
-  # then do the same for i2, and OR them together.
-  let mask = (masks[1] shl s.offset(i1)) or (masks[1] shl s.offset(i2))
-  # get rid of everything but the two values we're swapping
-  let masked = s.data and mask
-  # shift by the distance between values in both directions, combine, then mask
-  let swapped = ((masked shl diff) or (masked shr diff)) and mask
-  # finally, AND with the inverse of mask so that only the values being 
-  # swapped are erased, and combine that with the swapped values
-  s.data = (s.data and mask.bitnot) or swapped
-
-
-proc shuffle(r: var Rand, s: var ColorStack) =
-  # Fisher-Yates shuffle
-  for i in countdown(s.high, 1'u8):
-    let j = cast[uint8](r.rand(i))
-    if j != i:
-      s.swap(i, j)
-
-
-proc reverse(s: var ColorStack, first, last: uint8) =
-  var x = first
-  var y = last
-  while x < y:
-    s.swap(x, y)
-    inc x
-    dec y
-
-
-proc asInt(s: ColorStack): uint16 = s.data
-
-
-proc `$`(s: ColorStack): string =
-  result = "St@["
-  for c in s:
-    if result[^1] != '[':
-      result.add(", ")
-    result.add($c)
-  result.add("]")
-
-
-var one: ColorStack
-one.add(cRed)
-one.add(cGreen)
-one.add(cBlue)
-one.add(cYellow)
-one.add(cPurple)
-
-var two: ColorStack
-# two.add(cPurple)
-two.add(cRed)
-# two.add(cYellow)
-
-echo "one: ", one
-# echo "two: ", two
-
-one.reverse(0, 4)
-echo "one: ", one
-# one[^2] = cPurple
-# echo "one: ", one
-
-# echo "one 0: ", one[0]
-# echo "one 2: ", one[2]
-# echo "one 3: ", one[3]
-
-# echo "one ^1: ", one[^1]
-# echo "one ^2: ", one[^2]
-# echo "one ^4: ", one[^4]
-
-# echo "<move>"
-# moveSubstack(one, two, 2)
-# echo "one: ", one
-# echo "two: ", two

test.nim

@@ -43,13 +43,13 @@ proc newRandomGame(r: var Rand): Board =
   result.setState(dice, [])
 
 
-proc games(nTests, nSamples: SomeInteger): TestResults =
+proc games(nTests, nSamples: SomeInteger, parallel = true): TestResults =
   var r = getRand()
   var scores: ScoreSet
   for i in 1 .. nTests:
     let b = newRandomGame(r)
     let dur = executionTime:
-      let s = b.randomGames(nSamples)
+        let s = b.randomGames(nSamples, parallel = parallel)
     result.ops += s.sum()
     result.time += dur
 
@@ -94,17 +94,4 @@ proc testSpread(nTests, nSamples: Natural) =
 
 
 when isMainModule:
-  games(100, 1_000_000).summarize()
+  games(10, 10_000_000).summarize()
-  # let start_states = 2_000
-  # let executionTime = testLegs(start_states)
-  # echo "Execution time: ", executionTime
-  # echo "Leg simulations per second: ", float(start_states * 29_160) / executionTime
-
-  # for i in 1 .. 1:
-  #   let num_games = 100_000_005
-  #   let executionTime = testGames(num_games)
-  #   echo "Execution time: ", executionTime
-  #   echo "Full-game simulations per second: ", float(num_games) / executionTime
-  #   echo ""
-
-  # testSpread(100, 1_000_000)