restore

Author: janmasrovira

bench2/Benchmark/Nockma/Encoding/Natural.hs

@@ -1,5 +1,6 @@
 module Benchmark.Nockma.Encoding.Natural where
 
+import Data.Serialize qualified as Serial
 import Juvix.Prelude
 import Juvix.Prelude.Bytes
 import System.Random
@@ -9,7 +10,7 @@ randomNatural :: IO Natural
 randomNatural = do
   sg <- getStdGen
   let numDigits :: Natural = 1000000
-  return (fst (uniformR (10 ^ numDigits, 10 ^ numDigits + 100) sg))
+  return (fst (uniformR (10 ^ numDigits, 10 ^ numDigits + 10000) sg))
 
 randomNaturalBS :: IO ByteString
 randomNaturalBS = naturalToByteString <$> randomNatural
@@ -27,50 +28,25 @@ bm = bgroup "Natural Encoding" [byteStringToNatBm, natToByteStringBm]
                 (\nat -> bench "Old" (nf old nat)),
               env
                 randomNaturalBS
-                (\nat -> bench "New" (nf new nat)),
-              env
-                randomNaturalBS
-                ( \nat ->
-                    bench
-                      "TEST"
-                      ( nf
-                          ( \i ->
-                              if new i == old i
-                                then True
-                                else error "wrong"
-                          )
-                          nat
-                      )
-                )
+                (\nat -> bench "New" (nf new nat))
             ]
 
     natToByteStringBm =
-      let old = padByteStringWord . naturalToByteStringOld
-          new = padByteStringWord . naturalToByteString
-          new2 = padByteStringWord . naturalToByteStringTest False
+      let shiftBased = padByteStringWord . naturalToByteStringOld
+          wordBased = padByteStringWord . naturalToByteString
+          byteBased = padByteStringWord . naturalToByteStringHelper True
        in bgroup
             "Natural -> ByteString"
             [ env
                 randomNatural
-                (\nat -> bench "Old" (nf old nat)),
+                (\nat -> bench "Shift based" (nf shiftBased nat)),
               env
                 randomNatural
-                (\nat -> bench "New" (nf new nat)),
+                (\nat -> bench "Word64 based" (nf wordBased nat)),
               env
                 randomNatural
-                (\nat -> bench "New2" (nf new2 nat)),
+                (\nat -> bench "Word8 based" (nf byteBased nat)),
               env
                 randomNatural
-                ( \nat ->
-                    bench
-                      "TEST"
-                      ( nf
-                          ( \i ->
-                              if new i == new2 i
-                                then True
-                                else error "wrong"
-                          )
-                          nat
-                      )
-                )
+                (\nat -> bench "Cereal library" (nf Serial.encode nat))
             ]

bench2/Main.hs

@@ -9,7 +9,7 @@ import Test.Tasty.Bench
 main :: IO ()
 main =
   defaultMain
-    [ -- Effect.bm,
-      -- Nockma.bm
+    [ Effect.bm,
+      Nockma.bm,
       Natural.bm
     ]

src/Juvix/Compiler/Nockma/Encoding/ByteString.hs

@@ -1,5 +1,3 @@
-{-# LANGUAGE MagicHash #-}
-
 module Juvix.Compiler.Nockma.Encoding.ByteString where
 
 import Crypto.Hash.SHA256 qualified as SHA256

src/Juvix/Prelude/Bytes.hs

@@ -29,7 +29,7 @@ naturalToBytes = \case
   NB b -> byteArrayToBytes (GHCByteArray.ByteArray b)
 
 -- | Pad a ByteString with zeros up to the smallest length such that is
--- divisible by the given arg
+-- divisible by `align`
 padByteStringMod :: Int -> ByteString -> ByteString
 padByteStringMod align bs =
   let (d, m) = divMod (BS.length bs) align
@@ -49,23 +49,24 @@ padByteString n bs
 naturalToByteStringLELen :: Int -> Natural -> ByteString
 naturalToByteStringLELen len = padByteString len . naturalToByteStringLE
 
+-- | This is quadratic (`shiftR` is O(n))
 naturalToByteStringOld :: Natural -> ByteString
-naturalToByteStringOld = naturalToByteStringLE
-
--- | TODO: this is quadratic (`shiftR` is O(n))
-naturalToByteStringLE :: Natural -> ByteString
-naturalToByteStringLE = BS.toStrict . BS.toLazyByteString . go
+naturalToByteStringOld = do
+  BS.toStrict . BS.toLazyByteString . go
   where
     go :: Natural -> BS.Builder
     go = \case
       0 -> mempty
       n -> BS.word8 (fromIntegral n) <> go (n `shiftR` 8)
 
+naturalToByteStringLE :: Natural -> ByteString
+naturalToByteStringLE = naturalToByteString
+
 -- | Little endian
-naturalToByteStringTest :: Bool -> Natural -> ByteString
-naturalToByteStringTest word64 n
+naturalToByteStringHelper :: Bool -> Natural -> ByteString
+naturalToByteStringHelper forceWord8 n
   -- most common case
-  | word64 && 8 == bytesPerWord =
+  | (not forceWord8) && 8 == bytesPerWord =
       let w :: [Word64] = naturalToWord64 n
        in build (mconcat (map BS.word64LE w))
   | otherwise = BS.pack (naturalToBytes n)
@@ -74,7 +75,7 @@ naturalToByteStringTest word64 n
     build = BS.toStrict . BS.toLazyByteString
 
 naturalToByteString :: Natural -> ByteString
-naturalToByteString = naturalToByteStringTest True
+naturalToByteString = naturalToByteStringHelper False
 
 -- | Little endian
 wordToBytes :: Word -> [Word8]