Solidity Gas Optimization: EVM Storage and Unchecked Arithmetic

Game save systems use memory optimization techniques like bit packing (Beauty pack) to efficiently store game state information, where multiple boolean variables (such as whether 32 chests are opened) are compressed into a single 32-bit variable, using only 1 bit per item instead of 8 bits per boolean variable.

Solidity automatically packs variables together in storage when possible to save space. For example, two uint128 variables can be packed into a single 256-bit storage slot, with each occupying half the slot. This packing occurs because their combined size (256 bits) exactly fills one slot. Variables larger than 128 bits cannot be packed and occupy their own full slots. This optimization reduces the overall storage footprint of contracts.

Advanced gas optimization requires balancing efficiency with security. Transaction data costs 16 gas units per byte, making data inclusion expensive. Payable functions cost less than non-payable functions because they don't require checking for Ether inclusion. State variables are permanently stored on the blockchain and consume significant gas, while local variables exist only during function execution. Using state variables unnecessarily can cost thousands of gas units more than local variables. Variable packing stores multiple small variables in a single 32-byte slot to reduce gas costs, with unused space padded with zeros. Advanced optimization techniques include reducing state changes by performing calculations in local variables first, using unchecked arithmetic when overflow is impossible, and leveraging memory instead of storage. Developers must balance optimization with security, as unchecked operations can introduce vulnerabilities. Industry best practices demonstrate that optimization should only be applied when security risks are well-understood.

Algorithm design requires defining state variables to track progress. For the packing problem, two key variables are needed: (1) a counter for the number of boxes (starting from 1 since we begin with an empty box), and (2) a variable for the current box's weight (starting from 0). These variables maintain the state of the algorithm as it processes each object, allowing the program to make decisions about whether to add an object to the current box or start a new one.

This section covers mask packing for efficient data transmission in industrial automation. The put bit function packs Boolean variables into masks by specifying the mask variable, bit number, and new state. To encode four Boolean variables into one mask, you chain four put bit blocks where each block's output feeds into the next. The first block uses either the output mask or an empty mask (zero). Bit 0 receives the first output state, bit 1 the second, and so on. A single mask contains 16 bits (0-15), so longer chains can pack more values. This technique is essential for working with input/output modules from MX 110 or 210 series. The practical application involves transferring logical variables from operator panels (like SMI 200) to programmable relays (like PR) by packing variables into one integer using put bit, then extracting them using extract functions. This method significantly reduces network memory usage compared to transmitting each Boolean variable separately.

Ethereum revolutionized blockchain by introducing smart contracts—business logic running on the blockchain. The Ethereum Virtual Machine (EVM) executes this code. Three main smart contract languages exist: Serpent (Python-influenced, deprecated), Triple L (Lisp-based, minimalistic), and Solidity (JavaScript-influenced, most popular). Solidity is a contract-oriented high-level language targeting the EVM, statically typed, and designed for lightweight bytecode execution. Development tools include text editors (Atom, Sublime Text, VS Code), solc compiler (via Docker/npm), and Remix (online IDE for beginners). Solidity operators mirror JavaScript: comparison, bitwise (AND, OR, XOR, NOT), and arithmetic operators. Bitwise operations require bytes1 variables and 0x hexadecimal prefix. NOT is implemented as XOR with 0xff since native negation is unsupported.

This comprehensive section covers bitwise operators working on binary levels: AND (&) returns 1 only when both bits are 1; OR (|) returns 1 if any bit is 1; NOT (~) inverts all bits requiring 2's complement for negative numbers; XOR (^) returns 1 only when exactly one bit is 1. The section also explains shift operators: left shift (<<) multiplies by 2^shift_amount but can produce negatives for large numbers; right shift (>>) divides by 2^shift_amount. Padding uses 0s for positive numbers but is compiler-dependent for negatives. These operators enable efficient low-level programming and bit manipulation.

SHA-256 operates on 32-bit words using four fundamental bitwise operations: (1) Shift Right - moves bits to the right by specified positions, discarding bits that fall off the end; (2) Rotation Right (Circular Shift) - shifts bits circularly so bits that fall off one side reappear on the other side; (3) Exclusive-OR (XOR) - produces 1 only when exactly one of two inputs is 1, creating a balanced representation of multiple bits; (4) Addition - performs normal integer addition on binary numbers, constrained to 32 bits using modulus 2^32 to wrap around results exceeding 32 bits.

Bitwise operators manipulate data at the binary level (ones and zeros), unlike regular math operations. Computers represent all data as binary sequences. Key operators include AND (both bits must be 1), OR (either bit can be 1), XOR (exactly one bit must be 1), NOT (inverts all bits), and shift operators (move bits left or right). These operations originated from early computing constraints in the 1970s when resources were extremely limited. Understanding bitwise operations is essential for embedded programming, memory optimization, and low-level system development.

Nethermind has evolved from optimizing their own client to developing specialized devnets (PerfNet for compute-heavy scenarios and BloatNet for state growth analysis) and standardized benchmarking tools (Gas Benchmarks) that enable reproducible, reliable performance testing across all Ethereum clients, revealing critical performance flaws invisible on mainnet and guiding gas limit increases from 36 to 45 million and beyond.

Gas benchmarking evaluates client performance under computational loads through systematic testing of repricing scenarios and stateful operations. Teams optimize database designs to prevent bottlenecks and develop faster historical block tracing methods using specialized plugins. New RPC endpoints enable building blocks from transactions, accelerating development workflows. These methodologies ensure clients can scale with network growth while maintaining performance standards across diverse implementations.

Profiling tools can reveal why implementations differ in performance. For example, Java's JIT compiler can optimize division operations using multiplication and bit shifts, while Scala's compiler couldn't. This optimization was possible because Java's method had predictable initial calls, while Scala's recursive method had unpredictable behavior. The fundamental principle of benchmarking is: if you write a benchmark, it doesn't mean it's correct. You must always verify that your benchmark actually measures what you intend to measure. The infrastructure tools are not magic solutions - they are code that can contain bugs. Every benchmark must be analyzed to ensure it produces valid results for your specific use case.

Performance profiling tools help identify bottlenecks and measure improvements. Memory profilers (Visual Studio, JetBrains Memory Profiler) show allocation patterns across generations and detect memory leaks through snapshot comparison. CPU profilers (dotTrace, Visual Studio) identify where CPU time is spent and detect thread blocking. Benchmark.NET provides accurate micro-benchmarking with memory allocation tracking and code generation analysis. Compiler visualization tools (shortlab.io, PowerUp) show how code is compiled to IL and assembly, revealing optimization opportunities. These tools are essential for systematic performance optimization.

Profiling identifies performance bottlenecks through statistical data collection about running systems. Tools range from compiler-level sampling profilers like gprof to hardware performance monitoring units (PMUs). PMUs provide detailed low-level metrics including cache misses, branch prediction accuracy, stall cycles, and instruction counts. Profiling introduces interference with actual performance, making uninstrumented benchmarking essential for final validation. Proper performance measurement requires statistical rigor beyond simple averaging—always examine variance (standard deviation) alongside mean values to detect unexpected system behavior. Standard deviation assumes normal distribution properties, though computer measurements often follow binomial distributions. The Central Limit Theorem suggests 30+ samples approximate normality, but practical constraints often limit sample sizes. Successful benchmarking requires warm-up runs to eliminate cold cache effects, varying input data and addresses to prevent compiler optimizations, using seeded random number generators for reproducibility, and verifying output correctness as subsystems may implement optimizations altering observed behavior.