int si_profiler(siprofiler *p)
{
uint64_t memory_used = 0;
ssrbnode *pn;
sinode *n;
pn = ss_rbmin(&p->i->i);
while (pn) {
n = sscast(pn, sinode, node);
p->total_node_count++;
p->count += n->i0.count;
p->count += n->i1.count;
memory_used += n->i0.used;
memory_used += n->i1.used;
p->count += n->index.h->keys;
p->count_dup += n->index.h->dupkeys;
int indexsize = sd_indexsize_ext(n->index.h);
p->total_node_size += indexsize + n->index.h->total;
p->total_node_origin_size += indexsize + n->index.h->totalorigin;
p->total_page_count += n->index.h->count;
pn = ss_rbnext(&p->i->i, pn);
}
p->memory_used = memory_used;
p->read_disk = p->i->read_disk;
p->read_cache = p->i->read_cache;
return 0;
}
static inline int
si_recovercomplete(sitrack *track, sr *r, si *index, ssbuf *buf)
{
/* prepare and build primary index */
ss_bufreset(buf);
ssrbnode *p = ss_rbmin(&track->i);
while (p) {
sinode *n = sscast(p, sinode, node);
int rc = ss_bufadd(buf, r->a, &n, sizeof(sinode*));
if (ssunlikely(rc == -1))
return sr_oom_malfunction(r->e);
p = ss_rbnext(&track->i, p);
}
ssiter i;
ss_iterinit(ss_bufiterref, &i);
ss_iteropen(ss_bufiterref, &i, buf, sizeof(sinode*));
while (ss_iterhas(ss_bufiterref, &i))
{
sinode *n = ss_iterof(ss_bufiterref, &i);
if (n->recover & SI_RDB_REMOVE) {
int rc = si_nodefree(n, r, 1);
if (ssunlikely(rc == -1))
return -1;
ss_iternext(ss_bufiterref, &i);
continue;
}
n->recover = SI_RDB;
si_insert(index, n);
si_plannerupdate(&index->p, SI_COMPACT|SI_BRANCH|SI_TEMP, n);
ss_iternext(ss_bufiterref, &i);
}
return 0;
}
int si_profiler(siprofiler *p)
{
uint32_t temperature_total = 0;
uint64_t memory_used = 0;
ssrbnode *pn;
sinode *n;
pn = ss_rbmin(&p->i->i);
while (pn) {
n = sscast(pn, sinode, node);
if (p->temperature_max < n->temperature)
p->temperature_max = n->temperature;
if (p->temperature_min > n->temperature)
p->temperature_min = n->temperature;
temperature_total += n->temperature;
p->total_node_count++;
p->count += n->i0.count;
p->count += n->i1.count;
p->total_branch_count += n->branch_count;
if (p->total_branch_max < n->branch_count)
p->total_branch_max = n->branch_count;
if (n->branch_count < 20)
p->histogram_branch[n->branch_count]++;
else
p->histogram_branch_20plus++;
memory_used += n->i0.used;
memory_used += n->i1.used;
sibranch *b = n->branch;
while (b) {
p->count += b->index.h->keys;
p->count_dup += b->index.h->dupkeys;
int indexsize = sd_indexsize_ext(b->index.h);
p->total_snapshot_size += indexsize;
p->total_node_size += indexsize + b->index.h->total;
p->total_node_origin_size += indexsize + b->index.h->totalorigin;
p->total_page_count += b->index.h->count;
if (b->index.h->extensions & SD_INDEXEXT_AMQF) {
p->total_amqf_size +=
sizeof(sdindexamqf) + sd_indexamqf(&b->index)->size;
}
b = b->next;
}
pn = ss_rbnext(&p->i->i, pn);
}
if (p->total_node_count > 0) {
p->total_branch_avg =
p->total_branch_count / p->total_node_count;
p->temperature_avg =
temperature_total / p->total_node_count;
}
p->memory_used = memory_used;
p->read_disk = p->i->read_disk;
p->read_cache = p->i->read_cache;
si_profiler_histogram_branch(p);
si_profiler_histogram_temperature(p);
return 0;
}
static inline void
si_recoversize(si *i)
{
ssrbnode *pn = ss_rbmin(&i->i);
while (pn) {
sinode *n = sscast(pn, sinode, node);
i->size += si_nodesize(n);
pn = ss_rbnext(&i->i, pn);
}
}
uint64_t sx_min(sxmanager *m)
{
ss_spinlock(&m->lock);
uint64_t id = 0;
if (sx_count(m) > 0) {
ssrbnode *node = ss_rbmin(&m->i);
sx *min = sscast(node, sx, node);
id = min->id;
}
ss_spinunlock(&m->lock);
return id;
}
uint64_t sx_vlsn(sxmanager *m)
{
ss_spinlock(&m->lock);
uint64_t vlsn;
if (sx_count(m) > 0) {
ssrbnode *node = ss_rbmin(&m->i);
sx *min = sscast(node, sx, node);
vlsn = min->vlsn;
} else {
vlsn = sr_seq(m->r->seq, SR_LSN);
}
ss_spinunlock(&m->lock);
return vlsn;
}
ssrbnode *ss_rbnext(ssrb *t, ssrbnode *n)
{
if (ssunlikely(n == NULL))
return ss_rbmin(t);
if (n->r) {
n = n->r;
while (n->l)
n = n->l;
return n;
}
ssrbnode *p;
while ((p = n->p) && p->r == n)
n = p;
return p;
}
static inline uint64_t
sx_csn(sxmanager *m)
{
uint64_t csn = UINT64_MAX;
if (m->count_rw == 0)
return csn;
ssrbnode *p = ss_rbmin(&m->i);
sx *min = NULL;
while (p) {
min = sscast(p, sx, node);
if (min->type == SXRO) {
p = ss_rbnext(&m->i, p);
continue;
}
break;
}
assert(min != NULL);
return min->csn;
}
