Whats the cheapest/most gas efficient way of converting bytes32 to uint24?

Question

I have an array of bytes32 with various pieces of information at various byte positions in it, and 2nd 3 bytes are a number, which I convert to uint24 like so (where currentData is of type bytes32):

uint24 convertedNumber = uint24(bytes3(currentData << 24));

However the operation happens in a loop, so the cost of shifting, then creating a bytes3, then converting to uint24 can add up as the size of the input array grows. Is there a more gas-efficient way to convert 3 bytes at a position inside a bytes32 into uint24?

Answer 1

I guess there is not much to get since not many operations are included and the operations are very fundamental (shift, assign). I created a solution that can save 28 gas per conversion though:

pragma solidity ^0.6.3;

contract Test {
    function b32ToU24(bytes32 barray) external pure returns (uint24) {
        return uint24(bytes3(barray << 24));
    }

    function b32ToU24ASM(bytes32 barray) external pure returns (uint24) {
        uint24 result;

        assembly {
            // Right shift barray by 26 bytes, assign remaining 6 bytes to result
            // Since result is an uint24, the 3 msB will not be regarded
            result := shr(0xd0, barray)
        }

        return result;
    }
}

Using the solc compiler 0.6.3 with optimizations, function b32ToU24 requires 258 gas whereas function b32ToU24ASM requires 230 gas. Without optimization 327 gas and 309 gas respectively. Depending on the context there might be more margin for optimizations.

Edit1: Since you have an array of bytes32 values, you have to adapt the solution in a way that iterates through the array and loads the data (using mload) before. If you want to store the values in an array of uint24 you can use mstore with an adequate offset. (assuming everything happens in memory)