Skip to content

Commit

Permalink
cleanup for compute budget program
Browse files Browse the repository at this point in the history
  • Loading branch information
@ibhatt-jumptrading
ibhatt-jumptrading committed Aug 5, 2024
1 parent 65c003b commit 0fb6018
Showing 1 changed file with 55 additions and 61 deletions.
116 changes: 55 additions & 61 deletions src/flamenco/runtime/program/fd_compute_budget_program.c
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
#include "fd_compute_budget_program.h"

#include "../fd_runtime_err.h"
#include "../fd_system_ids.h"
#include "../fd_executor.h"
#include "../context/fd_exec_instr_ctx.h"
Expand All @@ -13,42 +14,48 @@

FD_FN_PURE static inline int
is_compute_budget_instruction( fd_exec_txn_ctx_t const * ctx,
fd_txn_instr_t const * instr ) {
fd_pubkey_t const * txn_accs = ctx->accounts;
fd_pubkey_t const * program_pubkey = &txn_accs[instr->program_id];
fd_txn_instr_t const * instr ) {
fd_pubkey_t const * txn_accs = ctx->accounts;
fd_pubkey_t const * program_pubkey = &txn_accs[ instr->program_id ];
return !memcmp(program_pubkey, fd_solana_compute_budget_program_id.key, sizeof(fd_pubkey_t));
}

/* https://github.com/anza-xyz/agave/blob/16de8b75ebcd57022409b422de557dd37b1de8db/compute-budget/src/compute_budget_processor.rs#L150-L153 */
FD_FN_PURE static inline int
sanitize_requested_heap_size( ulong bytes ) {
return !(bytes>FD_MAX_HEAP_FRAME_BYTES || bytes<FD_MIN_HEAP_FRAME_BYTES || bytes%FD_HEAP_FRAME_BYTES_GRANULARITY);
}

/* https://github.com/anza-xyz/agave/blob/16de8b75ebcd57022409b422de557dd37b1de8db/compute-budget/src/compute_budget_processor.rs#L69-L148 */
int fd_executor_compute_budget_program_execute_instructions( fd_exec_txn_ctx_t * ctx, fd_rawtxn_b_t const * txn_raw ) {
uint has_compute_units_limit_update = 0;
uint has_compute_units_price_update = 0;
uint has_requested_heap_size = 0;
uint has_loaded_accounts_data_size_limit_update = 0;
uint has_compute_units_limit_update = 0UL;
uint has_compute_units_price_update = 0UL;
uint has_requested_heap_size = 0UL;
uint has_loaded_accounts_data_size_limit_update = 0UL;

uint num_non_compute_budget_instrs = 0;
uint num_non_compute_budget_instrs = 0U;

uint updated_compute_unit_limit = 0;
ulong updated_compute_unit_price = 0;
uint updated_requested_heap_size = 0;
ulong request_heap_frame_instr_idx = 0;
uint updated_loaded_accounts_data_size_limit = 0;
uint updated_compute_unit_limit = 0U;
uint updated_requested_heap_size = 0U;
uint updated_loaded_accounts_data_size_limit = 0U;
ulong updated_compute_unit_price = 0UL;

uint prioritization_fee_type = FD_COMPUTE_BUDGET_PRIORITIZATION_FEE_TYPE_COMPUTE_UNIT_PRICE;

for( ulong i = 0; i < ctx->txn_descriptor->instr_cnt; i++ ) {
fd_txn_instr_t const * instr = &ctx->txn_descriptor->instr[i];
for( ulong i=0UL; i<ctx->txn_descriptor->instr_cnt; i++ ) {
fd_txn_instr_t const * instr = &ctx->txn_descriptor->instr[i];

if( !is_compute_budget_instruction(ctx, instr) ) { /* FIXME: is a compute budget instr */
if( !is_compute_budget_instruction( ctx, instr ) ) {
num_non_compute_budget_instrs++;
continue;
}
/* Deserialize the ComputeBudgetInstruction enum */
uchar * data = (uchar *)txn_raw->raw + instr->data_off;
uchar * data = (uchar *)txn_raw->raw + instr->data_off;

fd_compute_budget_program_instruction_t instruction;
fd_bincode_decode_ctx_t decode_ctx = {
.data = data,
.dataend = &data[instr->data_sz],
.data = data,
.dataend = &data[ instr->data_sz ],
.valloc = ctx->valloc,
};

Expand All @@ -59,54 +66,48 @@ int fd_executor_compute_budget_program_execute_instructions( fd_exec_txn_ctx_t *
return FD_EXECUTOR_INSTR_ERR_INVALID_ACC_DATA;
}

switch (instruction.discriminant) {
switch( instruction.discriminant ) {
case fd_compute_budget_program_instruction_enum_request_heap_frame: {
if( has_requested_heap_size ) {
/* FIXME: RETURN TXN ERR DUPLICATE TXN! */
return 1;
if( FD_UNLIKELY( has_requested_heap_size ) ) {
return FD_RUNTIME_TXN_ERR_DUPLICATE_INSTRUCTION;
}

has_requested_heap_size = 1;
request_heap_frame_instr_idx = i;
has_requested_heap_size = 1U;
updated_requested_heap_size = instruction.inner.request_heap_frame;

if( FD_UNLIKELY( !sanitize_requested_heap_size( updated_requested_heap_size ) ) ) {
return FD_EXECUTOR_INSTR_ERR_INVALID_INSTR_DATA;
}
break;
}
case fd_compute_budget_program_instruction_enum_set_compute_unit_limit: {
if( has_compute_units_limit_update ) {
/* FIXME: RETURN TXN ERR DUPLICATE TXN! */
return 1;
if( FD_UNLIKELY( has_compute_units_limit_update ) ) {
return FD_RUNTIME_TXN_ERR_DUPLICATE_INSTRUCTION;
}

has_compute_units_limit_update = 1;
updated_compute_unit_limit = instruction.inner.set_compute_unit_limit;
has_compute_units_limit_update = 1U;
updated_compute_unit_limit = instruction.inner.set_compute_unit_limit;

break;
}
case fd_compute_budget_program_instruction_enum_set_compute_unit_price: {
if( has_compute_units_price_update ) {
/* FIXME: RETURN TXN ERR DUPLICATE TXN! */
return 1;
if( FD_UNLIKELY( has_compute_units_price_update ) ) {
return FD_RUNTIME_TXN_ERR_DUPLICATE_INSTRUCTION;
}

has_compute_units_price_update = 1;
prioritization_fee_type = FD_COMPUTE_BUDGET_PRIORITIZATION_FEE_TYPE_COMPUTE_UNIT_PRICE;
updated_compute_unit_price = instruction.inner.set_compute_unit_price;
has_compute_units_price_update = 1U;
prioritization_fee_type = FD_COMPUTE_BUDGET_PRIORITIZATION_FEE_TYPE_COMPUTE_UNIT_PRICE;
updated_compute_unit_price = instruction.inner.set_compute_unit_price;

break;
}
case fd_compute_budget_program_instruction_enum_set_loaded_accounts_data_size_limit: {
if ( !FD_FEATURE_ACTIVE( ctx->slot_ctx, add_set_tx_loaded_accounts_data_size_instruction ) ) {
return FD_EXECUTOR_INSTR_ERR_INVALID_INSTR_DATA;
if( FD_UNLIKELY( has_loaded_accounts_data_size_limit_update ) ) {
return FD_RUNTIME_TXN_ERR_DUPLICATE_INSTRUCTION;
}

if( has_loaded_accounts_data_size_limit_update ) {
/* FIXME: RETURN TXN ERR DUPLICATE TXN! */
return 1;
}

has_loaded_accounts_data_size_limit_update = 1;
updated_loaded_accounts_data_size_limit = instruction.inner.set_loaded_accounts_data_size_limit;
has_loaded_accounts_data_size_limit_update = 1U;
updated_loaded_accounts_data_size_limit = instruction.inner.set_loaded_accounts_data_size_limit;

break;
}
Expand All @@ -117,36 +118,29 @@ int fd_executor_compute_budget_program_execute_instructions( fd_exec_txn_ctx_t *
}

if( has_requested_heap_size ) {
if( updated_requested_heap_size > FD_MAX_HEAP_FRAME_BYTES
|| updated_requested_heap_size < FD_MIN_HEAP_FRAME_BYTES
|| updated_requested_heap_size % FD_HEAP_FRAME_BYTES_GRANULARITY != 0 ) {
/* FIXME: RETURN TXN ERR INVALID INSTR DATA! */
(void)request_heap_frame_instr_idx;
return 1;
}

ctx->heap_size = updated_requested_heap_size;
}

if( has_compute_units_limit_update ) {
ctx->compute_unit_limit = fd_ulong_min(FD_MAX_COMPUTE_UNIT_LIMIT, updated_compute_unit_limit);
ctx->compute_unit_limit = fd_ulong_min( FD_MAX_COMPUTE_UNIT_LIMIT, updated_compute_unit_limit );
} else {
ctx->compute_unit_limit = fd_ulong_min(FD_MAX_COMPUTE_UNIT_LIMIT, fd_ulong_sat_mul((ulong)num_non_compute_budget_instrs, (ulong)DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT));
ctx->compute_unit_limit = fd_ulong_min( FD_MAX_COMPUTE_UNIT_LIMIT,
(ulong)fd_uint_sat_mul( num_non_compute_budget_instrs, DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT ) );
}

if( has_compute_units_price_update ) {
ctx->prioritization_fee_type = prioritization_fee_type;
ctx->compute_unit_price = updated_compute_unit_price;
ctx->compute_unit_price = updated_compute_unit_price;
}

if ( has_loaded_accounts_data_size_limit_update ) {
ulong data_sz_set = fd_ulong_min( FD_VM_LOADED_ACCOUNTS_DATA_SIZE_LIMIT, updated_loaded_accounts_data_size_limit );
ctx->loaded_accounts_data_size_limit = data_sz_set;
if( has_loaded_accounts_data_size_limit_update ) {
ctx->loaded_accounts_data_size_limit =
fd_ulong_min( FD_VM_LOADED_ACCOUNTS_DATA_SIZE_LIMIT, updated_loaded_accounts_data_size_limit );
}

ctx->compute_meter = ctx->compute_unit_limit;
ctx->compute_meter = ctx->compute_unit_limit;

return 0;
return FD_RUNTIME_EXECUTE_SUCCESS;
}


Expand Down

0 comments on commit 0fb6018

Please sign in to comment.