Pool Store

Understanding Compute Unit Consumption on Solana

As a developer building applications on the Solana blockchain, you’re likely curious about how your code is executed. One aspect of this process involves computing unit (CU) consumption, which can vary depending on the instructions used in your program. In this article, we’ll explore why instructions consume different amounts of compute units on Solana and provide examples to illustrate these differences.

What are Compute Units?

On Solana, a compute unit is a measure of the computational effort required to execute an instruction. It’s calculated by dividing the number of gas (the native cryptocurrency used for transaction fees) required to execute the instruction by the block time (the amount of time it takes to execute one transaction on the network).

Why do instructions consume different amounts of compute units?

The main reason for this variation is the difference in the number of gas and computational complexity of each instruction. Instructions are categorized into several types, including:

• Gas-efficient instructions: These instructions have a lower gas cost but require more computation. Examples include call, load, and store.

• High-gas instructions

  : These instructions have a higher gas cost but require less computation. Examples include transfer and send.

The number of gas required to execute an instruction is determined by its complexity, which includes factors such as the address size, data type, and computational requirements.

Measuring CU consumption on Solana

To understand how these instructions consume compute units on Solana, we’ll create a TypeScript test that executes one of our Ixs (a custom instruction) and measures the CU usage. We’ll compare the results across different gas-efficient and high-gas instructions.

import * as solana from '@solana/web3.js';

import { Ix } from './Ix'; // Import your custom Ix implementation


// Create a Solana instance with our test network (e.g., Solana Test Network)

const solanaInstance = new solana.Web3();

const network = 'testnet';


// Execute the custom Ix on the test network

Ix.run(solanaInstance, {

  address: 'your_address',

  data: 'your_data',

});

Measuring CU consumption

We’ll use a library called solana-cpu to measure compute unit consumption. You can install it using npm:

npm install solana-cpu

Create an index file (cpu.js) with the following code:

import * as cpu from 'solana-cpu';


const Ix = require('./Ix');


// Create a Solana instance with our test network

const solanaInstance = new solana.Web3();


function measureCpuUsage() {

  // Execute the custom Ix on the test network and measure CU consumption

  const ctx = {};

  return cpu.measureCpuUsage(

    Ix.run,

    'your_address',

    data: 'your_data'

  );

}


// Measure compute unit consumption for different gas-efficient instructions

const gasEfficientInstructions = ['call', 'load', 'store'];

console.log(CU usage on ${gasEfficientInstructions.join(', ')});

console.log(measureCpuUsage());


// Measure compute unit consumption for high-gas instructions

const highGasInstructions = ['transfer', 'send'];

console.log(CU usage on ${highGasInstructions.join(', ')});

console.log(measureCpuUsage());

Example Output

Running the above code will output a JSON object with the measured CU consumption. The exact results may vary depending on your Solana instance and test network.

“`json

{

“gasEfficientInstructions”: {

“call”: {

“cpu_usage”: “0.01”

},

“load”: {

“cpu_usage”: “0.02”

},

“store”: {

“cpu_usage”: “0.03”

}

},

“highGasInstructions”: {

“transfer”: {

“cpu_usage”: “0.05”

},

“send”: {

“cpu_usage”: “0.

Ethereum Bips