Add benchmarking code and costing model for insertCoin

Author: ana-pantilie

plutus-core/cost-model/budgeting-bench/Benchmarks/Values.hs

@@ -11,6 +11,7 @@ import Prelude
 
 import Common
 import Control.Monad (replicateM)
+import Control.Monad.State.Strict (State)
 import Criterion.Main (Benchmark)
 import Data.Bits (shiftR, (.&.))
 import Data.ByteString (ByteString)
@@ -19,13 +20,13 @@ import Data.Int (Int64)
 import Data.List (find, sort)
 import Data.Word (Word8)
 import GHC.Stack (HasCallStack)
-import PlutusCore (DefaultFun (LookupCoin, UnValueData, ValueContains, ValueData))
+import PlutusCore (DefaultFun (InsertCoin, LookupCoin, UnValueData, ValueContains, ValueData))
 import PlutusCore.Builtin (BuiltinResult (BuiltinFailure, BuiltinSuccess, BuiltinSuccessWithLogs))
 import PlutusCore.Evaluation.Machine.ExMemoryUsage (ValueLogOuterSizeAddLogMaxInnerSize (..),
                                                     ValueTotalSize (..))
-import PlutusCore.Value (K, Value)
+import PlutusCore.Value (K, Quantity (..), Value)
 import PlutusCore.Value qualified as Value
-import System.Random.Stateful (StatefulGen, StdGen, runStateGen_, uniformRM)
+import System.Random.Stateful (StateGenM, StatefulGen, StdGen, runStateGen_, uniformRM)
 
 ----------------------------------------------------------------------------------------------------
 -- Benchmarks --------------------------------------------------------------------------------------
@@ -36,6 +37,7 @@ makeBenchmarks gen =
   , valueContainsBenchmark gen
   , valueDataBenchmark gen
   , unValueDataBenchmark gen
+  , insertCoinBenchmark gen
   ]
 
 ----------------------------------------------------------------------------------------------------
@@ -47,10 +49,10 @@ lookupCoinBenchmark gen =
     (id, id, ValueLogOuterSizeAddLogMaxInnerSize) -- Wrap Value argument to report sum of log sizes
     LookupCoin -- the builtin fun
     [] -- no type arguments needed (monomorphic builtin)
-    (lookupCoinArgs gen) -- the argument combos to generate benchmarks for
+    (runBenchGen gen lookupCoinArgs) -- the argument combos to generate benchmarks for
 
