Merge pull request #2 from morpho-labs/feat/log-buckets

Logarithmic buckets

Author: QGarchery

.gitmodules

@@ -3,8 +3,13 @@
 	url = https://github.com/dapphub/ds-test
 [submodule "lib/forge-std"]
 	path = lib/forge-std
-	url = https://github.com/foundry-rs/forge-std
+	url = https://github.com/MathisGD/forge-std
+	branch = feat/real-gas-consumption
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts
 	branch = v4.8.0
+[submodule "lib/morpho-utils"]
+	path = lib/morpho-utils
+	url = https://github.com/morpho-dao/morpho-utils
+

certora/applyHarnessFIFO.patch

@@ -37,7 +37,7 @@ diff -ruN MockDLL.sol MockDLL.sol
 --- MockDLL.sol	1970-01-01 01:00:00.000000000 +0100
 +++ MockDLL.sol	2022-12-16 20:35:27.432652652 +0100
 @@ -0,0 +1,111 @@
-+// SPDX-License-Identifier: GNU AGPLv3
++// SPDX-License-Identifier: AGPL-3.0-only
 +pragma solidity ^0.8.0;
 +
 +import "./DoubleLinkedList.sol";

certora/applyHarnessSimple.patch

@@ -56,7 +56,7 @@ diff -ruN MockDLL.sol MockDLL.sol
 --- MockDLL.sol	1970-01-01 01:00:00.000000000 +0100
 +++ MockDLL.sol	2022-11-11 11:27:17.368989154 +0100
 @@ -0,0 +1,91 @@
-+// SPDX-License-Identifier: GNU AGPLv3
++// SPDX-License-Identifier: AGPL-3.0-only
 +pragma solidity ^0.8.0;
 +
 +import "./DoubleLinkedList.sol";

foundry.toml

@@ -1,5 +1,11 @@
 [profile.default]
 solc_version = "0.8.17"
+no_match_test = "testGasUsage"
+
+[profile.gas]
+no_match_test = "None"
+match_test = "testGasUsage"
+verbosity = 2
 
 [fuzz]
 runs = 1024

lib/ds-test

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+library BucketDLL {
+    /// STRUCTS ///
+
+    struct Account {
+        address prev;
+        address next;
+    }
+
+    struct List {
+        mapping(address => Account) accounts;
+    }
+
+    /// INTERNAL ///
+
+    /// @notice Returns the address at the head of the `_list`.
+    /// @param _list The list from which to get the head.
+    /// @return The address of the head.
+    function getHead(List storage _list) internal view returns (address) {
+        return _list.accounts[address(0)].next;
+    }
+
+    /// @notice Returns the address at the tail of the `_list`.
+    /// @param _list The list from which to get the tail.
+    /// @return The address of the tail.
+    function getTail(List storage _list) internal view returns (address) {
+        return _list.accounts[address(0)].prev;
+    }
+
+    /// @notice Returns the next id address from the current `_id`.
+    /// @param _list The list to search in.
+    /// @param _id The address of the current account.
+    /// @return The address of the next account.
+    function getNext(List storage _list, address _id) internal view returns (address) {
+        return _list.accounts[_id].next;
+    }
+
+    /// @notice Returns the previous id address from the current `_id`.
+    /// @param _list The list to search in.
+    /// @param _id The address of the current account.
+    /// @return The address of the previous account.
+    function getPrev(List storage _list, address _id) internal view returns (address) {
+        return _list.accounts[_id].prev;
+    }
+
+    /// @notice Removes an account of the `_list`.
+    /// @dev This function should not be called with `_id` equal to address 0.
+    /// @param _list The list to search in.
+    /// @param _id The address of the account.
+    /// @return Whether the bucket is empty after removal.
+    function remove(List storage _list, address _id) internal returns (bool) {
+        Account memory account = _list.accounts[_id];
+        address prev = account.prev;
+        address next = account.next;
+
+        _list.accounts[prev].next = next;
+        _list.accounts[next].prev = prev;
+
+        delete _list.accounts[_id];
+
+        return (prev == address(0) && next == address(0));
+    }
+
+    /// @notice Inserts an account in the `_list`.
+    /// @dev This function should not be called with `_id` equal to address 0.
+    /// @param _list The list to search in.
+    /// @param _id The address of the account.
+    /// @param _head Tells whether to insert at the head or at the tail of the list.
+    /// @return Whether the bucket was empty before insertion.
+    function insert(
+        List storage _list,
+        address _id,
+        bool _head
+    ) internal returns (bool) {
+        if (_head) {
+            address head = _list.accounts[address(0)].next;
+            _list.accounts[address(0)].next = _id;
+            _list.accounts[head].prev = _id;
+            _list.accounts[_id].next = head;
+            return head == address(0);
+        } else {
+            address tail = _list.accounts[address(0)].prev;
+            _list.accounts[address(0)].prev = _id;
+            _list.accounts[tail].next = _id;
+            _list.accounts[_id].prev = tail;
+            return tail == address(0);
+        }
+    }
+}

