Skip to content

Commit c458bc8

Browse files
cali-jumptradingcali-jumptrading
committed
batch lthash
1 parent 3b1b286 commit c458bc8

File tree

2 files changed

+166
-30
lines changed

2 files changed

+166
-30
lines changed

‎src/ballet/lthash/fd_lthash_adder.h

Lines changed: 143 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,22 @@ struct __attribute__((aligned(FD_LTHASH_ADDER_ALIGN))) fd_lthash_adder {
2929

3030
uint batch_cnt;
3131

32+
struct {
33+
uchar pubkey[ 32UL ];
34+
uchar owner[ 32UL ];
35+
uchar executable;
36+
ulong data_len;
37+
int valid;
38+
} buffered_account;
39+
40+
struct {
41+
uchar * data;
42+
ulong data_sz;
43+
ulong data_max;
44+
} buffered_data;
45+
46+
fd_blake3_t blake[1];
47+
3248
#if FD_LTHASH_ADDER_PARA_MAX>1
3349

3450
uchar batch_data[ FD_LTHASH_ADDER_PARA_MAX*FD_BLAKE3_CHUNK_SZ ]
@@ -66,10 +82,9 @@ fd_lthash_adder_push( fd_lthash_adder_t * adder,
6682
ulong const batch_threshold = 512UL;
6783
fd_lthash_value_t value[1];
6884
if( FD_UNLIKELY( input_sz>batch_threshold ) ) {
69-
fd_blake3_t blake[1];
70-
fd_blake3_init( blake );
71-
fd_blake3_append( blake, input, input_sz );
72-
fd_blake3_fini_2048( blake, value->bytes );
85+
fd_blake3_init( adder->blake );
86+
fd_blake3_append( adder->blake, input, input_sz );
87+
fd_blake3_fini_2048( adder->blake, value->bytes );
7388
fd_lthash_add( sum, value );
7489
return;
7590
}
@@ -99,15 +114,134 @@ fd_lthash_adder_flush( fd_lthash_adder_t * adder,
99114
uint batch_cnt = adder->batch_cnt;
100115
for( uint i=0U; i<batch_cnt; i++ ) {
101116
fd_lthash_value_t value[1];
102-
fd_blake3_t blake[1];
103-
fd_blake3_init( blake );
104-
fd_blake3_append( blake, (void const *)adder->batch_ptrs[ i ], adder->batch_sz[ i ] );
105-
fd_blake3_fini_2048( blake, value->bytes );
117+
fd_blake3_init( adder->blake );
118+
fd_blake3_append( adder->blake, (void const *)adder->batch_ptrs[ i ], adder->batch_sz[ i ] );
119+
fd_blake3_fini_2048( adder->blake, value->bytes );
106120
fd_lthash_add( sum, value );
107121
}
108122
adder->batch_cnt = 0U;
109123
}
110124

125+
/* fd_lthash_adder_stream_account_hdr buffers account metadata into
126+
the lthash adder. */
127+
static inline void
128+
fd_lthash_adder_stream_account_hdr(
129+
fd_lthash_adder_t * adder,
130+
fd_lthash_value_t * sum,
131+
void const * pubkey,
132+
ulong data_sz,
133+
ulong lamports,
134+
uchar executable,
135+
void const * owner
136+
) {
137+
fd_lthash_value_t value[1];
138+
139+
ulong const static_sz = 0UL;
140+
ulong const batch_threshold = 0UL;
141+
142+
adder->buffered_data.data_sz = 0UL;
143+
adder->buffered_data.data_max = 0UL;
144+
145+
if( FD_UNLIKELY( data_sz > batch_threshold-static_sz || /* optimize for small appends */
146+
FD_BLAKE3_PARA_MAX==0 ) ) {
147+
adder->buffered_account.valid = 1;
148+
adder->buffered_account.executable = executable;
149+
adder->buffered_account.data_len = data_sz;
150+
memcpy( adder->buffered_account.pubkey, pubkey, 32UL );
151+
memcpy( adder->buffered_account.owner, owner, 32UL );
152+
adder->buffered_data.data_max = data_sz;
153+
154+
fd_blake3_init( adder->blake );
155+
fd_blake3_append( adder->blake, &lamports, sizeof(ulong) );
156+
157+
if( FD_UNLIKELY( data_sz==0UL ) ) {
158+
uchar footer[ 65 ];
159+
footer[ 0 ] = executable;
160+
memcpy( footer+1, owner, 32 );
161+
memcpy( footer+33, pubkey, 32 );
162+
fd_blake3_append( adder->blake, footer, sizeof(footer) );
163+
fd_blake3_fini_2048( adder->blake, value->bytes );
164+
fd_lthash_add( sum, value );
165+
}
166+
} else {
167+
uint batch_idx = adder->batch_cnt++;
168+
uchar * slot = (uchar *)adder->batch_ptrs[ batch_idx ];
169+
uchar * p = slot;
170+
171+
/* Fixed size header */
172+
FD_STORE( ulong, p, lamports );
173+
p += sizeof(ulong);
174+
/* Variable size content */
175+
adder->buffered_data.data = p;
176+
adder->buffered_data.data_max = data_sz;
177+
p += data_sz;
178+
/* Fixed size footer */
179+
p[0] = executable; p += 1;
180+
fd_memcpy( p, owner, 32 ); p += 32;
181+
fd_memcpy( p, pubkey, 32 ); p += 32;
182+
183+
adder->batch_sz[ batch_idx ] = (uint)( p-slot );
184+
185+
if( batch_idx+1>=FD_BLAKE3_PARA_MAX && data_sz==0UL ) {
186+
# if FD_HAS_AVX512
187+
fd_blake3_lthash_batch16( (void const **)fd_type_pun_const( adder->batch_ptrs ), adder->batch_sz, value->words );
188+
# elif FD_HAS_AVX
189+
fd_blake3_lthash_batch8 ( (void const **)fd_type_pun_const( adder->batch_ptrs ), adder->batch_sz, value->words );
190+
# endif
191+
adder->batch_cnt = 0;
192+
fd_lthash_add( sum, value );
193+
}
194+
}
195+
}
196+
197+
/* fd_lthash_adder_stream_account_data buffers account data
198+
into the lthash adder. */
199+
200+
static inline int
201+
fd_lthash_adder_stream_account_data(
202+
fd_lthash_adder_t * adder,
203+
fd_lthash_value_t * sum,
204+
uchar const * data,
205+
ulong data_sz
206+
) {
207+
fd_lthash_value_t value[1];
208+
fd_lthash_zero( value );
209+
/* FIXME opportunities for memcpy hax here */
210+
211+
if( FD_UNLIKELY( adder->buffered_account.valid ) ) {
212+
fd_blake3_append( adder->blake, data, data_sz );
213+
} else {
214+
fd_memcpy( adder->buffered_data.data+adder->buffered_data.data_sz, data, data_sz );
215+
}
216+
adder->buffered_data.data_sz += data_sz;
217+
218+
if( FD_LIKELY( adder->buffered_data.data_sz==adder->buffered_data.data_max ) ) {
219+
if( adder->buffered_account.valid ) {
220+
uchar footer[ 65 ];
221+
footer[ 0 ] = adder->buffered_account.executable;
222+
memcpy( footer+1, adder->buffered_account.owner, 32 );
223+
memcpy( footer+33, adder->buffered_account.pubkey, 32 );
224+
fd_blake3_append( adder->blake, footer, sizeof(footer) );
225+
fd_blake3_fini_2048( adder->blake, value->bytes );
226+
fd_lthash_add( sum, value );
227+
adder->buffered_account.valid = 0;
228+
return 1;
229+
} else {
230+
uint batch_idx = adder->batch_cnt;
231+
if( batch_idx+1>=FD_BLAKE3_PARA_MAX ) {
232+
# if FD_HAS_AVX512
233+
fd_blake3_lthash_batch16( (void const **)fd_type_pun_const( adder->batch_ptrs ), adder->batch_sz, value->words );
234+
# elif FD_HAS_AVX
235+
fd_blake3_lthash_batch8 ( (void const **)fd_type_pun_const( adder->batch_ptrs ), adder->batch_sz, value->words );
236+
# endif
237+
adder->batch_cnt = 0;
238+
fd_lthash_add( sum, value );
239+
}
240+
}
241+
}
242+
return 0;
243+
}
244+
111245
/* fd_lthash_adder_push_solana_account wraps fd_lthash_adder_push for
112246
Solana account inputs. */
113247

@@ -171,6 +305,7 @@ fd_lthash_adder_push_solana_account(
171305
}
172306
}
173307

308+
174309
FD_PROTOTYPES_END
175310

176311
#endif /* HEADER_fd_src_ballet_lthash_fd_lthash_adder_h */

‎src/discof/restore/fd_snaplt_tile.c

Lines changed: 23 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
#include "../../ballet/lthash/fd_lthash.h"
44
#include "../../flamenco/runtime/fd_hashes.h"
55
#include "../../flamenco/runtime/fd_acc_mgr.h"
6+
#include "../../ballet/lthash/fd_lthash_adder.h"
67

78
#include "utils/fd_ssctrl.h"
89

@@ -25,7 +26,8 @@
2526
struct fd_snaplt_tile {
2627
int state;
2728

28-
fd_lthash_value_t running_lthash;
29+
fd_lthash_value_t running_lthash;
30+
fd_lthash_adder_t * adder;
2931

3032
fd_snapshot_account_t account;
3133
ulong acc_data_sz;
@@ -80,6 +82,7 @@ scratch_footprint( fd_topo_tile_t const * tile ) {
8082
(void)tile;
8183
ulong l = FD_LAYOUT_INIT;
8284
l = FD_LAYOUT_APPEND( l, alignof(fd_snaplt_tile_t), sizeof(fd_snaplt_tile_t) );
85+
l = FD_LAYOUT_APPEND( l, FD_LTHASH_ADDER_ALIGN, sizeof(fd_lthash_adder_t) );
8386
return FD_LAYOUT_FINI( l, alignof(fd_snaplt_tile_t) );
8487
}
8588

@@ -130,17 +133,27 @@ during_frag( fd_snaplt_tile_t * ctx,
130133

131134
if( FD_LIKELY( account->lamports!=0UL ) ) {
132135
ctx->hash_account = 1;
133-
fd_blake3_init( ctx->b3 );
134-
fd_blake3_append( ctx->b3, &account->lamports, sizeof( ulong ) );
135-
fd_memcpy( &ctx->account, account, sizeof(fd_snapshot_account_t) );
136+
fd_lthash_adder_stream_account_hdr( ctx->adder,
137+
&ctx->running_lthash,
138+
account->pubkey,
139+
account->data_len,
140+
account->lamports,
141+
account->executable,
142+
account->owner );
136143
}
137144
break;
138145
}
139146
case FD_SNAPSHOT_HASH_MSG_ACCOUNT_DATA: {
140147
FD_TEST( ctx->state==FD_SNAPLT_STATE_HASHING );
141148
if( FD_LIKELY( ctx->hash_account ) ) {
142-
fd_blake3_append( ctx->b3, fd_chunk_to_laddr_const( ctx->in.wksp, chunk ), sz );
143-
ctx->acc_data_sz += sz;
149+
int hashed = fd_lthash_adder_stream_account_data( ctx->adder,
150+
&ctx->running_lthash,
151+
(uchar const *)fd_chunk_to_laddr_const( ctx->in.wksp, chunk ),
152+
sz );
153+
if( hashed ) {
154+
ctx->metrics.accounts_hashed++;
155+
ctx->hash_account = 0;
156+
}
144157
}
145158
break;
146159
}
@@ -174,26 +187,11 @@ after_frag( fd_snaplt_tile_t * ctx,
174187
case FD_SNAPSHOT_HASH_MSG_ACCOUNT_HDR:
175188
case FD_SNAPSHOT_HASH_MSG_ACCOUNT_DATA: {
176189
FD_TEST( ctx->state==FD_SNAPLT_STATE_HASHING );
177-
if( FD_LIKELY( ctx->acc_data_sz==ctx->account.data_len && ctx->hash_account ) ) {
178-
/* hash account here */
179-
fd_lthash_value_t account_lthash[1];
180-
fd_lthash_zero( account_lthash );
181-
182-
uchar executable_flag = ctx->account.executable & 0x1;
183-
fd_blake3_append( ctx->b3, &executable_flag, sizeof( uchar ) );
184-
fd_blake3_append( ctx->b3, ctx->account.owner, FD_HASH_FOOTPRINT );
185-
fd_blake3_append( ctx->b3, ctx->account.pubkey, FD_HASH_FOOTPRINT );
186-
fd_blake3_fini_2048( ctx->b3, account_lthash->bytes );
187-
188-
fd_lthash_add( &ctx->running_lthash, account_lthash );
189-
ctx->acc_data_sz = 0UL;
190-
ctx->hash_account = 0;
191-
ctx->metrics.accounts_hashed++;
192-
}
193190
break;
194191
}
195192
case FD_SNAPSHOT_HASH_MSG_FINI: {
196193
FD_TEST( ctx->state==FD_SNAPLT_STATE_HASHING );
194+
fd_lthash_adder_flush( ctx->adder, &ctx->running_lthash );
197195
uchar * lthash_out = fd_chunk_to_laddr( ctx->out.wksp, ctx->out.chunk );
198196
fd_memcpy( lthash_out, &ctx->running_lthash, sizeof(fd_lthash_value_t) );
199197
fd_stem_publish( stem, 0UL, FD_SNAPSHOT_HASH_MSG_RESULT, ctx->out.chunk, FD_LTHASH_LEN_BYTES, 0UL, 0UL, 0UL );
@@ -229,6 +227,9 @@ unprivileged_init( fd_topo_t * topo,
229227

230228
FD_SCRATCH_ALLOC_INIT( l, scratch );
231229
fd_snaplt_tile_t * ctx = FD_SCRATCH_ALLOC_APPEND( l, alignof(fd_snaplt_tile_t), sizeof(fd_snaplt_tile_t) );
230+
void * _adder = FD_SCRATCH_ALLOC_APPEND( l, FD_LTHASH_ADDER_ALIGN, sizeof(fd_lthash_adder_t) );
231+
232+
ctx->adder = fd_lthash_adder_new( _adder );
232233

233234
if( FD_UNLIKELY( tile->in_cnt!=1UL ) ) FD_LOG_ERR(( "tile `" NAME "` has %lu ins, expected 1", tile->in_cnt ));
234235
if( FD_UNLIKELY( tile->out_cnt!=1UL ) ) FD_LOG_ERR(( "tile `" NAME "` has %lu outs, expected 1", tile->out_cnt ));

0 commit comments

Comments
 (0)