funk: optimize rec memory layout

riptl · ripatel-fd · commit e467a082b61f · 2025-10-06T17:07:37.000Z
Reduces fd_funk_rec_t footprint from 128 bytes to 96 bytes
diff --git a/src/funk/fd_funk_rec.c b/src/funk/fd_funk_rec.c
@@ -20,9 +20,7 @@
 #define MAP_KEY_HASH(k0,seed) fd_funk_xid_key_pair_hash((k0),(seed))
 #define MAP_IDX_T             uint
 #define MAP_NEXT              map_next
-#define MAP_MEMO              map_hash
 #define MAP_MAGIC             (0xf173da2ce77ecdb0UL) /* Firedancer rec db version 0 */
-#define MAP_MEMOIZE           1
 #define MAP_IMPL_STYLE        2
 #include "../util/tmpl/fd_map_chain_para.c"
 
@@ -176,7 +174,7 @@ fd_funk_rec_query_try_global( fd_funk_t const *         funk,
        !fd_funk_rec_map_iter_done( iter );
        iter = fd_funk_rec_map_iter_next( iter ) ) {
     fd_funk_rec_t const * ele = fd_funk_rec_map_iter_ele_const( iter );
-    if( FD_LIKELY( hash == ele->map_hash ) && FD_LIKELY( fd_funk_rec_key_eq( key, ele->pair.key ) ) ) {
+    if( FD_LIKELY( fd_funk_rec_key_eq( key, ele->pair.key ) ) ) {
 
       /* For cur_txn in path from [txn] to [root] where root is NULL */
 
@@ -293,10 +291,8 @@ fd_funk_rec_prepare( fd_funk_t *               funk,
   fd_funk_val_init( rec );
   if( txn == NULL ) {
     fd_funk_txn_xid_set_root( rec->pair.xid );
-    rec->txn_cidx = fd_funk_txn_cidx( FD_FUNK_TXN_IDX_NULL );
   } else {
     fd_funk_txn_xid_copy( rec->pair.xid, &txn->xid );
-    rec->txn_cidx = fd_funk_txn_cidx( (ulong)( txn - funk->txn_pool->ele ) );
     prepare->rec_head_idx = &txn->rec_head_idx;
     prepare->rec_tail_idx = &txn->rec_tail_idx;
   }
@@ -485,7 +481,7 @@ fd_funk_rec_remove( fd_funk_t *               funk,
   if( rec_out ) *rec_out = rec;
 
   /* Access the flags atomically */
-  ulong old_flags;
+  uint old_flags;
   for(;;) {
     old_flags = rec->flags;
     if( FD_UNLIKELY( old_flags & FD_FUNK_REC_FLAG_ERASE ) ) {
@@ -547,8 +543,6 @@ int
 fd_funk_rec_verify( fd_funk_t * funk ) {
   fd_funk_rec_map_t *  rec_map  = funk->rec_map;
   fd_funk_rec_pool_t * rec_pool = funk->rec_pool;
-  fd_funk_txn_pool_t * txn_pool = funk->txn_pool;
-  ulong txn_max = fd_funk_txn_pool_ele_max( txn_pool );
   ulong rec_max = fd_funk_rec_pool_ele_max( rec_pool );
 
 # define TEST(c) do {                                                                           \
@@ -570,10 +564,9 @@ fd_funk_rec_verify( fd_funk_t * funk ) {
       /* Make sure every record either links up with the last published
          transaction or an in-prep transaction and the flags are sane. */
 
-      fd_funk_txn_xid_t const * xid     = fd_funk_rec_xid( rec );
-      ulong                     txn_idx = fd_funk_txn_idx( rec->txn_cidx );
+      fd_funk_txn_xid_t const * xid = fd_funk_rec_xid( rec );
 
-      if( fd_funk_txn_idx_is_null( txn_idx ) ) { /* This is a record from the last published transaction */
+      if( fd_funk_txn_xid_eq_root( xid ) ) { /* This is a record from the last published transaction */
 
         TEST( fd_funk_txn_xid_eq_root( xid ) );
         /* No record linked list at the root txn */
@@ -582,10 +575,7 @@ fd_funk_rec_verify( fd_funk_t * funk ) {
 
       } else { /* This is a record from an in-prep transaction */
 
-        TEST( txn_idx<txn_max );
-        fd_funk_txn_t const * txn = fd_funk_txn_query( xid, funk->txn_map );
-        TEST( txn );
-        TEST( txn==(funk->txn_pool->ele+txn_idx) );
+        TEST( fd_funk_txn_query( xid, funk->txn_map ) );
 
       }
     }
@@ -609,10 +599,9 @@ fd_funk_rec_verify( fd_funk_t * funk ) {
     for( fd_funk_txn_all_iter_new( funk, txn_iter ); !fd_funk_txn_all_iter_done( txn_iter ); fd_funk_txn_all_iter_next( txn_iter ) ) {
       fd_funk_txn_t const * txn = fd_funk_txn_all_iter_ele_const( txn_iter );
 
-      ulong txn_idx = (ulong)(txn-txn_pool->ele);
-      uint  rec_idx = txn->rec_head_idx;
+      uint rec_idx = txn->rec_head_idx;
       while( !fd_funk_rec_idx_is_null( rec_idx ) ) {
-        TEST( (rec_idx<rec_max) && (fd_funk_txn_idx( rec_pool->ele[ rec_idx ].txn_cidx )==txn_idx) && rec_pool->ele[ rec_idx ].tag==0U );
+        TEST( (rec_idx<rec_max) && rec_pool->ele[ rec_idx ].tag==0U );
         rec_pool->ele[ rec_idx ].tag = 1U;
         fd_funk_rec_query_t query[1];
         fd_funk_rec_t const * rec2 = fd_funk_rec_query_try_global( funk, &txn->xid, rec_pool->ele[ rec_idx ].pair.key, NULL, query );
@@ -632,10 +621,9 @@ fd_funk_rec_verify( fd_funk_t * funk ) {
     for( fd_funk_txn_all_iter_new( funk, txn_iter ); !fd_funk_txn_all_iter_done( txn_iter ); fd_funk_txn_all_iter_next( txn_iter ) ) {
       fd_funk_txn_t const * txn = fd_funk_txn_all_iter_ele_const( txn_iter );
 
-      ulong txn_idx = (ulong)(txn-txn_pool->ele);
-      uint  rec_idx = txn->rec_tail_idx;
+      uint rec_idx = txn->rec_tail_idx;
       while( !fd_funk_rec_idx_is_null( rec_idx ) ) {
-        TEST( (rec_idx<rec_max) && (fd_funk_txn_idx( rec_pool->ele[ rec_idx ].txn_cidx )==txn_idx) && rec_pool->ele[ rec_idx ].tag==1U );
+        TEST( (rec_idx<rec_max) && rec_pool->ele[ rec_idx ].tag==1U );
         rec_pool->ele[ rec_idx ].tag = 2U;
         uint prev_idx = rec_pool->ele[ rec_idx ].prev_idx;
         if( !fd_funk_rec_idx_is_null( prev_idx ) ) TEST( rec_pool->ele[ prev_idx ].next_idx==rec_idx );
diff --git a/src/funk/fd_funk_rec.h b/src/funk/fd_funk_rec.h
@@ -1,19 +1,7 @@
 #ifndef HEADER_fd_src_funk_fd_funk_rec_h
 #define HEADER_fd_src_funk_fd_funk_rec_h
 
-/* This provides APIs for managing funk records.  It is generally not
-   meant to be included directly.  Use fd_funk.h instead.
-
-   The following APIs are thread safe and can be interleaved arbirarily
-   across threads:
-     fd_funk_rec_query_try
-     fd_funk_rec_query_test
-     fd_funk_rec_query_try_global
-     fd_funk_rec_prepare
-     fd_funk_rec_publish
-     fd_funk_rec_cancel
-     fd_funk_rec_remove
-*/
+/* fd_funk_rec.h provides APIs for managing funk records */
 
 #include "fd_funk_txn.h" /* Includes fd_funk_base.h */
 
@@ -22,7 +10,7 @@
    multiple of align.  These are provided to facilitate compile time
    declarations. */
 
-#define FD_FUNK_REC_ALIGN     (64UL)
+#define FD_FUNK_REC_ALIGN     (32UL)
 
 /* FD_FUNK_REC_FLAG_* are flags that can be bit-ored together to specify
    how records are to be interpreted.  The 5 most significant bytes of a
@@ -48,17 +36,15 @@ struct __attribute__((aligned(FD_FUNK_REC_ALIGN))) fd_funk_rec {
 
   fd_funk_xid_key_pair_t pair;     /* Transaction id and record key pair */
   uint                   map_next; /* Internal use by map */
-  ulong                  map_hash; /* Internal use by map */
 
   /* These fields are managed by funk.  TODO: Consider using record
      index compression here (much more debatable than in txn itself). */
 
   uint  prev_idx;  /* Record map index of previous record in its transaction */
   uint  next_idx;  /* Record map index of next record in its transaction */
 
-  uint  txn_cidx;  /* Compressed transaction map index (or compressed FD_FUNK_TXN_IDX if this is in the last published) */
   uint  tag;       /* Internal use only */
-  ulong flags;     /* Flags that indicate how to interpret a record */
+  uint  flags;     /* Flags that indicate how to interpret a record */
 
   /* Note: use of uint here requires FD_FUNK_REC_VAL_MAX to be at most
      UINT_MAX. */
@@ -70,12 +56,11 @@ struct __attribute__((aligned(FD_FUNK_REC_ALIGN))) fd_funk_rec {
                       has tag wksp_tag) and the owner of the region will be the record. The allocator is
                       fd_funk_alloc(). IMPORTANT! HAS NO GUARANTEED ALIGNMENT! */
 
-  /* Padding to FD_FUNK_REC_ALIGN here */
 };
 
 typedef struct fd_funk_rec fd_funk_rec_t;
 
-FD_STATIC_ASSERT( sizeof(fd_funk_rec_t) == 2U*FD_FUNK_REC_ALIGN, record size is wrong );
+FD_STATIC_ASSERT( sizeof(fd_funk_rec_t) == 3U*FD_FUNK_REC_ALIGN, record size is wrong );
 
 /* fd_funk_rec_map allows for indexing records by their (xid,key) pair.
    It is used to store all records of the last published transaction and
@@ -100,13 +85,9 @@ FD_STATIC_ASSERT( sizeof(fd_funk_rec_t) == 2U*FD_FUNK_REC_ALIGN, record size is
 #define MAP_KEY_HASH(k0,seed) fd_funk_xid_key_pair_hash((k0),(seed))
 #define MAP_IDX_T             uint
 #define MAP_NEXT              map_next
-#define MAP_MEMO              map_hash
 #define MAP_MAGIC             (0xf173da2ce77ecdb0UL) /* Firedancer rec db version 0 */
-#define MAP_MEMOIZE           1
 #define MAP_IMPL_STYLE        1
 #include "../util/tmpl/fd_map_chain_para.c"
-#undef  MAP_MEMOIZE
-#undef  MAP_HASH
 
 typedef fd_funk_rec_map_query_t fd_funk_rec_query_t;
 
diff --git a/src/funk/fd_funk_txn.c b/src/funk/fd_funk_txn.c
@@ -175,12 +175,11 @@ fd_funk_txn_cancel_childless( fd_funk_t * funk,
   while( !fd_funk_rec_idx_is_null( rec_idx ) ) {
 
     if( FD_UNLIKELY( rec_idx>=rec_max ) ) FD_LOG_CRIT(( "memory corruption detected (bad idx)" ));
-    if( FD_UNLIKELY( fd_funk_txn_idx( rec_pool->ele[ rec_idx ].txn_cidx )!=txn_idx ) )
+    if( FD_UNLIKELY( !fd_funk_txn_xid_eq( rec_pool->ele[ rec_idx ].pair.xid, &txn->xid ) ) )
       FD_LOG_CRIT(( "memory corruption detected (cycle or bad idx)" ));
 
     fd_funk_rec_t * rec = &rec_pool->ele[ rec_idx ];
     uint next_idx = rec->next_idx;
-    rec->txn_cidx = fd_funk_txn_cidx( FD_FUNK_TXN_IDX_NULL );
 
     for(;;) {
       fd_funk_rec_map_query_t rec_query[1];
@@ -444,11 +443,10 @@ fd_funk_txn_remove_published( fd_funk_t * funk ) {
       if( FD_UNLIKELY( err!=FD_MAP_SUCCESS ) ) FD_LOG_CRIT(( "fd_funk_rec_map_remove failed (%i-%s)", err, fd_map_strerror( err ) ));
 
       /* Sanity check: Record belongs to last published XID */
-      if( FD_UNLIKELY( !fd_funk_txn_idx_is_null( fd_funk_txn_idx( rec->txn_cidx ) ) ) ) {
+      if( FD_UNLIKELY( !fd_funk_txn_xid_eq_root( rec->pair.xid ) ) ) {
         FD_LOG_ERR(( "Failed to remove published txns: concurrent in-prep record detected" ));
       }
 
-
       /* Free rec resources */
       fd_funk_val_flush( rec, alloc, wksp );
       fd_funk_rec_pool_release( rec_pool, rec, 1 );
@@ -502,7 +500,6 @@ static void
 fd_funk_txn_update( fd_funk_t *               funk,
                     uint *                    _dst_rec_head_idx, /* Pointer to the dst list head */
                     uint *                    _dst_rec_tail_idx, /* Pointer to the dst list tail */
-                    ulong                     dst_txn_idx,       /* Transaction index of the merge destination */
                     fd_funk_txn_xid_t const * dst_xid,           /* dst xid */
                     ulong                     txn_idx ) {        /* Transaction index of the records to merge */
   fd_wksp_t *          wksp     = funk->wksp;
@@ -544,7 +541,6 @@ fd_funk_txn_update( fd_funk_t *               funk,
       }
       /* Clean up value */
       fd_funk_val_flush( rec2, alloc, wksp );
-      rec2->txn_cidx = fd_funk_txn_cidx( FD_FUNK_TXN_IDX_NULL );
       fd_funk_rec_pool_release( rec_pool, rec2, 1 );
       break;
     }
@@ -557,7 +553,6 @@ fd_funk_txn_update( fd_funk_t *               funk,
        property. */
 
     rec->pair.xid[0] = *dst_xid;
-    rec->txn_cidx = fd_funk_txn_cidx( dst_txn_idx );
 
     rec->prev_idx = FD_FUNK_REC_IDX_NULL;
     if( _dst_rec_head_idx ) {
@@ -591,7 +586,7 @@ fd_funk_txn_publish_funk_child( fd_funk_t * const funk,
 
   /* Apply the updates in txn to the last published transactions */
 
-  fd_funk_txn_update( funk, NULL, NULL, FD_FUNK_TXN_IDX_NULL, fd_funk_root( funk ), txn_idx );
+  fd_funk_txn_update( funk, NULL, NULL, fd_funk_root( funk ), txn_idx );
 
   /* Cancel all competing transaction histories */
 
@@ -722,13 +717,13 @@ fd_funk_txn_publish_into_parent( fd_funk_t *               funk,
   ulong parent_idx = fd_funk_txn_idx( txn->parent_cidx );
   if( fd_funk_txn_idx_is_null( parent_idx ) ) {
     /* Publish to root */
-    fd_funk_txn_update( funk, NULL, NULL, FD_FUNK_TXN_IDX_NULL, fd_funk_root( funk ), txn_idx );
+    fd_funk_txn_update( funk, NULL, NULL, fd_funk_root( funk ), txn_idx );
     /* Inherit the children */
     funk->shmem->child_head_cidx = txn->child_head_cidx;
     funk->shmem->child_tail_cidx = txn->child_tail_cidx;
   } else {
     fd_funk_txn_t * parent_txn = &txn_pool->ele[ parent_idx ];
-    fd_funk_txn_update( funk, &parent_txn->rec_head_idx, &parent_txn->rec_tail_idx, parent_idx, &parent_txn->xid, txn_idx );
+    fd_funk_txn_update( funk, &parent_txn->rec_head_idx, &parent_txn->rec_tail_idx, &parent_txn->xid, txn_idx );
     /* Inherit the children */
     parent_txn->child_head_cidx = txn->child_head_cidx;
     parent_txn->child_tail_cidx = txn->child_tail_cidx;
diff --git a/src/funk/test_funk_rec.c b/src/funk/test_funk_rec.c
@@ -2,7 +2,7 @@
 
 #if FD_HAS_HOSTED
 
-FD_STATIC_ASSERT( FD_FUNK_REC_ALIGN    == 64UL, unit_test );
+FD_STATIC_ASSERT( FD_FUNK_REC_ALIGN    == 32UL, unit_test );
 
 FD_STATIC_ASSERT( FD_FUNK_REC_FLAG_ERASE==1UL, unit_test );
 