lib/forge-std

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "./BucketDLL.sol";
+
+library LogarithmicBuckets {
+    using BucketDLL for BucketDLL.List;
+
+    struct BucketList {
+        mapping(uint256 => BucketDLL.List) lists;
+        mapping(address => uint256) valueOf;
+        uint256 bucketsMask;
+    }
+
+    /// ERRORS ///
+
+    /// @notice Thrown when the address is zero at insertion.
+    error ZeroAddress();
+
+    /// @notice Thrown when 0 value is inserted.
+    error ZeroValue();
+
+    /// INTERNAL ///
+
+    /// @notice Updates an account in the `_buckets`.
+    /// @param _buckets The buckets to update.
+    /// @param _id The address of the account.
+    /// @param _newValue The new value of the account.
+    /// @param _head Indicates whether to insert the new values at the head or at the tail of the buckets list.
+    function update(
+        BucketList storage _buckets,
+        address _id,
+        uint256 _newValue,
+        bool _head
+    ) internal {
+        if (_id == address(0)) revert ZeroAddress();
+        uint256 value = _buckets.valueOf[_id];
+        _buckets.valueOf[_id] = _newValue;
+
+        if (value == 0) {
+            if (_newValue == 0) revert ZeroValue();
+            _insert(_buckets, _id, _computeBucket(_newValue), _head);
+            return;
+        }
+
+        uint256 currentBucket = _computeBucket(value);
+        if (_newValue == 0) {
+            _remove(_buckets, _id, currentBucket);
+            return;
+        }
+
+        uint256 newBucket = _computeBucket(_newValue);
+        if (newBucket != currentBucket) {
+            _remove(_buckets, _id, currentBucket);
+            _insert(_buckets, _id, newBucket, _head);
+        }
+    }
+
+    /// @notice Returns the value of `_id`.
+    /// @param _buckets The buckets to search in.
+    /// @param _id The address of the account.
+    function getValueOf(BucketList storage _buckets, address _id) internal view returns (uint256) {
+        return _buckets.valueOf[_id];
+    }
+
+    /// @notice Returns the bucket in which to look for `_value`.
+    /// @param _buckets The buckets to search in.
+    /// @param _value The value to look for.
+    function getBucketOf(BucketList storage _buckets, uint256 _value)
+        internal
+        view
+        returns (BucketDLL.List storage)
+    {
+        uint256 bucket = _computeBucket(_value);
+        return _buckets.lists[bucket];
+    }
+
+    /// @notice Returns the address in `_buckets` that is a candidate for matching the value `_value`.
+    /// @param _buckets The buckets to get the head.
+    /// @param _value The value to match.
+    /// @return The address of the head.
+    function getMatch(BucketList storage _buckets, uint256 _value) internal view returns (address) {
+        uint256 bucketsMask = _buckets.bucketsMask;
+        if (bucketsMask == 0) return address(0);
+        uint256 lowerMask = _setLowerBits(_value);
+
+        uint256 next = _nextBucket(lowerMask, bucketsMask);
+
+        if (next != 0) return _buckets.lists[next].getHead();
+
+        uint256 prev = _prevBucket(lowerMask, bucketsMask);
+
+        return _buckets.lists[prev].getHead();
+    }
+
+    /// PRIVATE ///
+
+    /// @notice Removes an account in the `_buckets`.
+    /// @dev Does not update the value.
+    /// @param _buckets The buckets to modify.
+    /// @param _id The address of the account to remove.
+    /// @param _bucket The mask of the bucket where to remove.
+    function _remove(
+        BucketList storage _buckets,
+        address _id,
+        uint256 _bucket
+    ) private {
+        if (_buckets.lists[_bucket].remove(_id))
+            _buckets.bucketsMask &= _bucket ^ type(uint256).max;
+    }
+
+    /// @notice Inserts an account in the `_buckets`.
+    /// @dev Expects that `_id` != 0.
+    /// @dev Does not update the value.
+    /// @param _buckets The buckets to modify.
+    /// @param _id The address of the account to update.
+    /// @param _bucket The mask of the bucket where to insert.
+    /// @param _head Whether to insert at the head or at the tail of the list.
+    function _insert(
+        BucketList storage _buckets,
+        address _id,
+        uint256 _bucket,
+        bool _head
+    ) private {
+        if (_buckets.lists[_bucket].insert(_id, _head)) _buckets.bucketsMask |= _bucket;
+    }
+
+    /// @notice Returns the bucket in which the given value would fall.
+    function _computeBucket(uint256 _value) private pure returns (uint256) {
+        uint256 lowerMask = _setLowerBits(_value);
+        return lowerMask ^ (lowerMask >> 1);
+    }
+
+    /// @notice Sets all the bits lower than (or equal to) the highest bit in the input.
+    /// @dev This is the same as rounding the input the nearest upper value of the form `2 ** n - 1`.
+    function _setLowerBits(uint256 x) private pure returns (uint256 y) {
+        assembly {
+            x := or(x, shr(1, x))
+            x := or(x, shr(2, x))
+            x := or(x, shr(4, x))
+            x := or(x, shr(8, x))
+            x := or(x, shr(16, x))
+            x := or(x, shr(32, x))
+            x := or(x, shr(64, x))
+            y := or(x, shr(128, x))
+        }
+    }
+
+    /// @notice Returns the following bucket which contains greater values.
+    /// @dev The bucket returned is the lowest that is in `bucketsMask` and not in `lowerMask`.
+    function _nextBucket(uint256 lowerMask, uint256 bucketsMask)
+        private
+        pure
+        returns (uint256 bucket)
+    {
+        assembly {
+            let higherBucketsMask := and(not(lowerMask), bucketsMask)
+            bucket := and(higherBucketsMask, add(not(higherBucketsMask), 1))
+        }
+    }
+
+    /// @notice Returns the preceding bucket which contains smaller values.
+    /// @dev The bucket returned is the highest that is in both `bucketsMask` and `lowerMask`.
+    function _prevBucket(uint256 lowerMask, uint256 bucketsMask) private pure returns (uint256) {
+        uint256 lowerBucketsMask = _setLowerBits(lowerMask & bucketsMask);
+        return lowerBucketsMask ^ (lowerBucketsMask >> 1);
+    }
+}