Realignment

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

@@ -87,7 +87,7 @@ benchIntegerToByteString =
  -- Widths are in words: we need to convert those to widths in bytes for the implementation
  let width' = 8 * fromIntegral width
  in bgroup (showMemoryUsage e) [
- bgroup (showMemoryUsage (LiteralByteSize width')) [mkBM e width' n]
+ bgroup (showMemoryUsage (IntegerCostedAsByteSize width')) [mkBM e width' n]
  ]
  where mkBM x y z = benchDefault (showMemoryUsage z) $ mkApp3 b [] x y z
  in bgroup (show b) $ fmap mkOneBM l

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

@@ -192,7 +192,7 @@ createOneTermBuiltinBench
  -> Benchmark
 createOneTermBuiltinBench name tys xs =
  bgroup (show name) $ [mkBM x | x <- xs]
-  where mkBM x = benchDefault (showMemoryUsage x) $ mkApp1 name tys x
+ where mkBM x = benchDefault (showMemoryUsage x) $ mkApp1 name tys x
 
 {- | Given a builtin function f of type a * b -> _ together with lists xs::[a] and
  ys::[b], create a collection of benchmarks which run f on all pairs in
@@ -210,7 +210,7 @@ createTwoTermBuiltinBench
  -> Benchmark
 createTwoTermBuiltinBench name tys xs ys =
  bgroup (show name) $ [bgroup (showMemoryUsage x) [mkBM x y | y <- ys] | x <- xs]
-  where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp2 name tys x y
+ where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp2 name tys x y
 
 createTwoTermBuiltinBenchLiteralInY
  :: ( fun ~ DefaultFun, uni ~ DefaultUni
@@ -225,8 +225,8 @@ createTwoTermBuiltinBenchLiteralInY
  -> Benchmark
 createTwoTermBuiltinBenchLiteralInY fun tys xs ns =
  bgroup (show fun) $ [bgroup (showMemoryUsage x) [mkBM x n | n <- ns] | x <- xs]
-  where mkBM x n =
-  benchDefault (showMemoryUsage (LiteralInteger n)) $ mkApp2 fun tys x n
+ where mkBM x n =
+ benchDefault (showMemoryUsage (IntegerCostedLiterally n)) $ mkApp2 fun tys x n
 
 createTwoTermBuiltinBenchWithFlag
  :: ( fun ~ DefaultFun, uni ~ DefaultUni
@@ -242,7 +242,7 @@ createTwoTermBuiltinBenchWithFlag
  -> Benchmark
 createTwoTermBuiltinBenchWithFlag fun tys flag xs ys =
  bgroup (show fun) $ [bgroup (showMemoryUsage x) [mkBM x y | y <- ys] | x <- xs]
-  where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp3 fun tys flag x y
+ where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp3 fun tys flag x y
 
 {- | Given a builtin function f of type a * b -> _ together with lists xs::[a] and
  ys::[b], create a collection of benchmarks which run f on all pairs in 'zip
@@ -267,7 +267,7 @@ createTwoTermBuiltinBenchElementwise
  -> Benchmark
 createTwoTermBuiltinBenchElementwise name tys xs ys =
  bgroup (show name) $ zipWith (\x y -> bgroup (showMemoryUsage x) [mkBM x y]) xs ys
-  where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp2 name tys x y
+ where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp2 name tys x y
 -- TODO: throw an error if xmem != ymem? That would suggest that the caller has
 -- done something wrong.
 
@@ -284,8 +284,8 @@ createTwoTermBuiltinBenchElementwiseLiteralInX
  -> Benchmark
 createTwoTermBuiltinBenchElementwiseLiteralInX name tys xs ys =
  bgroup (show name) $
- zipWith (\x y -> bgroup (showMemoryUsage (LiteralInteger x)) [mkBM x y]) xs ys
-  where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp2 name tys x y
+ zipWith (\x y -> bgroup (showMemoryUsage (IntegerCostedLiterally x)) [mkBM x y]) xs ys
+ where mkBM x y = benchDefault (showMemoryUsage y) $ mkApp2 name tys x y
 -- TODO: throw an error if xmem != ymem? That would suggest that the caller has
 -- done something wrong.
 
@@ -303,7 +303,7 @@ createTwoTermBuiltinBenchElementwiseLiteralInY
 createTwoTermBuiltinBenchElementwiseLiteralInY name tys xs ys =
  bgroup (show name) $
  zipWith (\x y -> bgroup (showMemoryUsage x) [mkBM x y]) xs ys
-  where mkBM x y = benchDefault (showMemoryUsage (LiteralInteger y)) $ mkApp2 name tys x y
+ where mkBM x y = benchDefault (showMemoryUsage (IntegerCostedLiterally y)) $ mkApp2 name tys x y
 
 {- | Given a builtin function f of type a * b * c -> _ together with a list of
  inputs of type (a,b,c), create a collection of benchmarks which run f on all
@@ -324,6 +324,6 @@ createThreeTermBuiltinBenchElementwise name tys inputs =
  map
  (\(x, y, z) -> bgroup (showMemoryUsage x) [bgroup (showMemoryUsage y) [mkBM x y z]])
  inputs
-  where mkBM x y z = benchDefault (showMemoryUsage z) $ mkApp3 name tys x y z
+ where mkBM x y z = benchDefault (showMemoryUsage z) $ mkApp3 name tys x y z
 -- TODO: throw an error if xmem != ymem? That would suggest that the caller has
 -- done something wrong.

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

@@ -21,9 +21,10 @@ import PlutusCore.Data (Data (..))
 import PlutusCore.Default.Universe
 import PlutusCore.Evaluation.Machine.BuiltinCostModel
 import PlutusCore.Evaluation.Machine.ExBudgetStream (ExBudgetStream)
-import PlutusCore.Evaluation.Machine.ExMemoryUsage (ExMemoryUsage, ListCostedByLength (..),
- LiteralByteSize (..), LiteralInteger (..),
- memoryUsage, singletonRose)
+import PlutusCore.Evaluation.Machine.ExMemoryUsage (ExMemoryUsage, IntegerCostedAsByteSize (..),
+ IntegerCostedLiterally (..),
+ ListCostedByLength (..), memoryUsage,
+ singletonRose)
 import PlutusCore.Pretty (PrettyConfigPlc)
 
 import PlutusCore.Bitwise qualified as Bitwise
@@ -1867,10 +1868,10 @@ instance uni ~ DefaultUni => ToBuiltinMeaning uni DefaultFun where
  -- Conversions
  {- See Note [Input length limitation for IntegerToByteString] -}
  toBuiltinMeaning _semvar IntegerToByteString =
- let integerToByteStringDenotation :: Bool -> LiteralByteSize -> Integer -> BuiltinResult BS.ByteString
- {- The second argument is wrapped in a LiteralByteSize to allow us to interpret it as a size during
+ let integerToByteStringDenotation :: Bool -> IntegerCostedAsByteSize -> Integer -> BuiltinResult BS.ByteString
+ {- The second argument is wrapped in a IntegerCostedAsByteSize to allow us to interpret it as a size during
  costing. It appears as an integer in UPLC: see Note [Integral types as Integer]. -}
- integerToByteStringDenotation b (LiteralByteSize w) = Bitwise.integerToByteStringWrapper b w
+ integerToByteStringDenotation b (IntegerCostedAsByteSize w) = Bitwise.integerToByteStringWrapper b w
  {-# INLINE integerToByteStringDenotation #-}
  in makeBuiltinMeaning
  integerToByteStringDenotation
@@ -1936,25 +1937,25 @@ instance uni ~ DefaultUni => ToBuiltinMeaning uni DefaultFun where
  (runCostingFunTwoArguments . paramWriteBits)
 
  toBuiltinMeaning _semvar ReplicateByte =
- let replicateByteDenotation :: LiteralInteger -> Word8 -> BuiltinResult BS.ByteString
- replicateByteDenotation (LiteralInteger n) w = Bitwise.replicateByte n w
+ let replicateByteDenotation :: IntegerCostedLiterally -> Word8 -> BuiltinResult BS.ByteString
+ replicateByteDenotation (IntegerCostedLiterally n) w = Bitwise.replicateByte n w
  -- FIXME: be careful about the coercion inreplicateByte
  {-# INLINE replicateByteDenotation #-}
  in makeBuiltinMeaning
  replicateByteDenotation
  (runCostingFunTwoArguments . paramReplicateByte)
 
  toBuiltinMeaning _semvar ShiftByteString =
- let shiftByteStringDenotation :: BS.ByteString -> LiteralInteger -> BS.ByteString
- shiftByteStringDenotation s (LiteralInteger n) = Bitwise.shiftByteString s (fromIntegral n)
+ let shiftByteStringDenotation :: BS.ByteString -> IntegerCostedLiterally -> BS.ByteString
+ shiftByteStringDenotation s (IntegerCostedLiterally n) = Bitwise.shiftByteString s (fromIntegral n)
  {-# INLINE shiftByteStringDenotation #-}
  in makeBuiltinMeaning
  shiftByteStringDenotation
  (runCostingFunTwoArguments . paramShiftByteString)
 
  toBuiltinMeaning _semvar RotateByteString =
- let rotateByteStringDenotation :: BS.ByteString -> LiteralInteger -> BS.ByteString
- rotateByteStringDenotation s (LiteralInteger n) = Bitwise.rotateByteString s (fromIntegral n)
+ let rotateByteStringDenotation :: BS.ByteString -> IntegerCostedLiterally -> BS.ByteString
+ rotateByteStringDenotation s (IntegerCostedLiterally n) = Bitwise.rotateByteString s (fromIntegral n)
  {-# INLINE rotateByteStringDenotation #-}
  in makeBuiltinMeaning
  rotateByteStringDenotation

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

@@ -49,8 +49,9 @@ 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
-import PlutusCore.Evaluation.Machine.ExMemoryUsage (ListCostedByLength (..), LiteralByteSize (..),
- LiteralInteger (..))
+import PlutusCore.Evaluation.Machine.ExMemoryUsage (IntegerCostedAsByteSize (..),
+ IntegerCostedLiterally (..),
+ ListCostedByLength (..))
 import PlutusCore.Pretty.Extra
 
 import Data.ByteString (ByteString)
@@ -469,18 +470,18 @@ deriving via AsInteger Word64 instance HasConstantIn DefaultUni term =>
  ReadKnownIn DefaultUni term Word64
 
 deriving newtype instance
- KnownTypeAst tyname DefaultUni LiteralByteSize
+ KnownTypeAst tyname DefaultUni IntegerCostedAsByteSize
 deriving newtype instance HasConstantIn DefaultUni term =>
- MakeKnownIn DefaultUni term LiteralByteSize
+ MakeKnownIn DefaultUni term IntegerCostedAsByteSize
 deriving newtype instance HasConstantIn DefaultUni term =>
- ReadKnownIn DefaultUni term LiteralByteSize
+ ReadKnownIn DefaultUni term IntegerCostedAsByteSize
 
 deriving newtype instance
- KnownTypeAst tyname DefaultUni LiteralInteger
+ KnownTypeAst tyname DefaultUni IntegerCostedLiterally
 deriving newtype instance HasConstantIn DefaultUni term =>
- MakeKnownIn DefaultUni term LiteralInteger
+ MakeKnownIn DefaultUni term IntegerCostedLiterally
 deriving newtype instance HasConstantIn DefaultUni term =>
- ReadKnownIn DefaultUni term LiteralInteger
+ ReadKnownIn DefaultUni term IntegerCostedLiterally
 
 deriving newtype instance
  forall tyname a .

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

@@ -10,8 +10,8 @@ module PlutusCore.Evaluation.Machine.ExMemoryUsage
  , singletonRose
  , ExMemoryUsage(..)
  , flattenCostRose
- , LiteralByteSize(..)
- , LiteralInteger(..)
+ , IntegerCostedAsByteSize(..)
+ , IntegerCostedLiterally(..)
  , ListCostedByLength(..)
  ) where
 
@@ -170,24 +170,29 @@ instance ExMemoryUsage () where
  memoryUsage () = singletonRose 1
  {-# INLINE memoryUsage #-}
 
-{- | When invoking a built-in function, a value of type LiteralByteSize can be
- used transparently as a built-in Integer but with a different size measure:
- see Note [Integral types as Integer]. This is required by the
+{- | When invoking a built-in function, a value of type `IntegerCostedAsByteSize`
+ can be used transparently as a built-in Integer but with a different size
+ measure: see Note [Integral types as Integer]. This is required by the
  `integerToByteString` builtin, which takes an argument `w` specifying the
  width (in bytes) of the output bytestring (zero-padded to the desired size).
  The memory consumed by the function is given by `w`, *not* the size of `w`.
- The `LiteralByteSize` type wraps an Integer `w` in a newtype whose
+ The `IntegerCostedAsByteSize` type wraps an Integer `w` in a newtype whose
  `ExMemoryUsage` is equal to the number of eight-byte words required to
  contain `w` bytes, allowing its costing function to work properly.
 -}
-newtype LiteralByteSize = LiteralByteSize { unLiteralByteSize :: Integer }
-instance ExMemoryUsage LiteralByteSize where
- memoryUsage (LiteralByteSize n) = singletonRose . fromIntegral $ ((n-1) `div` 8) + 1
+newtype IntegerCostedAsByteSize = IntegerCostedAsByteSize { unIntegerCostedAsByteSize :: Integer }
+instance ExMemoryUsage IntegerCostedAsByteSize where
+ memoryUsage (IntegerCostedAsByteSize n) = singletonRose . fromIntegral $ ((n-1) `div` 8) + 1
  {-# INLINE memoryUsage #-}
 
-newtype LiteralInteger = LiteralInteger { unLiteralInteger :: Integer }
-instance ExMemoryUsage LiteralInteger where
- memoryUsage (LiteralInteger n) = singletonRose . fromIntegral $ abs n
+{- | A wrapper for Integers whose "memory usage" for costing purposes is the
+ absolute value of the integer. This is used for costing built-in functions
+ such as `shiftByteString` and `rotateByteString`, where the cost may depend
+ on the actual value of the shift argument, not its size.
+-}
+newtype IntegerCostedLiterally = IntegerCostedLiterally { unIntegerCostedLiterally :: Integer }
+instance ExMemoryUsage IntegerCostedLiterally where
+ memoryUsage (IntegerCostedLiterally n) = singletonRose . fromIntegral $ abs n
  {-# INLINE memoryUsage #-}
 
 {- | A wrappper for lists whose "memory usage" for costing purposes is just the

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

@@ -37,7 +37,7 @@ 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 (LiteralByteSize)
+import PlutusCore.Evaluation.Machine.ExMemoryUsage (IntegerCostedAsByteSize)
 import PlutusCore.Evaluation.Machine.MachineParameters (CostModel (..))
 import UntypedPlutusCore.Evaluation.Machine.Cek.CekMachineCosts (CekMachineCosts,
  CekMachineCostsBase (..))
@@ -109,7 +109,7 @@ smallConstant tr
  | Just HRefl <- eqTypeRep tr (typeRep @Integer) = SomeConst (0 :: Integer)
  | Just HRefl <- eqTypeRep tr (typeRep @Int) = SomeConst (0 :: Integer)
  | Just HRefl <- eqTypeRep tr (typeRep @Word8) = SomeConst (0 :: Integer)
- | Just HRefl <- eqTypeRep tr (typeRep @LiteralByteSize) = SomeConst (0 :: Integer)
+ | Just HRefl <- eqTypeRep tr (typeRep @IntegerCostedAsByteSize) = SomeConst (0 :: Integer)
  | Just HRefl <- eqTypeRep tr (typeRep @Bool) = SomeConst False
  | Just HRefl <- eqTypeRep tr (typeRep @BS.ByteString) = SomeConst $ BS.pack []
  | Just HRefl <- eqTypeRep tr (typeRep @Text) = SomeConst ("" :: Text)

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

@@ -29,7 +29,7 @@ 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.Evaluation.Machine.ExMemoryUsage (LiteralByteSize, LiteralInteger)
+import PlutusCore.Evaluation.Machine.ExMemoryUsage (IntegerCostedAsByteSize, IntegerCostedLiterally)
 import PlutusCore.Generators.Hedgehog.AST hiding (genConstant)
 
 import Data.ByteString qualified as BS
@@ -81,8 +81,8 @@ genConstant tr
  | Just HRefl <- eqTypeRep tr (typeRep @Integer) = SomeGen genInteger
  | Just HRefl <- eqTypeRep tr (typeRep @Int) = SomeGen genInteger
  | Just HRefl <- eqTypeRep tr (typeRep @Word8) = SomeGen genInteger
- | Just HRefl <- eqTypeRep tr (typeRep @LiteralByteSize) = SomeGen genInteger
--- | Just HRefl <- eqTypeRep tr (typeRep @LiteralInteger) = SomeGen genInteger
+ | Just HRefl <- eqTypeRep tr (typeRep @IntegerCostedAsByteSize) = SomeGen genInteger
+-- | Just HRefl <- eqTypeRep tr (typeRep @IntegerCostedLiterally) = SomeGen genInteger
  | Just HRefl <- eqTypeRep tr (typeRep @Bool) = SomeGen Gen.bool
  | Just HRefl <- eqTypeRep tr (typeRep @BS.ByteString) = SomeGen genByteString
  | Just HRefl <- eqTypeRep tr (typeRep @Text) = SomeGen genText