refactor: consolidate Value size measurement types

Simplifies the memory usage measurement by consolidating three separate types
(Logarithmic, ValueOuterOrMaxInner, LogValueOuterOrMaxInner) into a single
ValueLogOuterOrMaxInner type. This reduces complexity while maintaining the
same functionality for measuring logarithmic Value sizes.

The new type directly encodes the intended semantics: size = log(max(outer, maxInner)),
making the code more maintainable and producing clearer type signatures in builtin
function definitions.

Author: Unisay

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

@@ -13,7 +13,7 @@ import Criterion.Main (Benchmark)
 import Data.ByteString (ByteString)
 import Data.Int (Int64)
 import PlutusCore (DefaultFun (LookupCoin, UnValueData, ValueContains, ValueData))
-import PlutusCore.Evaluation.Machine.ExMemoryUsage (LogValueOuterOrMaxInner (..),
+import PlutusCore.Evaluation.Machine.ExMemoryUsage (ValueLogOuterOrMaxInner (..),
                                                     ValueTotalSize (..))
 import PlutusCore.Value (K, Value)
 import PlutusCore.Value qualified as Value
@@ -36,7 +36,7 @@ makeBenchmarks gen =
 lookupCoinBenchmark :: StdGen -> Benchmark
 lookupCoinBenchmark gen =
   createThreeTermBuiltinBenchElementwiseWithWrappers
-    (id, id, LogValueOuterOrMaxInner) -- Wrap Value argument to report outer/max inner size with log
+    (id, id, ValueLogOuterOrMaxInner) -- Wrap Value argument to report outer/max inner size with log
     LookupCoin -- the builtin fun
     [] -- no type arguments needed (monomorphic builtin)
     (lookupCoinArgs gen) -- the argument combos to generate benchmarks for
@@ -73,7 +73,7 @@ withSearchKeys g genValue = do
 valueContainsBenchmark :: StdGen -> Benchmark
 valueContainsBenchmark gen =
   createTwoTermBuiltinBenchElementwiseWithWrappers
-    (LogValueOuterOrMaxInner, ValueTotalSize)
+    (ValueLogOuterOrMaxInner, ValueTotalSize)
     -- Container: outer/maxInner with log, Contained: totalSize
     ValueContains -- the builtin fun
     [] -- no type arguments needed (monomorphic builtin)

plutus-core/plutus-core/src/PlutusCore/Default/Builtins.hs

@@ -24,8 +24,8 @@ import PlutusCore.Default.Universe
 import PlutusCore.Evaluation.Machine.BuiltinCostModel
 import PlutusCore.Evaluation.Machine.ExBudgetStream (ExBudgetStream)
 import PlutusCore.Evaluation.Machine.ExMemoryUsage (ExMemoryUsage, IntegerCostedLiterally (..),
-                                                    LogValueOuterOrMaxInner (..),
                                                     NumBytesCostedAsNumWords (..),
+                                                    ValueLogOuterOrMaxInner (..),
                                                     ValueTotalSize (..), memoryUsage, singletonRose)
 import PlutusCore.Pretty (PrettyConfigPlc)
 import PlutusCore.Value (Value)
@@ -2056,8 +2056,8 @@ instance uni ~ DefaultUni => ToBuiltinMeaning uni DefaultFun where
             (runCostingFunFourArguments . unimplementedCostingFun)
 
     toBuiltinMeaning _semvar LookupCoin =
-      let lookupCoinDenotation :: ByteString -> ByteString -> LogValueOuterOrMaxInner -> Integer
-          lookupCoinDenotation p t (LogValueOuterOrMaxInner v) = Value.lookupCoin p t v
+      let lookupCoinDenotation :: ByteString -> ByteString -> ValueLogOuterOrMaxInner -> Integer
+          lookupCoinDenotation p t (ValueLogOuterOrMaxInner v) = Value.lookupCoin p t v
           {-# INLINE lookupCoinDenotation #-}
        in makeBuiltinMeaning
             lookupCoinDenotation
@@ -2072,8 +2072,8 @@ instance uni ~ DefaultUni => ToBuiltinMeaning uni DefaultFun where
             (runCostingFunTwoArguments . unimplementedCostingFun)
 
     toBuiltinMeaning _semvar ValueContains =
-      let valueContainsDenotation :: LogValueOuterOrMaxInner -> ValueTotalSize -> BuiltinResult Bool
-          valueContainsDenotation (LogValueOuterOrMaxInner v1) (ValueTotalSize v2) =
+      let valueContainsDenotation :: ValueLogOuterOrMaxInner -> ValueTotalSize -> BuiltinResult Bool
+          valueContainsDenotation (ValueLogOuterOrMaxInner v1) (ValueTotalSize v2) =
             Value.valueContains v1 v2
           {-# INLINE valueContainsDenotation #-}
        in makeBuiltinMeaning

plutus-core/plutus-core/src/PlutusCore/Default/Universe.hs

@@ -52,8 +52,8 @@ import PlutusCore.Crypto.BLS12_381.G2 qualified as BLS12_381.G2
 import PlutusCore.Crypto.BLS12_381.Pairing qualified as BLS12_381.Pairing
 import PlutusCore.Data (Data)
 import PlutusCore.Evaluation.Machine.ExMemoryUsage (IntegerCostedLiterally (..),
-                                                    LogValueOuterOrMaxInner (..),
                                                     NumBytesCostedAsNumWords (..),
+                                                    ValueLogOuterOrMaxInner (..),
                                                     ValueTotalSize (..))
 import PlutusCore.Pretty.Extra (juxtRenderContext)
 import PlutusCore.Value (Value)
@@ -580,13 +580,13 @@ instance KnownBuiltinTypeIn DefaultUni term Value =>
     {-# INLINE readKnown #-}
 
 deriving newtype instance
-        KnownTypeAst tyname DefaultUni LogValueOuterOrMaxInner
+        KnownTypeAst tyname DefaultUni ValueLogOuterOrMaxInner
 instance KnownBuiltinTypeIn DefaultUni term Value =>
-        MakeKnownIn DefaultUni term LogValueOuterOrMaxInner where
+        MakeKnownIn DefaultUni term ValueLogOuterOrMaxInner where
     makeKnown = makeKnownCoerce @Value
     {-# INLINE makeKnown #-}
 instance KnownBuiltinTypeIn DefaultUni term Value =>
-        ReadKnownIn DefaultUni term LogValueOuterOrMaxInner where
+        ReadKnownIn DefaultUni term ValueLogOuterOrMaxInner where
     readKnown = readKnownCoerce @Value
     {-# INLINE readKnown #-}
 

plutus-core/plutus-core/src/PlutusCore/Evaluation/Machine/ExMemoryUsage.hs

@@ -12,9 +12,7 @@ module PlutusCore.Evaluation.Machine.ExMemoryUsage
     , NumBytesCostedAsNumWords(..)
     , IntegerCostedLiterally(..)
     , ValueTotalSize(..)
-    , ValueOuterOrMaxInner(..)
-    , Logarithmic(..)
-    , LogValueOuterOrMaxInner(..)
+    , ValueLogOuterOrMaxInner(..)
     ) where
 
 import PlutusCore.Crypto.BLS12_381.G1 as BLS12_381.G1
@@ -380,38 +378,6 @@ newtype ValueTotalSize = ValueTotalSize { unValueTotalSize :: Value }
 instance ExMemoryUsage ValueTotalSize where
     memoryUsage = singletonRose . fromIntegral . Value.totalSize . unValueTotalSize
 
--- | Measure the size of a `Value` by taking the max of
--- (size of the outer map, size of the largest inner map).
-newtype ValueOuterOrMaxInner = ValueOuterOrMaxInner { unValueOuterOrMaxInner :: Value }
-
-instance ExMemoryUsage ValueOuterOrMaxInner where
-    memoryUsage (ValueOuterOrMaxInner v) = singletonRose (fromIntegral size)
-      where
-        size = Map.size (Value.unpack v) `max` Value.maxInnerSize v
-
-{-| A wrapper that applies a logarithmic transformation to another size measure.
-This is useful for modeling operations with logarithmic complexity, where the cost
-depends on log(n) where n is the size measure from the wrapped newtype.
-
-For example, @Logarithmic ValueOuterOrMaxInner@ can be used to model operations
-that are O(log max(m, k)) where m is the number of policies and k is the max tokens
-per policy.
-
-The memory usage is calculated as: @max 1 (floor (log2 size + 1))@ where size comes
-from the wrapped newtype's ExMemoryUsage instance.
--}
-newtype Logarithmic n = Logarithmic { unLogarithmic :: n }
-
-instance ExMemoryUsage n => ExMemoryUsage (Logarithmic n) where
-    memoryUsage (Logarithmic wrapped) =
-      case memoryUsage wrapped of
-        CostRose size _ ->
-          let sizeInteger :: Integer
-              sizeInteger = fromSatInt size
-              logSize = integerLog2 sizeInteger
-          in singletonRose $ max 1 (fromIntegral (logSize + 1))
-    {-# INLINE memoryUsage #-}
-
 {-| A combined wrapper for Value that measures size using outer/max inner map sizes
 with logarithmic transformation. This is equivalent to @Logarithmic ValueOuterOrMaxInner@
 but defined as a single newtype for simpler type instances and better error messages.
@@ -422,10 +388,10 @@ O(log max(m, k)) where m is the number of policies and k is the max tokens per p
 If this is used to wrap an argument in the denotation of a builtin then it *MUST* also
 be used to wrap the same argument in the relevant budgeting benchmark.
 -}
-newtype LogValueOuterOrMaxInner = LogValueOuterOrMaxInner { unLogValueOuterOrMaxInner :: Value }
+newtype ValueLogOuterOrMaxInner = ValueLogOuterOrMaxInner { unLogValueOuterOrMaxInner :: Value }
 
-instance ExMemoryUsage LogValueOuterOrMaxInner where
-    memoryUsage (LogValueOuterOrMaxInner v) =
+instance ExMemoryUsage ValueLogOuterOrMaxInner where
+    memoryUsage (ValueLogOuterOrMaxInner v) =
       let size = Map.size (Value.unpack v) `max` Value.maxInnerSize v
           logSize = integerLog2 (toInteger size)
       in singletonRose $ max 1 (fromIntegral (logSize + 1))

plutus-core/plutus-core/test/CostModelSafety/Spec.hs

@@ -32,13 +32,15 @@ import PlutusCore.Crypto.BLS12_381.G1 qualified as BLS12_381.G1
 import PlutusCore.Crypto.BLS12_381.G2 qualified as BLS12_381.G2
 import PlutusCore.Crypto.BLS12_381.Pairing qualified as BLS12_381.Pairing
 import PlutusCore.Data (Data (..))
+import PlutusCore.Default ()
 import PlutusCore.Default.Builtins
 import PlutusCore.Evaluation.Machine.BuiltinCostModel (BuiltinCostModel)
 import PlutusCore.Evaluation.Machine.ExBudget (ExBudget (ExBudget))
 import PlutusCore.Evaluation.Machine.ExBudgetingDefaults (cekCostModelForVariant)
 import PlutusCore.Evaluation.Machine.ExBudgetStream (sumExBudgetStream)
 import PlutusCore.Evaluation.Machine.ExMemoryUsage (IntegerCostedLiterally,
-                                                    NumBytesCostedAsNumWords)
+                                                    NumBytesCostedAsNumWords,
+                                                    ValueLogOuterOrMaxInner, ValueTotalSize)
 import PlutusCore.Evaluation.Machine.MachineParameters (CostModel (..))
 import PlutusCore.Value (Value)
 import PlutusCore.Value qualified as Value
@@ -129,7 +131,9 @@ smallConstant tr
     | Just HRefl <- eqTypeRep tr (typeRep @BLS12_381.Pairing.MlResult) =
                     SomeConst $ BLS12_381.Pairing.millerLoop
                                   BLS12_381.G1.offchain_zero BLS12_381.G2.offchain_zero
-    | Just HRefl <- eqTypeRep tr (typeRep @Value) = SomeConst $ Value.empty
+    | Just HRefl <- eqTypeRep tr (typeRep @Value) = SomeConst Value.empty
+    | Just HRefl <- eqTypeRep tr (typeRep @ValueTotalSize) = SomeConst Value.empty
+    | Just HRefl <- eqTypeRep tr (typeRep @ValueLogOuterOrMaxInner) = SomeConst Value.empty
     | trPair `App` tr1 `App` tr2 <- tr
     , Just HRefl <- eqTypeRep trPair (typeRep @(,)) =
         case (smallConstant tr1, smallConstant tr2) of

plutus-core/testlib/PlutusCore/Generators/Hedgehog/Builtin.hs

@@ -19,7 +19,8 @@ import PlutusCore.Crypto.BLS12_381.G2 qualified as BLS12_381.G2
 import PlutusCore.Crypto.BLS12_381.Pairing qualified as BLS12_381.Pairing
 import PlutusCore.Data (Data (..))
 import PlutusCore.Evaluation.Machine.ExMemoryUsage (IntegerCostedLiterally,
-                                                    NumBytesCostedAsNumWords)
+                                                    NumBytesCostedAsNumWords,
+                                                    ValueLogOuterOrMaxInner, ValueTotalSize)
 import PlutusCore.Generators.Hedgehog.AST hiding (genConstant)
 import PlutusCore.Generators.QuickCheck.Builtin
 import PlutusCore.Value (Value)
@@ -109,6 +110,8 @@ genConstant tr
     | Just HRefl <- eqTypeRep tr (typeRep @BLS12_381.Pairing.MlResult) =
           genArbitraryBuiltin @BLS12_381.Pairing.MlResult
     | Just HRefl <- eqTypeRep tr (typeRep @Value) = genArbitraryBuiltin @Value
+    | Just HRefl <- eqTypeRep tr (typeRep @ValueTotalSize) = genArbitraryBuiltin @Value
+    | Just HRefl <- eqTypeRep tr (typeRep @ValueLogOuterOrMaxInner) = genArbitraryBuiltin @Value
     | trPair `App` tr1 `App` tr2 <- tr
     , Just HRefl <- eqTypeRep trPair (typeRep @(,)) =
         -- We can perhaps use the @QuickCheck@ generator here too, but this seems rather hard.