implement card (#825)

* implement `card`

* update test

Author: metagn

lib/std/system.nim

@@ -471,6 +471,7 @@ template len*[I, T](x: array[I, T]): int =
 # is the string equality is used by hexer/stringcases.nim.
 include "system/stringimpl"
 
+include "system/countbits_impl"
 include "system/setops"
 
 include "system/openarrays"

lib/std/system/countbits_impl.nim

@@ -0,0 +1,73 @@
+# slightly modified from original countbits_impl
+
+# C compiler defines seem to not be defined yet:
+const useBuiltins = not defined(noIntrinsicsBitOpts)
+const useGCC_builtins = (defined(gcc) or defined(llvm_gcc) or
+                         defined(clang)) and useBuiltins
+const useICC_builtins = defined(icc) and useBuiltins
+const useVCC_builtins = defined(vcc) and useBuiltins
+const arch64 = true # sizeof(int) == 8
+
+template countBitsImpl(n: uint32): int =
+  # generic formula is from: https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+  var v = uint32(n)
+  v = v - ((v shr 1) and 0x55555555'u32)
+  v = (v and 0x33333333'u32) + ((v shr 2) and 0x33333333'u32)
+  (((v + (v shr 4) and 0xF0F0F0F'u32) * 0x1010101'u32) shr 24).int
+
+template countBitsImpl(n: uint64): int =
+  # generic formula is from: https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+  var v = uint64(n)
+  v = v - ((v shr 1) and 0x5555555555555555'u64)
+  v = (v and 0x3333333333333333'u64) + ((v shr 2) and 0x3333333333333333'u64)
+  v = (v + (v shr 4) and 0x0F0F0F0F0F0F0F0F'u64)
+  ((v * 0x0101010101010101'u64) shr 56).int
+
+
+when useGCC_builtins:
+  # Returns the number of set 1-bits in value.
+  proc builtin_popcount(x: cuint): cint {.importc: "__builtin_popcount", cdecl.}
+  proc builtin_popcountll(x: culonglong): cint {.
+      importc: "__builtin_popcountll", cdecl.}
+
+elif useVCC_builtins:
+  # Counts the number of one bits (population count) in a 16-, 32-, or 64-byte unsigned integer.
+  func builtin_popcnt16(a2: uint16): uint16 {.
+      importc: "__popcnt16", header: "<intrin.h>".}
+  func builtin_popcnt32(a2: uint32): uint32 {.
+      importc: "__popcnt", header: "<intrin.h>".}
+  func builtin_popcnt64(a2: uint64): uint64 {.
+      importc: "__popcnt64", header: "<intrin.h>".}
+
+elif useICC_builtins:
+  # Intel compiler intrinsics: http://fulla.fnal.gov/intel/compiler_c/main_cls/intref_cls/common/intref_allia_misc.htm
+  # see also: https://software.intel.com/en-us/node/523362
+  # Count the number of bits set to 1 in an integer a, and return that count in dst.
+  func builtin_popcnt32(a: cint): cint {.
+      importc: "_popcnt", header: "<immintrin.h>".}
+  func builtin_popcnt64(a: uint64): cint {.
+      importc: "_popcnt64", header: "<immintrin.h>".}
+
+proc countBits32*(x: uint32): int {.inline.} =
+  when useGCC_builtins:
+    result = builtin_popcount(x.cuint).int
+  elif useVCC_builtins:
+    result = builtin_popcnt32(x.uint32).int
+  elif useICC_builtins:
+    result = builtin_popcnt32(x.cint).int
+  else:
+    result = countBitsImpl(x.uint32)
+
+proc countBits64*(x: uint64): int {.inline.} =
+  when useGCC_builtins:
+    result = builtin_popcountll(x.culonglong).int
+  elif useVCC_builtins:
+    when arch64: result = builtin_popcnt64(x.uint64).int
+    else: result = builtin_popcnt32((x.uint64 and 0xFFFFFFFF'u64).uint32).int +
+                    builtin_popcnt32((x.uint64 shr 32'u64).uint32).int
+  elif useICC_builtins:
+    when arch64: result = builtin_popcnt64(x.uint64).int
+    else: result = builtin_popcnt32((x.uint64 and 0xFFFFFFFF'u64).cint).int +
+                    builtin_popcnt32((x.uint64 shr 32'u64).cint).int
+  else:
+    result = countBitsImpl(x.uint64)

lib/std/system/setops.nim

@@ -22,3 +22,20 @@ func `+`*[T](x, y: set[T]): set[T] {.magic: "PlusSet".}
 func `-`*[T](x, y: set[T]): set[T] {.magic: "MinusSet".}
 
 func contains*[T](x: set[T], y: T): bool {.magic: "InSet".}
+
+proc cardSetImpl(s: ptr UncheckedArray[uint8], len: int): int {.inline.} =
+  var i = 0
+  result = 0
+  var num = 0'u64
+  when defined(x86) or defined(amd64):
+    while i < len - 8:
+      copyMem(addr num, addr s[i], 8)
+      inc(result, countBits64(num))
+      inc(i, 8)
+
+  while i < len:
+    inc(result, countBits32(uint32(s[i])))
+    inc(i, 1)
+
+proc cardSet(s: ptr UncheckedArray[uint8], len: int): int {.inline.} =
+  result = cardSetImpl(s, len)

src/hexer/desugar.nim

@@ -225,9 +225,6 @@ proc genSetOp(c: var Context; dest: var TokenBuf; n: var Cursor) =
   case size
   of 1, 2, 4, 8:
     case kind
-    of CardX:
-      # XXX needs countBits compilerproc
-      raiseAssert("unimplemented")
     of LtSetX:
       copyIntoKind dest, AndX, info:
         addTypedOp dest, EqX, cType, info:
@@ -283,9 +280,6 @@ proc genSetOp(c: var Context; dest: var TokenBuf; n: var Cursor) =
       raiseAssert("unreachable")
   else:
     case kind
-    of CardX:
-      # XXX originally implemented as cardSet compilerproc
-      raiseAssert("unimplemented")
     of LtSetX, LeSetX:
       dest.add parLeToken(ExprX, info)
       let resValue = [parLeToken(TrueX, info), parRiToken(info)]
@@ -388,6 +382,45 @@ proc genSetOp(c: var Context; dest: var TokenBuf; n: var Cursor) =
     dest.addParRi()
     c.tempUseBufStack.shrink(oldBufStackLen)
 
+proc genCard(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  let info = n.info
+  inc n
+  let typ = n
+  if typ.typeKind != SetT:
+    error "expected set type for set op", n
+  var baseType = typ
+  inc baseType
+  var argsBuf = createTokenBuf(16)
+  swap dest, argsBuf
+  skip n # nothing to do with set type
+  let aStart = dest.len
+  tr(c, dest, n)
+  swap dest, argsBuf
+  skipParRi n
+  let a = cursorAt(argsBuf, aStart) # no temp needed
+  var err = false
+  let size = asSigned(bitsetSizeInBytes(baseType), err)
+  assert not err
+  case size
+  of 1, 2:
+    copyIntoKind dest, CallX, info:
+      dest.add symToken(pool.syms.getOrIncl("countBits32.0." & SystemModuleSuffix), info)
+      addUIntTypedOp dest, CastX, 32, info:
+        dest.addSubtree a
+  of 4:
+    copyIntoKind dest, CallX, info:
+      dest.add symToken(pool.syms.getOrIncl("countBits32.0." & SystemModuleSuffix), info)
+      dest.addSubtree a
+  of 8:
+    copyIntoKind dest, CallX, info:
+      dest.add symToken(pool.syms.getOrIncl("countBits64.0." & SystemModuleSuffix), info)
+      dest.addSubtree a
+  else:
+    copyIntoKind dest, CallX, info:
+      dest.add symToken(pool.syms.getOrIncl("cardSet.0." & SystemModuleSuffix), info)
+      dest.arrayToPointer(a, info)
+      dest.addIntLit(size, info)
+
 proc genSingleInclSmall(dest: var TokenBuf; s, elem: Cursor; size: int; info: PackedLineInfo) =
   let bits = size * 8
   copyIntoKind dest, AsgnS, info:
@@ -673,8 +706,10 @@ proc tr(c: var Context; dest: var TokenBuf; n: var Cursor) =
         trSons(c, dest, n)
     of SetConstrX:
       genSetConstr(c, dest, n)
-    of PlusSetX, MinusSetX, MulSetX, XorSetX, EqSetX, LeSetX, LtSetX, InSetX, CardX:
+    of PlusSetX, MinusSetX, MulSetX, XorSetX, EqSetX, LeSetX, LtSetX, InSetX:
       genSetOp(c, dest, n)
+    of CardX:
+      genCard(c, dest, n)
     of TypeofX:
       takeTree dest, n
     of DdotX: