utils,spad: add spad handholding

jumpsiegel · jumpsiegel · commit 54b04bf1856e · 2025-08-12T11:50:51.000Z
diff --git a/src/discof/rpcserver/fd_methods.c b/src/discof/rpcserver/fd_methods.c
@@ -192,6 +192,9 @@ void json_add_value(struct json_values* values, struct json_path* path, const vo
       values->buf_alloc <<= 1;
     } while (new_buf_sz > values->buf_alloc);
     char* newbuf = (char*)fd_spad_alloc( spad, 1, values->buf_alloc);
+    if ( FD_UNLIKELY( NULL == newbuf ) ) {
+      FD_LOG_ERR(( "out of spad scratch space" ));
+    }
     fd_memcpy(newbuf, values->buf, values->buf_sz);
     values->buf = newbuf;
   }
diff --git a/src/discof/rpcserver/fd_rpc_history.c b/src/discof/rpcserver/fd_rpc_history.c
@@ -92,6 +92,9 @@ fd_rpc_history_t *
 fd_rpc_history_create(fd_rpcserver_args_t * args) {
   fd_spad_t * spad = args->spad;
   fd_rpc_history_t * hist = (fd_rpc_history_t *)fd_spad_alloc( spad, alignof(fd_rpc_history_t), sizeof(fd_rpc_history_t) );
+  if ( FD_UNLIKELY ( NULL == hist ) ) {
+    FD_LOG_ERR(( "out of spad scratch space" ));
+  }
   memset(hist, 0, sizeof(fd_rpc_history_t));
   hist->spad = spad;
 
diff --git a/src/discof/rpcserver/fd_rpc_service.c b/src/discof/rpcserver/fd_rpc_service.c
@@ -2294,6 +2294,9 @@ void
 fd_rpc_create_ctx(fd_rpcserver_args_t * args, fd_rpc_ctx_t ** ctx_p) {
   fd_rpc_ctx_t * ctx         = (fd_rpc_ctx_t *)fd_spad_alloc( args->spad, alignof(fd_rpc_ctx_t), sizeof(fd_rpc_ctx_t) );
   fd_rpc_global_ctx_t * gctx = (fd_rpc_global_ctx_t *)fd_spad_alloc( args->spad, alignof(fd_rpc_global_ctx_t), sizeof(fd_rpc_global_ctx_t) );
+  if ( FD_UNLIKELY ( (NULL == ctx) || (NULL == gctx) ) ) {
+    FD_LOG_ERR(( "fd_spad_alloc failed" ));
+  }
   fd_memset(ctx, 0, sizeof(fd_rpc_ctx_t));
   fd_memset(gctx, 0, sizeof(fd_rpc_global_ctx_t));
 
diff --git a/src/discof/rpcserver/json_lex.c b/src/discof/rpcserver/json_lex.c
@@ -387,6 +387,10 @@ static char* json_lex_append_prepare(json_lex_state_t* lex, ulong sz) {
     } while (new_sz + 1 > lex->last_str_alloc);
     char* oldstr = lex->last_str;
     lex->last_str = (char*)fd_spad_alloc( lex->spad, 1, lex->last_str_alloc);
+    if ( FD_UNLIKELY ( NULL == lex->last_str ) ) {
+      // TODO: what should we do?
+      return NULL;
+    }
     // Copy the old content to the new space
     fd_memcpy(lex->last_str, oldstr, lex->last_str_sz);
   }
diff --git a/src/flamenco/runtime/fd_executor.c b/src/flamenco/runtime/fd_executor.c
@@ -919,6 +919,9 @@ fd_executor_create_rollback_fee_payer_account( fd_exec_txn_ctx_t * txn_ctx,
 
     ulong  data_len       = fd_txn_account_get_data_len( &txn_ctx->accounts[FD_FEE_PAYER_TXN_IDX] );
     void * fee_payer_data = fd_spad_alloc( txn_ctx->spad, FD_ACCOUNT_REC_ALIGN, sizeof(fd_account_meta_t) + data_len );
+    if( FD_UNLIKELY( NULL == fee_payer_data ) ) {
+      FD_LOG_CRIT(( "out of spad scratch space" ));
+    }
     fd_memcpy( fee_payer_data, (uchar *)meta, sizeof(fd_account_meta_t) + data_len );
     if( FD_UNLIKELY( !fd_txn_account_join( fd_txn_account_new(
           txn_ctx->rollback_fee_payer_account,
@@ -1408,6 +1411,9 @@ fd_executor_setup_txn_account( fd_exec_txn_ctx_t * txn_ctx,
        initialize a new metadata. */
 
     uchar * new_raw_data = fd_spad_alloc( txn_ctx->spad, FD_ACCOUNT_REC_ALIGN, FD_ACC_TOT_SZ_MAX );
+    if( FD_UNLIKELY( NULL == new_raw_data ) ) {
+      FD_LOG_CRIT(( "out of spad scratch space" ));
+    }
     ulong   dlen         = !!meta ? meta->dlen : 0UL;
 
     if( FD_LIKELY( meta ) ) {
@@ -1432,6 +1438,9 @@ fd_executor_setup_txn_account( fd_exec_txn_ctx_t * txn_ctx,
       data_wksp    = fd_funk_wksp( txn_ctx->funk );
     } else {
       uchar * mem = fd_spad_alloc( txn_ctx->spad, FD_TXN_ACCOUNT_ALIGN, sizeof(fd_account_meta_t) );
+      if( FD_UNLIKELY( NULL == mem ) ) {
+        FD_LOG_CRIT(( "out of spad scratch space" ));
+      }
       account_meta = (fd_account_meta_t *)mem;
       data_wksp    = txn_ctx->spad_wksp;
       fd_account_meta_init( account_meta );
diff --git a/src/flamenco/runtime/fd_runtime.c b/src/flamenco/runtime/fd_runtime.c
@@ -2776,6 +2776,9 @@ fd_runtime_read_genesis( fd_exec_slot_ctx_t *   slot_ctx,
      longer spad-backed. */
 
   uchar * buf = fd_spad_alloc( runtime_spad, alignof(ulong), (ulong)sbuf.st_size );
+  if( FD_UNLIKELY( NULL == buf ) ) {
+    FD_LOG_ERR(( "fd_spad_alloc failed" ));
+  }
   ulong sz    = 0UL;
   int res     = fd_io_read( fd, buf, (ulong)sbuf.st_size, (ulong)sbuf.st_size, &sz );
   FD_TEST( res==0 );
diff --git a/src/flamenco/runtime/fd_txncache.c b/src/flamenco/runtime/fd_txncache.c
@@ -1064,6 +1064,9 @@ fd_txncache_get_entries( fd_txncache_t *         tc,
 
       status_pair->value.statuses_len = num_statuses;
       status_pair->value.statuses     = fd_spad_alloc( spad, FD_CACHE_STATUS_ALIGN, num_statuses * sizeof(fd_cache_status_t) );
+      if( FD_UNLIKELY( NULL == status_pair->value.statuses )) {
+        FD_LOG_CRIT(( "out of spad scratch space" ));
+      }
       fd_memset( status_pair->value.statuses, 0, num_statuses * sizeof(fd_cache_status_t) );
 
       /* Copy over every entry for the given slot into the slot deltas. */
diff --git a/src/flamenco/runtime/program/fd_system_program.c b/src/flamenco/runtime/program/fd_system_program.c
@@ -20,6 +20,9 @@
 static inline char *
 fd_log_address_type( fd_spad_t * spad, fd_pubkey_t const * pubkey, fd_pubkey_t const * base ) {
   char * out = fd_spad_alloc( spad, alignof(char), 125UL );
+  if ( FD_UNLIKELY ( NULL == out ) )  {
+    FD_LOG_ERR(( "out of spad scratch spaced during logging" ));
+  }
   char base_addr[52];
   if( FD_UNLIKELY( base ) ) {
     snprintf( base_addr, 52UL, "Some(%s)", FD_BASE58_ENC_32_ALLOCA( base ) );
diff --git a/src/flamenco/runtime/tests/fd_dump_pb.c b/src/flamenco/runtime/tests/fd_dump_pb.c
@@ -201,6 +201,9 @@ dump_vote_accounts( fd_exec_slot_ctx_t const *        slot_ctx,
   fd_exec_test_vote_account_t * vote_account_out = fd_spad_alloc( spad,
                                                                   alignof(fd_exec_test_vote_account_t),
                                                                   vote_account_t_cnt * sizeof(fd_exec_test_vote_account_t) );
+  if( FD_UNLIKELY( NULL == vote_account_out ) ) {
+    FD_LOG_CRIT(( "out of spad scratch space" ));
+  }
 
   for( fd_vote_accounts_pair_global_t_mapnode_t const * curr = fd_vote_accounts_pair_global_t_map_minimum_const(
           vote_accounts_pool,
@@ -270,6 +273,9 @@ dump_sanitized_transaction( fd_funk_t *                            funk,
   fd_acct_addr_t const * account_keys = fd_txn_get_acct_addrs( txn_descriptor, txn_payload );
   for( ulong i = 0; i < txn_descriptor->acct_addr_cnt; i++ ) {
     pb_bytes_array_t * account_key = fd_spad_alloc( spad, alignof(pb_bytes_array_t), PB_BYTES_ARRAY_T_ALLOCSIZE(sizeof(fd_pubkey_t)) );
+    if( FD_UNLIKELY( NULL == account_key ) ) {
+      FD_LOG_ERR(( "fd_spad_alloc failed" ));
+    }
     account_key->size = sizeof(fd_pubkey_t);
     memcpy( account_key->bytes, &account_keys[i], sizeof(fd_pubkey_t) );
     message->account_keys[i] = account_key;
@@ -278,6 +284,10 @@ dump_sanitized_transaction( fd_funk_t *                            funk,
   /* Transaction Context -> tx -> message -> recent_blockhash */
   uchar const * recent_blockhash = fd_txn_get_recent_blockhash( txn_descriptor, txn_payload );
   message->recent_blockhash = fd_spad_alloc( spad, alignof(pb_bytes_array_t), PB_BYTES_ARRAY_T_ALLOCSIZE(sizeof(fd_hash_t)) );
+  if( FD_UNLIKELY( NULL == message->recent_blockhash ) ) {
+    FD_LOG_ERR(( "spad_alloc_alloc failed" ));
+  }
+
   message->recent_blockhash->size = sizeof(fd_hash_t);
   memcpy( message->recent_blockhash->bytes, recent_blockhash, sizeof(fd_hash_t) );
 
@@ -354,6 +364,9 @@ dump_sanitized_transaction( fd_funk_t *                            funk,
   fd_ed25519_sig_t const * signatures = fd_txn_get_signatures( txn_descriptor, txn_payload );
   for( uchar i = 0; i < txn_descriptor->signature_cnt; ++i ) {
     pb_bytes_array_t * signature = fd_spad_alloc( spad, alignof(pb_bytes_array_t), PB_BYTES_ARRAY_T_ALLOCSIZE(sizeof(fd_ed25519_sig_t)) );
+    if( FD_UNLIKELY( NULL == signature ) ) {
+      FD_LOG_ERR(( "fd_spad_alloc failed" ));
+    }
     signature->size = sizeof(fd_ed25519_sig_t);
     memcpy( signature->bytes, &signatures[i], sizeof(fd_ed25519_sig_t) );
     sanitized_transaction->signatures[i] = signature;
@@ -375,6 +388,9 @@ dump_blockhash_queue( fd_blockhashes_t const * queue,
        iter=fd_blockhash_deq_iter_prev( queue->d.deque, iter ) ) {
     fd_blockhash_info_t const * ele = fd_blockhash_deq_iter_ele_const( queue->d.deque, iter );
     pb_bytes_array_t * output_blockhash = fd_spad_alloc( spad, alignof(pb_bytes_array_t), PB_BYTES_ARRAY_T_ALLOCSIZE(sizeof(fd_hash_t)) );
+    if( FD_UNLIKELY( NULL == output_blockhash ) ) {
+      FD_LOG_ERR(( "fd_spad_alloc failed" ));
+    }
     output_blockhash->size = sizeof(fd_hash_t);
     fd_memcpy( output_blockhash->bytes, &ele->hash, sizeof(fd_hash_t) );
     output_blockhash_queue[ cnt ] = output_blockhash;
@@ -577,6 +593,9 @@ create_block_context_protobuf_from_block_tx_only( fd_exec_test_block_context_t *
   /* BlockContext -> txns */
   block_context->txns_count = 0U;
   block_context->txns       = fd_spad_alloc( spad, alignof(fd_exec_test_sanitized_transaction_t), block_info->txn_cnt * sizeof(fd_exec_test_sanitized_transaction_t) );
+  if( FD_UNLIKELY( NULL == block_context->txns ) ) {
+    FD_LOG_ERR(( "fd_spad_alloc failed" ));
+  }
   fd_memset( block_context->txns, 0, block_info->txn_cnt * sizeof(fd_exec_test_sanitized_transaction_t) );
 
   /* BlockContext -> acct_states
@@ -1041,6 +1060,10 @@ fd_dump_block_to_protobuf_tx_only( fd_runtime_block_info_t const * block_info,
     /* Output to file */
     ulong out_buf_size = 5UL<<30UL; /* 5 GB */
     uint8_t * out = fd_spad_alloc( spad, alignof(uint8_t), out_buf_size );
+    if( FD_UNLIKELY( NULL == out ) ) {
+      FD_LOG_CRIT(( "out of spad scratch space" ));
+    }
+
     pb_ostream_t stream = pb_ostream_from_buffer( out, out_buf_size );
     if( pb_encode( &stream, FD_EXEC_TEST_BLOCK_CONTEXT_FIELDS, block_context_msg ) ) {
       char output_filepath[256]; fd_memset( output_filepath, 0, sizeof(output_filepath) );
@@ -1092,6 +1115,9 @@ FD_SPAD_FRAME_BEGIN( vm->instr_ctx->txn_ctx->spad ) {
 
   /* SyscallContext -> vm_ctx -> rodata */
   sys_ctx.vm_ctx.rodata = fd_spad_alloc( vm->instr_ctx->txn_ctx->spad, alignof(pb_bytes_array_t), PB_BYTES_ARRAY_T_ALLOCSIZE( vm->rodata_sz ) );
+  if( FD_UNLIKELY( NULL == sys_ctx.vm_ctx.rodata )) {
+    FD_LOG_ERR(( "fd_spad_alloc failed " ));
+  }
   sys_ctx.vm_ctx.rodata->size = (pb_size_t) vm->rodata_sz;
   fd_memcpy( sys_ctx.vm_ctx.rodata->bytes, vm->rodata, vm->rodata_sz );
 
@@ -1123,11 +1149,17 @@ FD_SPAD_FRAME_BEGIN( vm->instr_ctx->txn_ctx->spad ) {
 
   /* SyscallContext -> vm_ctx -> return_data -> data */
   sys_ctx.vm_ctx.return_data.data = fd_spad_alloc( vm->instr_ctx->txn_ctx->spad, alignof(pb_bytes_array_t), PB_BYTES_ARRAY_T_ALLOCSIZE( vm->instr_ctx->txn_ctx->return_data.len ) );
+  if( FD_UNLIKELY( NULL == sys_ctx.vm_ctx.return_data.data )) {
+    FD_LOG_ERR(( "fd_spad_alloc failed " ));
+  }
   sys_ctx.vm_ctx.return_data.data->size = (pb_size_t)vm->instr_ctx->txn_ctx->return_data.len;
   fd_memcpy( sys_ctx.vm_ctx.return_data.data->bytes, vm->instr_ctx->txn_ctx->return_data.data, vm->instr_ctx->txn_ctx->return_data.len );
 
   /* SyscallContext -> vm_ctx -> return_data -> program_id */
   sys_ctx.vm_ctx.return_data.program_id = fd_spad_alloc( vm->instr_ctx->txn_ctx->spad, alignof(pb_bytes_array_t), sizeof(fd_pubkey_t) );
+  if( FD_UNLIKELY( NULL == sys_ctx.vm_ctx.return_data.program_id )) {
+    FD_LOG_ERR(( "fd_spad_alloc failed " ));
+  }
   sys_ctx.vm_ctx.return_data.program_id->size = sizeof(fd_pubkey_t);
   fd_memcpy( sys_ctx.vm_ctx.return_data.program_id->bytes, vm->instr_ctx->txn_ctx->return_data.program_id.key, sizeof(fd_pubkey_t) );
 
@@ -1227,6 +1259,9 @@ FD_SPAD_FRAME_BEGIN( txn_ctx->spad ) {
   /* Output to file */
   ulong out_buf_size = 1UL<<29UL; /* 128 MB */
   uint8_t * out = fd_spad_alloc( txn_ctx->spad, alignof(uint8_t), out_buf_size );
+  if( FD_UNLIKELY( NULL == out ) ) {
+    FD_LOG_CRIT(( "out of spad scratch space" ));
+  }
   pb_ostream_t stream = pb_ostream_from_buffer( out, out_buf_size );
   if( pb_encode( &stream, FD_EXEC_TEST_ELF_LOADER_CTX_FIELDS, &elf_ctx ) ) {
     FILE * file = fopen(filename, "wb");
diff --git a/src/flamenco/runtime/tests/harness/fd_block_harness.c b/src/flamenco/runtime/tests/harness/fd_block_harness.c
@@ -83,6 +83,9 @@ fd_runtime_fuzz_block_register_vote_account( fd_exec_slot_ctx_t *
   node_to_insert->elem.value.data_len   = account_dlen;
 
   uchar * data = fd_spad_alloc( spad, alignof(uchar), account_dlen );
+  if( FD_UNLIKELY( NULL == data ) ) {
+    FD_LOG_ERR(( "fd_spad_alloc failed" ));
+  }
   memcpy( data, fd_txn_account_get_data( acc ), account_dlen );
   fd_solana_account_data_update( &node_to_insert->elem.value, data );
 
@@ -172,6 +175,9 @@ fd_runtime_fuzz_block_update_prev_epoch_votes_cache( fd_vote_accounts_pair_globa
     fd_memcpy( &vote_node->elem.value.owner, vote_account->owner, sizeof(fd_pubkey_t) );
 
     uchar * data = fd_spad_alloc( spad, alignof(uchar), vote_account->data->size );
+    if( FD_UNLIKELY( NULL == data ) ) {
+      FD_LOG_ERR(( "fd_spad_alloc failed" ));
+    }
     memcpy( data, vote_account->data->bytes, vote_account->data->size );
     fd_solana_account_data_update( &vote_node->elem.value, data );
 
@@ -428,6 +434,9 @@ fd_runtime_fuzz_block_ctx_create( fd_runtime_fuzz_runner_t *           runner,
   fd_runtime_block_info_t *    block_info       = fd_spad_alloc( runner->spad, alignof(fd_runtime_block_info_t), sizeof(fd_runtime_block_info_t) );
   fd_microblock_batch_info_t * batch_info       = fd_spad_alloc( runner->spad, alignof(fd_microblock_batch_info_t), sizeof(fd_microblock_batch_info_t) );
   fd_microblock_info_t *       microblock_info  = fd_spad_alloc( runner->spad, alignof(fd_microblock_info_t), sizeof(fd_microblock_info_t) );
+  if( FD_UNLIKELY( ( NULL == block_info) | ( NULL == batch_info) | ( NULL == microblock_info ) ) ) {
+    FD_LOG_ERR(( "fd_spad_alloc failed" ));
+  }
   fd_memset( block_info, 0, sizeof(fd_runtime_block_info_t) );
   fd_memset( batch_info, 0, sizeof(fd_microblock_batch_info_t) );
   fd_memset( microblock_info, 0, sizeof(fd_microblock_info_t) );
diff --git a/src/flamenco/runtime/tests/harness/fd_vm_harness.c b/src/flamenco/runtime/tests/harness/fd_vm_harness.c
@@ -130,6 +130,10 @@ do{
   }
   ulong   rodata_sz = input->vm_ctx.rodata->size;
   uchar * rodata = fd_spad_alloc_check( spad, 8UL, rodata_sz );
+  if( FD_UNLIKELY( NULL == rodata ) ) {
+    FD_LOG_ERR(( "fd_spad_alloc failed" ));
+  }
+
   memcpy( rodata, input->vm_ctx.rodata->bytes, rodata_sz );
 
   /* Setup input region */
@@ -348,6 +352,9 @@ do{
 
   effects->rodata       = FD_SCRATCH_ALLOC_APPEND(
     l, alignof(pb_bytes_array_t), PB_BYTES_ARRAY_T_ALLOCSIZE( rodata_sz ) );
+  if( FD_UNLIKELY( (NULL == rodata) | (NULL == effects->rodata ) ) ) {
+    FD_LOG_ERR(( "fd_spad_alloc failed" ));
+  }
   effects->rodata->size = (uint)rodata_sz;
   fd_memcpy( effects->rodata->bytes, rodata, rodata_sz );
 
@@ -426,6 +433,9 @@ fd_runtime_fuzz_vm_syscall_run( fd_runtime_fuzz_runner_t * runner,
 
   ulong rodata_sz = input->vm_ctx.rodata ? input->vm_ctx.rodata->size : 0UL;
   uchar * rodata = fd_spad_alloc_check( spad, 8UL, rodata_sz );
+  if( FD_UNLIKELY( NULL == rodata ) ) {
+    FD_LOG_ERR(( "spad_alloc_alloc failed" ));
+  }
   if ( input->vm_ctx.rodata != NULL ) {
     fd_memcpy( rodata, input->vm_ctx.rodata->bytes, rodata_sz );
   }
diff --git a/src/util/log/fd_log.h b/src/util/log/fd_log.h
@@ -266,6 +266,11 @@
 
 #define FD_TEST_CUSTOM(c,err) do { if( FD_UNLIKELY( !(c) ) ) FD_LOG_ERR(( "FAIL: %s", (err) )); } while(0)
 
+/* FD_TEST_BRK is like FD_TEST but drops into a debugger on failure. */
+
+#define FD_TEST_BRK(c) do { if( FD_UNLIKELY( !(c) ) ) FD_LOG_WARNING(( "FAIL: %s", #c )); __asm__("int $3"); } while(0)
+
+
 /* Macros for doing hexedit / tcpdump-like logging of memory regions.
    E.g.
 
diff --git a/src/util/spad/fd_spad.c b/src/util/spad/fd_spad.c
@@ -69,10 +69,17 @@ fd_spad_frame_hi_debug( fd_spad_t * spad ) {
   return SELECT_DEBUG_IMPL(fd_spad_frame_hi)( spad );
 }
 
-void
+fd_spad_debug_state_t
 fd_spad_push_debug( fd_spad_t * spad ) {
+  fd_spad_debug_state_t state;
+  state.frame_free = spad->frame_free;
+  state.mem_used = spad->mem_used;
+  state.spad = spad;
+
   if( FD_UNLIKELY( !fd_spad_frame_free( spad ) ) ) FD_LOG_CRIT(( "too many frames" ));
   SELECT_DEBUG_IMPL(fd_spad_push)( spad );
+
+  return state;
 }
 
 void
@@ -81,17 +88,6 @@ fd_spad_pop_debug( fd_spad_t * spad ) {
   SELECT_DEBUG_IMPL(fd_spad_pop)( spad );
 }
 
-void *
-fd_spad_alloc_check( fd_spad_t * spad,
-                     ulong       align,
-                     ulong       sz ) {
-  if( FD_UNLIKELY( !fd_spad_frame_used( spad )               ) ) FD_LOG_CRIT(( "not in a frame"  ));
-  if( FD_UNLIKELY( (!!align) & (!fd_ulong_is_pow2( align ) ) ) ) FD_LOG_CRIT(( "bad align"       ));
-  ulong alloc_max = fd_spad_alloc_max( spad, align );
-  if( FD_UNLIKELY( alloc_max<sz ) ) FD_LOG_CRIT(( "out of memory: attempted to allocate %lu bytes, but only %lu available", sz, alloc_max ));
-  return SELECT_DEBUG_IMPL(fd_spad_alloc)( spad, align, sz );
-}
-
 void
 fd_spad_trim_debug( fd_spad_t * spad,
                     void *      hi ) {
@@ -314,3 +310,17 @@ fd_spad_vtable = {
   .malloc = fd_spad_valloc_malloc,
   .free   = fd_spad_valloc_free
 };
+
+void
+fd_spad_private_frame_end_debug( fd_spad_debug_state_t * _spad_state ) {
+  fd_spad_pop( _spad_state->spad );
+
+  if(_spad_state->frame_free != _spad_state->spad->frame_free ) {
+    FD_LOG_WARNING(("%lu != %lu", _spad_state->frame_free, _spad_state->spad->frame_free));
+    FD_TEST_BRK( _spad_state->frame_free == _spad_state->spad->frame_free );
+  }
+  if( _spad_state->mem_used != _spad_state->spad->mem_used ) {
+    FD_LOG_WARNING(("%lu != %lu", _spad_state->mem_used, _spad_state->spad->mem_used));
+    FD_TEST_BRK( _spad_state->mem_used == _spad_state->spad->mem_used );
+  }
+}
diff --git a/src/util/spad/fd_spad.h b/src/util/spad/fd_spad.h
