sweep_block_internal.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_vsource.h"
#include "sweep_block.h"

typedef enum : uint32_t {
  k_cbs_blob_bytes    = 8388608U,    
  k_cbs_cache_bytes   = 1048576U,    
  k_cbs_req_bytes     = 256U,        
  k_cbs_seq_passes    = 4U,          
  k_cbs_hot_reads     = 1048576U,    
  k_cbs_bucket_min    = 16U,         
  k_cbs_default_chunk = 65536U,      
  k_cbs_knee_pct      = 90U,         
  k_cbs_words_per_dot = 11U,         
  k_cbs_kib           = 1024U,       
  k_cbs_ns_per_us     = 1000U,       
  k_cbs_ns_per_s      = 1000000000U, 
  k_cbs_max_rows      = 24U,         
} cbs_dim_t;

typedef struct cbs_backend cbs_backend_t;
struct cbs_backend {
  const char* name; 
  int (*setup)(cbs_backend_t*      be,
               ra8_vsource_read_fn payload_read,
               void*               payload_ctx,
               uint32_t            blob_bytes,
               uint32_t            block_bytes,
               cb_sweep_config_t*  config);
  void (*teardown)(cbs_backend_t* be);
  ra8_vsource_read_fn read;          
  void*               read_ctx;      
  uint64_t            backing_bytes; 
  const uint64_t*     src_bytes;     
};

typedef struct {
  const char* backend;       
  const char* leg;           
  uint32_t    block_bytes;   
  uint32_t    frames;        
  uint64_t    reads;         
  uint64_t    hits;          
  uint64_t    misses;        
  uint64_t    evictions;     
  uint64_t    be_calls;      
  uint64_t    be_bytes;      
  uint64_t    src_bytes;     
  uint64_t    backing_bytes; 
  uint64_t    wall_ns;       
} cbs_row_t;

typedef struct {
  ra8_vsource_read_fn inner;     
  void*               inner_ctx; 
  uint64_t            calls;     
  uint64_t            bytes;     
} cbs_meter_t;

typedef struct {
  uint64_t rng;            
  uint32_t word_index;     
  uint32_t word_offset;    
  uint32_t sentence_words; 
  uint8_t  phase;          
} cbs_payload_state_t;

typedef struct {
  const void*         checkpoints;      
  uint32_t            checkpoint_count; 
  uint64_t            cursor_offset;    
  cbs_payload_state_t cursor_state;     
} cbs_payload_t;

RA8_PRIV size_t priv_payload_workspace_required(void);

RA8_PRIV int priv_payload_init(cbs_payload_t* payload, void* workspace, size_t capacity);

RA8_PRIV ra8_err_t priv_payload_read(void* ctx, uint64_t offset, uint8_t* buffer, uint32_t length);

RA8_PRIV uint64_t priv_now_ns(void);

RA8_PRIV ra8_err_t priv_meter_read(void* ctx, uint64_t offset, uint8_t* buf, uint32_t len);

RA8_PRIV cbs_backend_t* priv_backends(uint32_t* out_count);

RA8_PRIV int priv_print_row(cb_sink_t* sink, const cbs_row_t* r);

RA8_PRIV int priv_print_seq_table(cb_sink_t*       sink,
                                  const cbs_row_t* rows,
                                  uint32_t         nrows,
                                  const char*      be,
                                  const uint32_t*  blocks,
                                  uint32_t         nblocks);

RA8_PRIV int priv_print_hot_table(cb_sink_t*       sink,
                                  const cbs_row_t* rows,
                                  uint32_t         nrows,
                                  const char*      be,
                                  const uint32_t*  blocks,
                                  uint32_t         nblocks);

RA8_PRIV int priv_print_crossover(cb_sink_t*       sink,
                                  const cbs_row_t* rows,
                                  uint32_t         nrows,
                                  const uint32_t*  blocks,
                                  uint32_t         nblocks);