switch to bitshifting operations (turns out to be slower, oh well)

colors.nim

@@ -0,0 +1,17 @@
+type
+  Color* = enum
+    cRed, cGreen, cBlue, cYellow, cPurple
+
+
+const 
+  colorNames: array[Color, string] =
+    ["Red", "Green", "Blue", "Yellow", "Purple"]
+  colorAbbrevs: array[Color, char] = ['R', 'G', 'B', 'Y', 'P']
+
+
+proc `$`*(c: Color): string =
+  result = colorNames[c]
+
+
+proc abbrev*(c: Color): char =
+  result = colorAbbrevs[c]

config.nims

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

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

fixedseq.nim

@@ -25,6 +25,16 @@ proc `$`*(s: FixedSeq): string =
   result.add("]")
 
 
+proc `==`*[T1: FixedSeq, T2: FixedSeq](a: T1, b: T2): bool =
+  # generics are so that we can compare ShiftStack vs regular FixedSeq
+  if a.len != b.len:
+    return false
+  for i in 0 ..< a.len:
+    if a.data[i] != b.data[i]:
+      return false
+  return true
+
+
 proc `[]`*(s: FixedSeq, i: Natural): FixedSeq.Contents =
   if i > s.last:
     raise newException(IndexDefect, "index " & $i & " is out of bounds.")
@@ -124,7 +134,7 @@ proc shuffle*(s: var FixedSeq, r: var Rand) =
 
 
 proc moveSubstack*(src, dst: var FixedSeq; start: Natural) =
-  var count: typeof(src.last) = 0 # have to track this separately apparently
+  var count: FixedSeq.Pointer = 0 # have to track this separately apparently
   for idx in start .. src.last:
     swap(src.data[idx], dst.data[dst.last + 1 + count])
     inc count
@@ -133,7 +143,7 @@ proc moveSubstack*(src, dst: var FixedSeq; start: Natural) =
 
 
 proc moveSubstackPre*(src, dst: var FixedSeq; start: Natural) =
-  let ssLen = typeof(src.last)(src.last - start + 1) # length of substack
+  let ssLen = FixedSeq.Pointer(src.last - start + 1) # length of substack
   for i in countdown(dst.last, 0):
     swap(dst.data[i], dst.data[i + ssLen])
 
@@ -144,3 +154,5 @@ proc moveSubstackPre*(src, dst: var FixedSeq; start: Natural) =
 
   dst.last += ssLen
   src.last -= ssLen
+
+include shiftstack

game.nim

@@ -1,11 +1,9 @@
 import hashes, options
-import fixedseq
+import fixedseq, colors
+export colors
 
 
 type
-  Color* = enum
-    cRed, cGreen, cBlue, cYellow, cPurple
-
   ColorStack* = FixedSeq[5, Color, int8]
 
 
@@ -13,27 +11,7 @@ proc initColorStack*: ColorStack =
   result.initFixedSeq
 
 
-proc getAllColors: ColorStack = 
-  var i = 0
-  for c in Color.low .. Color.high:
-    result[i] = c
-
-const 
-  allColors* = getAllColors()
-  colorNames: array[Color, string] =
-    ["Red", "Green", "Blue", "Yellow", "Purple"]
-  colorAbbrevs: array[Color, char] = ['R', 'G', 'B', 'Y', 'P']
-
-
-proc `$`*(c: Color): string =
-  result = colorNames[c]
-
-
-proc abbrev*(c: Color): char =
-  result = colorAbbrevs[c]
-
-
-proc `$`*(s: ColorStack): string =
+proc `$`*[T](s: FixedSeq[T, Color, int8]): string =
   result.add("St@[")
   for i, color in s:
     result.add($color)
@@ -50,7 +28,7 @@ type
     tForward = 1
 
   Square* = object
-    camels*: ColorStack
+    camels*: ShiftStack
     tile*: Option[Tile]
 
   Board* = object

shiftstack.nim