-lookupCoinArgs :: StdGen -> [(ByteString, ByteString, Value)]
-lookupCoinArgs gen = runStateGen_ gen \(g :: g) -> do
+lookupCoinArgs :: (StatefulGen g m) => g -> m [(ByteString, ByteString, Value)]
+lookupCoinArgs gen = do
   {- Exhaustive power-of-2 combinations for BST worst-case benchmarking.
 
      Tests all combinations of sizes from powers and half-powers of 2.
@@ -81,7 +83,7 @@ lookupCoinArgs gen = runStateGen_ gen \(g :: g) -> do
 
   sequence
     -- Generate worst-case lookups for each size combination
-    [ withWorstCaseSearchKeys (generateConstrainedValueWithMaxPolicy numPolicies tokensPerPolicy g)
+    [ withWorstCaseSearchKeys (generateConstrainedValueWithMaxPolicy numPolicies tokensPerPolicy gen)
     | numPolicies <- sizes
     , tokensPerPolicy <- sizes
     ]
@@ -211,6 +213,41 @@ unValueDataBenchmark :: StdGen -> Benchmark
 unValueDataBenchmark gen =
   createOneTermBuiltinBench UnValueData [] (Value.valueData <$> generateTestValues gen)
 
+----------------------------------------------------------------------------------------------------
+-- InsertCoin --------------------------------------------------------------------------------------
+
+insertCoinBenchmark :: StdGen -> Benchmark
+insertCoinBenchmark gen =
+  createFourTermBuiltinBenchElementwiseWithWrappers
+    (id, id, id, ValueLogOuterSizeAddLogMaxInnerSize)
+    InsertCoin
+    []
+    (runBenchGen gen insertCoinArgs)
+
+insertCoinArgs :: (StatefulGen g m) => g -> m [(ByteString, ByteString, Integer, Value)]
+insertCoinArgs gen = do
+  lookupArgs <- lookupCoinArgs gen
+  let noOfBenchs = length lookupArgs
+  amounts <- genZeroOrMaxAmount gen noOfBenchs
+  pure $ reorderArgs <$> zip lookupArgs amounts
+  where
+    reorderArgs ((b1, b2, val), am) = (b1, b2, am, val)
+
+-- | Generate either zero or maximum amount Integer values, the probability of each is 50%
+genZeroOrMaxAmount
+  :: (StatefulGen g m)
+  => g
+  -> Int
+  -- ^ Number of amounts to generate
+  -> m [Integer]
+genZeroOrMaxAmount gen n =
+  replicateM n $ do
+    coinType <- uniformRM (0 :: Int, 1) gen
+    pure $ case coinType of
+      0 -> 0
+      1 -> unQuantity maxBound
+      _ -> error "genZeroOrMaxAmount: impossible"
+
 ----------------------------------------------------------------------------------------------------
 -- Value Generators --------------------------------------------------------------------------------
 
@@ -360,3 +397,8 @@ unsafeFromBuiltinResult = \case
   BuiltinSuccess x -> x
   BuiltinSuccessWithLogs _ x -> x
   BuiltinFailure _ err -> error $ "BuiltinResult failed: " <> show err
+
+-- | Abstracted runner for computations using stateful random generator 'StdGen'
+runBenchGen :: StdGen -> (StateGenM StdGen -> State StdGen a) -> a
+runBenchGen gen ma = runStateGen_ gen \g -> ma g
+

plutus-core/cost-model/budgeting-bench/Main.hs

@@ -48,20 +48,20 @@ main = do
   criterionMainWith
        Start
        defaultConfig $
-           Benchmarks.Bitwise.makeBenchmarks
-        <> Benchmarks.Bool.makeBenchmarks        gen
-        <> Benchmarks.ByteStrings.makeBenchmarks gen
-        <> Benchmarks.Crypto.makeBenchmarks      gen
-        <> Benchmarks.Data.makeBenchmarks        gen
-        <> Benchmarks.Integers.makeBenchmarks    gen
-        <> Benchmarks.Lists.makeBenchmarks       gen
-        <> Benchmarks.Arrays.makeBenchmarks      gen
-        <> Benchmarks.Misc.makeBenchmarks        gen
-        <> Benchmarks.Pairs.makeBenchmarks       gen
-        <> Benchmarks.Strings.makeBenchmarks     gen
-        <> Benchmarks.Tracing.makeBenchmarks     gen
-        <> Benchmarks.Unit.makeBenchmarks        gen
-        <> Benchmarks.Values.makeBenchmarks      gen
+            Benchmarks.Bitwise.makeBenchmarks
+         <> Benchmarks.Bool.makeBenchmarks        gen
+         <> Benchmarks.ByteStrings.makeBenchmarks gen
+         <> Benchmarks.Crypto.makeBenchmarks      gen
+         <> Benchmarks.Data.makeBenchmarks        gen
+         <> Benchmarks.Integers.makeBenchmarks    gen
+         <> Benchmarks.Lists.makeBenchmarks       gen
+         <> Benchmarks.Arrays.makeBenchmarks      gen
+         <> Benchmarks.Misc.makeBenchmarks        gen
+         <> Benchmarks.Pairs.makeBenchmarks       gen
+         <> Benchmarks.Strings.makeBenchmarks     gen
+         <> Benchmarks.Tracing.makeBenchmarks     gen
+         <> Benchmarks.Unit.makeBenchmarks        gen
+         <> Benchmarks.Values.makeBenchmarks      gen
 
   {- Run the nop benchmarks with a large time limit (30 seconds) in an attempt to
      get accurate results. -}

plutus-core/cost-model/data/models.R

@@ -156,6 +156,7 @@ arity <- function(name) {
         "ValueContains" = 2,
         "ValueData" = 1,
         "UnValueData" = 1,
+        "InsertCoin" = 4,
         -1  ## Default for missing values
         )
 }
@@ -170,7 +171,7 @@ get.bench.data <- function(path) {
         comment.char="#"
     )
 
-    benchname <- regex("([[:alnum:]_]+)/(\\d+)(?:/(\\d+))?(?:/(\\d+))?")
+    benchname <- regex("([[:alnum:]_]+)/(\\d+)(?:/(\\d+))?(?:/(\\d+))?(?:/(\\d+))?")
     ## We have benchmark names like "AddInteger/11/22", the numbers representing the sizes of
     ## the inputs to the benchmark.  This extracts the name and up to three numbers, returning
     ## "NA" for any that are missing.  If we ever have builtins with more than three arguments
@@ -182,7 +183,7 @@ get.bench.data <- function(path) {
     ## the size of the first one because the others are terms (and the time is
     ## constant anyway).
 
-    numbercols = c("x_mem", "y_mem", "z_mem")
+    numbercols = c("x_mem", "y_mem", "z_mem", "w_mem")
 
     benchmark.name.to.numbers <- function(name) {
         a <- str_match(name, benchname)
@@ -432,6 +433,14 @@ modelFun <- function(path) {
         return (mk.result(m, "linear_in_z"))
    }
 
+   linearInW <- function (fname) {
+        filtered <- data %>%
+            filter.and.check.nonempty(fname) %>%
+            discard.overhead ()
+        m <- lm(t ~ w_mem, filtered)
+        return (mk.result(m, "linear_in_w"))
+   }
+
     ##### Integers #####
 
     addIntegerModel <- {
@@ -817,6 +826,7 @@ modelFun <- function(path) {
 
     # Z wrapped with `Logarithmic . ValueOuterOrMaxInner`
     lookupCoinModel           <- linearInZ ("LookupCoin")    
+    insertCoinModel           <- linearInW ("InsertCoin")    
 
     # X wrapped with `ValueLogOuterSizeAddLogMaxInnerSize` (sum of logarithmic sizes)
     # Y wrapped with `ValueTotalSize` (contained value size)
@@ -829,7 +839,7 @@ modelFun <- function(path) {
         mk.result(m, "multiplied_sizes")
     }         
 
-    # Sizes of parameters are used as is (unwrapped):
+    # # Sizes of parameters are used as is (unwrapped):
     valueDataModel            <- constantModel ("ValueData")
     unValueDataModel          <- linearInX ("UnValueData")
 
@@ -930,7 +940,8 @@ modelFun <- function(path) {
         lookupCoinModel                      = lookupCoinModel,
         valueContainsModel                   = valueContainsModel,
         valueDataModel                       = valueDataModel,
-        unValueDataModel                     = unValueDataModel
+        unValueDataModel                     = unValueDataModel,
+        insertCoinModel                      = insertCoinModel
         )
 
     ## The integer division functions have a complex costing behaviour that requires some negative

scripts/toframe.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+cat "$*" |
+    sed 's#/# #g' |
+    sed 's/,/ /g' |
+    #    grep -v "^Nop" |
+    grep -v "^#" |
+    awk '
+      BEGIN {printf ("name x     y      z      u      v      w      t      lb     ub\n")}
+      function print1() {printf ("%-20s %7d %7d %7d %7d %7d %7d  %g %g %g \n", $1, $2,  0,  0,  0,  0,  0, $3, $4,  $5)}
+      function print2() {printf ("%-20s %7d %7d %7d %7d %7d %7d  %g %g %g \n", $1, $2, $3,  0,  0,  0,  0, $4, $5,  $6)}
+      function print3() {printf ("%-20s %7d %7d %7d %7d %7d %7d  %g %g %g \n", $1, $2, $3, $4,  0,  0,  0, $5, $6,  $7)}
+      function print4() {printf ("%-20s %7d %7d %7d %7d %7d %7d  %g %g %g \n", $1, $2, $3, $4, $5,  0,  0, $6, $7,  $8)}
+      function print5() {printf ("%-20s %7d %7d %7d %7d %7d %7d  %g %g %g \n", $1, $2, $3, $4, $5, $6,  0, $7, $8,  $9)}
+      function print6() {printf ("%-20s %7d %7d %7d %7d %7d %7d  %g %g %g \n", $1, $2, $3, $4, $5, $6, $7, $8, $9, $10)}
+      NF == 8  {print1()}
+      NF == 9  {print2()}
+      NF == 10 {print3()}
+      NF == 11 {print4()}
+      NF == 12 {print5()}
+      NF == 13 {print6()}
+    '