Refactor to use an array backend Part 1

README.md

@@ -20,8 +20,7 @@ Main focus:
     - Uint2048 for Ethereum Bloom filters
   - Ease of use:
     - Use traditional `+`, `-`, `+=`, etc operators like on native types
-    - Representation of numbers in memory is the exact same as native types and endianness aware.
-      - In practice that means that interfacing with binary blobs representing numbers from cryptographic    libraries can be done with a `cast` if it represents a Uint256, Uint512, Uint1024, Uint2048.
+    - converting to and from raw byte BigInts (also called octet string in IETF specs)
     - converting to and from Hex
     - converting to and from decimal strings
 

benchmarks/bench.nim

@@ -0,0 +1,91 @@
+import ../stint, std/[times, monotimes]
+
+template bench(desc: string, body: untyped) =
+  let start = getMonotime()
+  body
+  let stop = getMonotime()
+  echo desc,": ", inMilliseconds(stop-start), " ms"
+
+# Warmup on normal int to ensure max CPU freq
+# Complex enough that the compiler doesn't optimize it away
+
+proc warmup() =
+  var foo = 123
+  bench "Warmup":
+    for i in 0 ..< 10_000_000:
+      foo += i*i mod 456
+      foo = foo mod 789
+
+warmup()
+####################################
+
+let a = [123'u64, 123'u64, 123'u64, 123'u64]
+let m = [456'u64, 456'u64, 456'u64, 45'u64]
+
+proc add_stint(a, m: array[4, uint64]) =
+  let aU256 = cast[Stuint[256]](a)
+  let mU256 = cast[Stuint[256]](m)
+
+  bench "Add (stint)":
+    var foo = aU256
+    for i in 0 ..< 100_000_000:
+      foo += mU256
+      foo += aU256
+
+proc mul_stint(a, m: array[4, uint64]) =
+  let aU256 = cast[Stuint[256]](a)
+  let mU256 = cast[Stuint[256]](m)
+
+  bench "Mul (stint)":
+    var foo = aU256
+    for i in 0 ..< 100_000_000:
+      foo += (foo * foo)
+
+proc mod_stint(a, m: array[4, uint64]) =
+  let aU256 = cast[Stuint[256]](a)
+  let mU256 = cast[Stuint[256]](m)
+
+  bench "Mod (stint)":
+    var foo = aU256
+    for i in 0 ..< 100_000_000:
+      foo += (foo * foo) mod mU256
+
+add_stint(a, m)
+mul_stint(a, m)
+mod_stint(a, m)
+
+when defined(bench_ttmath):
+  # need C++
+  import ttmath, ../tests/ttmath_compat
+
+  proc add_ttmath(a, m: array[4, uint64]) =
+    let aU256 = a.astt()
+    let mU256 = m.astt()
+
+    bench "Add (ttmath)":
+      var foo = aU256
+      for i in 0 ..< 100_000_000:
+        foo += mU256
+        foo += aU256
+
+  proc mul_ttmath(a, m: array[4, uint64]) =
+    let aU256 = a.astt()
+    let mU256 = m.astt()
+
+    bench "Mul (ttmath)":
+      var foo = aU256
+      for i in 0 ..< 100_000_000:
+        foo += (foo * foo)
+
+  proc mod_ttmath(a, m: array[4, uint64]) =
+    let aU256 = a.astt()
+    let mU256 = m.astt()
+
+    bench "Mod (ttmath)":
+      var foo = aU256
+      for i in 0 ..< 100_000_000:
+        foo += (foo * foo) mod mU256
+
+  add_ttmath(a, m)
+  mul_ttmath(a, m)
+  mod_ttmath(a, m)