@@ -0,0 +1,191 @@
+# optimized bit-shifting versions of the FixedSequence substack operations
+import bitops, macros
+import colors
+
+
+macro show(expr: untyped) =
+  let node = expr.toStrLit
+  quote do:
+    echo `node`, " => ", `expr`
+
+
+proc getMasks(): (array[9, uint64], array[9, uint64]) =
+  # on little-endian architectures, casting an array[8, Color] to uint64 effectively
+  # reverses it. So we switch these masks so that we can refer to them consistently.
+  let 
+    left = [
+      0'u64,
+      0xff_00_00_00_00_00_00_00'u64,
+      0xff_ff_00_00_00_00_00_00'u64,
+      0xff_ff_ff_00_00_00_00_00'u64,
+      0xff_ff_ff_ff_00_00_00_00'u64,
+      0xff_ff_ff_ff_ff_00_00_00'u64,
+      0xff_ff_ff_ff_ff_ff_00_00'u64,
+      0xff_ff_ff_ff_ff_ff_ff_00'u64,
+      0xff_ff_ff_ff_ff_ff_ff_ff'u64,
+    ]
+    right = [
+      0'u64,
+      0x00_00_00_00_00_00_00_ff'u64,
+      0x00_00_00_00_00_00_ff_ff'u64,
+      0x00_00_00_00_00_ff_ff_ff'u64,
+      0x00_00_00_00_ff_ff_ff_ff'u64,
+      0x00_00_00_ff_ff_ff_ff_ff'u64,
+      0x00_00_ff_ff_ff_ff_ff_ff'u64,
+      0x00_ff_ff_ff_ff_ff_ff_ff'u64,
+      0xff_ff_ff_ff_ff_ff_ff_ff'u64,
+    ]
+  when cpuEndian == bigEndian:
+    result = (left, right)
+  when cpuEndian == littleEndian:
+    result = (right, left)
+
+
+type ShiftStack* = FixedSeq[8, Color, int8]
+const (masksLeft, masksRight) = getMasks()
+
+
+template `shl`(a: array[8, Color], offset: Natural): array[8, Color] =
+  when cpuEndian == bigEndian:
+    cast[array[8, Color]](cast[uint64](a) shl (offset * 8))
+  when cpuEndian == littleEndian: # direction is reversed
+    cast[array[8, Color]](cast[uint64](a) shr (offset * 8))
+
+
+template `shr`(a: array[8, Color], offset: Natural): array[8, Color] =
+  when cpuEndian == bigEndian:
+    cast[array[8, Color]](cast[uint64](a) shr (offset * 8))
+  when cpuEndian == littleEndian:
+    cast[array[8, Color]](cast[uint64](a) shl (offset * 8))
+
+
+template `and`(a: array[8, Color], mask: uint64): array[8, Color] =
+  cast[array[8, Color]](cast[uint64](a) and mask)
+
+
+template `or`(a: array[8, Color], mask: uint64): array[8, Color] =
+  cast[array[8, Color]](cast[uint64](a) or mask)
+
+
+template `or`(a: array[8, Color], mask: array[8, Color]): array[8, Color] =
+  cast[array[8, Color]](cast[uint64](a) or cast[uint64](mask))
+
+
+import strutils # remove later
+proc moveSubstack*(src, dst: var ShiftStack; start: Natural) =
+  # shift the source stack to position the substack above its final resting place
+  # offset is the length of the destination stack, minus the number of items NOT being moved
+  # number of items not being moved is the same as the start index
+  var substack: array[8, Color] 
+  if dst.len == start: # no shift necessary in this case
+    substack = src.data
+  elif dst.len > start:
+    substack = src.data shr (dst.len - start)
+  elif dst.len < start:
+    substack = src.data shl (start - dst.len)
+  # next, mask the source data to present only the items being moved
+  # dst.len of 0 corresponds to last mask in masksRight, aka masksRight[^1]
+  substack = substack and masksRight[^(dst.len + 1)]
+  # then combine
+  dst.data = dst.data or substack
+  # then git rid of the moved items from the source stack
+  src.data = src.data and masksLeft[start]
+  # a little bookkeeping
+  let ssLen = int8(src.len - start)
+  src.last -= ssLen
+  dst.last += ssLen
+
+
+proc moveSubstackPre*(src, dst: var ShiftStack; start: Natural) =
+  let ssLen = int8(src.len - start)
+  # shift the destination stack to make room for the new items
+  dst.data = dst.data shr ssLen
+  # shift source stack to line up the substack with its final resting place
+  let substack = src.data shl start
+  # combine
+  dst.data = dst.data or substack
+  # get rid of the moved items
+  src.data = src.data and masksLeft[start]
+  # more bookkeeping
+  src.last -= ssLen
+  dst.last += ssLen
+
+
+proc testMove[T1, T2: FixedSeq](a1, a2: var T1; b1, b2: var T2; i: Natural): bool =
+  let (orig_a1, orig_a2) = (a1, a2)
+  let (orig_b1, orig_b2) = (b1, b2)
+  a1.moveSubstack(a2, i)
+  b1.moveSubstack(b2, i)
+  if a1 != b1 or a2 != b2:
+    echo "Failed!"
+    show orig_b1
+    show orig_b2
+    echo "<<move ", i, ">>"
+    show b1
+    show b2
+    return false
+  return true
+
+
+when isMainModule:
+  var c1 = initFixedSeq(5, Color, int8)
+  var c2 = initFixedSeq(5, Color, int8)
+
+  var s1: ShiftStack
+  s1.initFixedSeq
+  var s2: ShiftStack
+  s2.initFixedSeq
+
+  c1.add(cPurple)
+  c1.add(cRed)
+  c1.add(cYellow)
+  c1.add(cBlue)
+  c1.add(cGreen)
+
+  s1.add(cPurple)
+  s1.add(cRed)
+  s1.add(cYellow)
+  s1.add(cBlue)
+  s1.add(cGreen)
+
+  # show s1
+  # show s2
+  # echo "<<move 2>>"
+  # s1.moveSubstack(s2, 2)
+  # show s1
+  # show s2
+
+  import random
+  randomize()
+  var r = initRand(rand(int64))
+  var success = true
+
+  for n in 1 .. 1_000_000:
+    var ranFirst, ranSecond: bool
+
+    if c1.len > 0:
+      let i = r.rand(c1.high)
+      ranFirst = true
+      if not testMove(c1, c2, s1, s2, i):
+        success = false
+        echo "Failed after ", n, " iterations."
+        break
+    else:
+      ranFirst = false
+
+    if c2.len > 0:
+      let j = r.rand(c2.high)
+      ranSecond = true
+      if not testMove(c2, c1, s2, s1, j):
+        success = false
+        echo "Failed after ", n, " iterations."
+        break
+    else:
+      ranSecond = false
+
+    if (not ranFirst) and (not ranSecond):
+      echo "Ran neither first nor second move."
+      break
+
+  if success:
+    echo "Success."

