Bitwise operations

plutus-core/changelog.d/20230809_093202_koz.ross_bitwise.md

@@ -0,0 +1,41 @@
+<!--
+A new scriv changelog fragment.
+
+Uncomment the section that is right (remove the HTML comment wrapper).
+-->
+
+<!--
+### Removed
+
+- A bullet item for the Removed category.
+
+-->
+### Added
+
+- Bitwise primitive operations, according to
+  [CIP-0058](https://github.com/cardano-foundation/CIPs/tree/master/CIP-0058).
+
+<!--
+### Changed
+
+- A bullet item for the Changed category.
+
+-->
+<!--
+### Deprecated
+
+- A bullet item for the Deprecated category.
+
+-->
+<!--
+### Fixed
+
+- A bullet item for the Fixed category.
+
+-->
+<!--
+### Security
+
+- A bullet item for the Security category.
+
+-->

plutus-core/cost-model/create-cost-model/CreateBuiltinCostModel.hs

@@ -123,6 +123,18 @@ builtinCostModelNames = BuiltinCostModelBase
   , paramBls12_381_finalVerify           = "bls12_381_finalVerifyModel"
   , paramBlake2b_224                     = "blake2b_224Model"
   , paramKeccak_256                      = "keccak_256Model"
+  , paramIntegerToByteString             = "integerToByteStringModel"
+  , paramByteStringToInteger             = "byteStringToIntegerModel"
+  , paramAndByteString                   = "andByteStringModel"
+  , paramIorByteString                   = "iorByteStringModel"
+  , paramXorByteString                   = "xorByteStringModel"
+  , paramComplementByteString            = "complementByteStringModel"
+  , paramShiftByteString                 = "shiftByteStringModel"
+  , paramRotateByteString                = "rotateByteStringModel"
+  , paramPopCountByteString              = "popCountByteStringModel"
+  , paramTestBitByteString               = "testBitByteStringModel"
+  , paramWriteBitByteString              = "writeBitByteStringModel"
+  , paramFindFirstSetByteString          = "findFirstSetByteStringModel"
   }
 
 
@@ -233,6 +245,19 @@ createBuiltinCostModel bmfile rfile = do
     paramBls12_381_millerLoop            <- getParams bls12_381_millerLoop      paramBls12_381_millerLoop
     paramBls12_381_mulMlResult           <- getParams bls12_381_mulMlResult     paramBls12_381_mulMlResult
     paramBls12_381_finalVerify           <- getParams bls12_381_finalVerify     paramBls12_381_finalVerify
+    -- Bitwise operations
+    paramIntegerToByteString             <- getParams integerToByteString       paramIntegerToByteString
+    paramByteStringToInteger             <- getParams byteStringToInteger       paramByteStringToInteger
+    paramAndByteString                   <- getParams andByteString             paramAndByteString
+    paramIorByteString                   <- getParams iorByteString             paramIorByteString
+    paramXorByteString                   <- getParams xorByteString             paramXorByteString
+    paramComplementByteString            <- getParams complementByteString      paramComplementByteString
+    paramShiftByteString                 <- getParams shiftByteString           paramShiftByteString
+    paramRotateByteString                <- getParams rotateByteString          paramRotateByteString
+    paramPopCountByteString              <- getParams popCountByteString        paramPopCountByteString
+    paramTestBitByteString               <- getParams testBitByteString         paramTestBitByteString
+    paramWriteBitByteString              <- getParams writeBitByteString        paramWriteBitByteString
+    paramFindFirstSetByteString          <- getParams findFirstSetByteString    paramFindFirstSetByteString
 
     paramKeccak_256                      <- getParams keccak_256                paramKeccak_256
     paramBlake2b_224                     <- getParams blake2b_224               paramBlake2b_224
@@ -922,9 +947,80 @@ bls12_381_mulMlResult cpuModelR = do
     pure $ CostingFun cpuModel memModel
 
 bls12_381_finalVerify :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelTwoArguments)
-bls12_381_finalVerify cpuModelR= do
+bls12_381_finalVerify cpuModelR = do
     cpuModel <- ModelTwoArgumentsConstantCost <$> readModelConstantCost cpuModelR
     let memModel = boolMemModel
     pure $ CostingFun cpuModel memModel
 
+integerToByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelOneArgument)
+integerToByteString cpuModelR = do
+  cpuModel <- ModelOneArgumentLinearCost <$> readModelLinearInX cpuModelR
+  let memModel = ModelOneArgumentLinearCost $ ModelLinearSize 0 1
+  pure $ CostingFun cpuModel memModel
+
+byteStringToInteger :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelOneArgument)
+byteStringToInteger cpuModelR = do
+  cpuModel <- ModelOneArgumentLinearCost <$> readModelLinearInX cpuModelR
+  let memModel = ModelOneArgumentLinearCost $ ModelLinearSize 0 1
+  pure $ CostingFun cpuModel memModel
+
+andByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelTwoArguments)
+andByteString cpuModelR = do
+  cpuModel <-  ModelTwoArgumentsMaxSize <$> readModelMaxSize cpuModelR
+  let memModel = ModelTwoArgumentsMaxSize $ ModelMaxSize 0 1
+  pure $ CostingFun cpuModel memModel
+
+iorByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelTwoArguments)
+iorByteString cpuModelR = do
+  cpuModel <-  ModelTwoArgumentsMaxSize <$> readModelMaxSize cpuModelR
+  let memModel = ModelTwoArgumentsMaxSize $ ModelMaxSize 0 1
+  pure $ CostingFun cpuModel memModel
+
+xorByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelTwoArguments)
+xorByteString cpuModelR = do
+  cpuModel <-  ModelTwoArgumentsMaxSize <$> readModelMaxSize cpuModelR
+  let memModel = ModelTwoArgumentsMaxSize $ ModelMaxSize 0 1
+  pure $ CostingFun cpuModel memModel
+
+complementByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelOneArgument)
+complementByteString cpuModelR = do
+  cpuModel <- ModelOneArgumentLinearCost <$> readModelLinearInX cpuModelR
+  let memModel = ModelOneArgumentLinearCost $ ModelLinearSize 0 1
+  pure $ CostingFun cpuModel memModel
+
+shiftByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelTwoArguments)
+shiftByteString cpuModelR = do
+  cpuModel <- undefined
+  let memModel = undefined
+  pure $ CostingFun cpuModel memModel
+
+rotateByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelTwoArguments)
+rotateByteString cpuModelR = do
+  cpuModel <- undefined  -- FIXME
+  let memModel = undefined -- FIXME
+  pure $ CostingFun cpuModel memModel
+
+popCountByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelOneArgument)
+popCountByteString cpuModelR = do
+  cpuModel <- ModelOneArgumentLinearCost <$> readModelLinearInX cpuModelR
+  let memModel = ModelOneArgumentLinearCost $ ModelLinearSize 0 1  -- FIXME
+  pure $ CostingFun cpuModel memModel
+
+testBitByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelTwoArguments)
+testBitByteString cpuModelR = do
+  cpuModel <- undefined -- FIXME
+  let memModel = ModelTwoArgumentsConstantCost 1
+  pure $ CostingFun cpuModel memModel
+
+writeBitByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelThreeArguments)
+writeBitByteString cpuModelR = do
+  cpuModel <- undefined -- FIXME
+  let memModel = undefined -- FIXME
+  pure $ CostingFun cpuModel memModel
+
+findFirstSetByteString :: MonadR m => (SomeSEXP (Region m)) -> m (CostingFun ModelOneArgument)
+findFirstSetByteString cpuModelR = do
+  cpuModel <- ModelOneArgumentLinearCost <$> readModelLinearInX cpuModelR
+  let memModel = undefined -- FIXME
+  pure $ CostingFun cpuModel memModel
 

plutus-core/cost-model/data/builtinCostModel.json

@@ -899,5 +899,197 @@
             "arguments": 10,
             "type": "constant_cost"
         }
+    },
+    "integerToByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "linear_cost"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 0,
+                "slope": 1
+            },
+            "type": "linear_cost"
+        }
+    },
+    "byteStringToInteger": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "linear_cost"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 1,
+                "slope": 1
+            },
+            "type": "linear_cost"
+        }
+    },        
+    "andByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "max_size"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 1,
+                "slope": 1
+            },
+            "type": "max_size"
+        }
+    },
+    "iorByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "max_size"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 1,
+                "slope": 1
+            },
+            "type": "max_size"
+        }
+    },
+    "xorByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "max_size"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 1,
+                "slope": 1
+            },
+            "type": "max_size"
+        }
+    },
+    "complementByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "linear_cost"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 0,
+                "slope": 1
+            },
+            "type": "linear_cost"
+        }
+    },
+    "shiftByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "max_size"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 1,
+                "slope": 1
+            },
+            "type": "max_size"
+        }
+    },
+    "rotateByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "max_size"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 1,
+                "slope": 1
+            },
+            "type": "max_size"
+        }
+    },
+    "popCountByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "linear_cost"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 0,
+                "slope": 1
+            },
+            "type": "linear_cost"
+        }
+    },
+    "testBitByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "linear_in_x"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 0,
+                "slope": 1
+            },
+            "type": "linear_in_x"
+        }
+    },
+    "writeBitByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "linear_in_x"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 0,
+                "slope": 1
+            },
+            "type": "linear_in_x"
+        }
+    },
+    "findFirstSetByteString": {
+        "cpu": {
+            "arguments": {
+                "intercept": 9999999999,
+                "slope": 9999999999
+            },
+            "type": "linear_cost"
+        },
+        "memory": {
+            "arguments": {
+                "intercept": 0,
+                "slope": 1
+            },
+            "type": "linear_cost"
+        }
     }
 }