test.nim

@@ -1,32 +1,7 @@
-import math, random, strformat, times, std/monotimes
+import math, random, strformat, times
 import fixedseq, game, simulation, ui
 
 
-type
-  TestResults = object
-    ops: int
-    time: Duration
-
-
-proc summarize(tr: TestResults) =
-  let secs = tr.time.inMilliseconds.float / 1000
-  stdout.write("Test completed:\n")
-  stdout.write("  " & $tr.ops, " operations in " & $round(secs, 2) & " seconds\n")
-  stdout.write("  " & $round(tr.ops.float / secs, 2) & " operations per second")
-  stdout.flushFile()
-
-
-template executionTime(body: untyped): Duration =
-  let start = getMonoTime()
-  body
-  getMonoTime() - start
-
-
-proc getRand(): Rand =
-  randomize()
-  result = initRand(rand(int64))
-
-
 proc randomDice(r: var Rand): seq[tuple[c: Color, p: int]] = 
   for c in Color:
     let v = r.rand(1..3)
@@ -43,15 +18,18 @@ proc newRandomGame(r: var Rand): Board =
   result.setState(dice, [])
 
 
-proc games(nTests, nSamples: SomeInteger): TestResults =
-  var r = getRand()
-  var scores: ScoreSet
-  for i in 1 .. nTests:
-    let b = newRandomGame(r)
-    let dur = executionTime:
-      let s = b.randomGames(nSamples)
-    result.ops += s.sum()
-    result.time += dur
+proc testGames(n: SomeInteger = 100): auto =
+  var r = initRand(rand(int64))
+  let dice = randomDice(r)
+  var b: Board
+  b.init
+  b.setState(dice, [])
+  b.display(1, 5)
+
+  let startTime = cpuTime()
+  let scores = b.randomGames(n, parallel = true)
+  result = cpuTime() - startTime
+  scores.display()
 
 
 proc testLegs(n: Natural = 100): auto =
@@ -94,17 +72,24 @@ proc testSpread(nTests, nSamples: Natural) =
 
 
 when isMainModule:
-  games(100, 1_000_000).summarize()
+  randomize()
+  # var r = initRand(rand(int64))
+  # let b = newRandomGame(r)
+  # b.display(1, 5)
+  # echo b.showSpaces(1, 16)
+
+  # let scores = b.getLegScores
+  # echo scores.showPercents
   # 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 ""
+  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)