END_TEST
START_TEST(test_fpn)
{
test_reset();
ck_assert(test_metrics->f.fpn == 0.0);
INCR(test_metrics, f);
ck_assert(test_metrics->f.fpn == 0.0);
INCR_N(test_metrics, f, 2);
ck_assert(test_metrics->f.fpn == 0.0);
UPDATE_VAL(test_metrics, f, 2.1);
ck_assert(test_metrics->f.fpn == 2.1);
DECR(test_metrics, f);
ck_assert(test_metrics->f.fpn == 2.1);
DECR_N(test_metrics, f, 5);
ck_assert(test_metrics->f.fpn == 2.1);
}
END_TEST
START_TEST(test_gauge)
{
test_reset();
ck_assert_int_eq(test_metrics->g.gauge, 0);
INCR(test_metrics, g);
ck_assert_int_eq(test_metrics->g.gauge, 1);
INCR_N(test_metrics, g, 2);
ck_assert_int_eq(test_metrics->g.gauge, 3);
UPDATE_VAL(test_metrics, g, 2);
ck_assert_int_eq(test_metrics->g.gauge, 2);
DECR(test_metrics, g);
ck_assert_int_eq(test_metrics->g.gauge, 1);
DECR_N(test_metrics, g, 5);
ck_assert_int_eq(test_metrics->g.gauge, -4);
}
int hash_add_or_set(struct hash_table_t *ht,
const char *key, unsigned int klen,
void *val, unsigned int vlen,
hash_ops op)
{
struct hash_bucket_t *p, **hlist_head;
unsigned long h;
unsigned int idx;
h = ht->hash_func(key, klen);
idx = h & ht->hash_mask;
p = ht->buckets[idx];
for (; p; p = p->next) {
if (p->hkey.klen == klen && !memcmp(p->hkey.key, key, klen)) {//Match
if (op == HASH_ADD) {
return 0;
}
UPDATE_VAL(ht, p, val, vlen);
return 1;
}
}
p = lkmalloc(sizeof(struct hash_bucket_t));
if (!p)
return 0;
hlist_head = &ht->buckets[idx];
INIT_KV(p, key, klen, val, vlen);
INSERT_INTO_HLIST(p, hlist_head);
INSERT_INTO_TLIST(p, ht);
ht->elements_count++;
if (ht->elements_count > ht->table_size)
hash_table_resize(ht);
return 1;
}
/*
* Initialize all slabclasses.
*
* Every slabclass is a collection of slabs of fixed size specified by
* --slab-size. A single slab is a collection of contiguous, equal sized
* item chunks of a given size specified by the profile array
*/
static rstatus_i
_slab_slabclass_setup(void)
{
uint8_t id; /* slabclass id */
ASSERT(profile_last_id <= SLABCLASS_MAX_ID);
for (id = SLABCLASS_MIN_ID; id <= profile_last_id; id++) {
struct slabclass *p; /* slabclass */
uint32_t nitem; /* # item per slabclass */
size_t item_sz; /* item size */
nitem = slab_capacity() / profile[id];
if (nitem == 0) {
log_error("Invalid slab class size %u; too large to fit in slab!",
profile[id]);
return CC_ERROR;
}
item_sz = profile[id];
p = &slabclass[id];
p->nitem = nitem;
p->size = item_sz;
/* chunk_size is static */
perslab[id] = (perslab_metrics_st){PERSLAB_METRIC(METRIC_INIT)};
UPDATE_VAL(&perslab[id], chunk_size, item_sz);
p->nfree_itemq = 0;
SLIST_INIT(&p->free_itemq);
p->nfree_item = 0;
p->next_item_in_slab = NULL;
}
return CC_OK;
}
static void
request_pool_create(uint32_t max)
{
struct request *req;
if (reqp_init) {
log_warn("request pool has already been created, re-creating");
request_pool_destroy();
}
log_info("creating request pool: max %"PRIu32, max);
FREEPOOL_CREATE(&reqp, max);
reqp_init = true;
FREEPOOL_PREALLOC(req, &reqp, max, next, request_create);
if (reqp.nfree < max) {
log_crit("cannot preallocate request pool, OOM. abort");
exit(EXIT_FAILURE);
}
UPDATE_VAL(request_metrics, request_free, max);
}
void
procinfo_update(void)
{
struct rusage usage;
UPDATE_VAL(procinfo_metrics, pid, getpid());
UPDATE_VAL(procinfo_metrics, time, time_unix_sec());
UPDATE_VAL(procinfo_metrics, uptime, time_proc_sec());
/* "%02d%02d%02d" % (major, minor, patch) */
UPDATE_VAL(procinfo_metrics, version, VERSION_MAJOR * 10000 +
VERSION_MINOR * 100 + VERSION_PATCH);
/* not checking return as both parameters should be valid */
getrusage(RUSAGE_SELF, &usage);
UPDATE_VAL(procinfo_metrics, ru_utime, usage.ru_utime.tv_sec +
usage.ru_utime.tv_usec * USEC);
UPDATE_VAL(procinfo_metrics, ru_stime, usage.ru_stime.tv_sec +
usage.ru_stime.tv_usec * USEC);
UPDATE_VAL(procinfo_metrics, ru_maxrss, usage.ru_maxrss );
UPDATE_VAL(procinfo_metrics, ru_ixrss, usage.ru_ixrss );
UPDATE_VAL(procinfo_metrics, ru_idrss, usage.ru_idrss );
UPDATE_VAL(procinfo_metrics, ru_isrss, usage.ru_isrss );
UPDATE_VAL(procinfo_metrics, ru_minflt, usage.ru_minflt );
UPDATE_VAL(procinfo_metrics, ru_majflt, usage.ru_majflt );
UPDATE_VAL(procinfo_metrics, ru_nswap, usage.ru_nswap );
UPDATE_VAL(procinfo_metrics, ru_inblock, usage.ru_inblock );
UPDATE_VAL(procinfo_metrics, ru_oublock, usage.ru_oublock );
UPDATE_VAL(procinfo_metrics, ru_msgsnd, usage.ru_msgsnd );
UPDATE_VAL(procinfo_metrics, ru_msgrcv, usage.ru_msgrcv );
UPDATE_VAL(procinfo_metrics, ru_nsignals, usage.ru_nsignals);
UPDATE_VAL(procinfo_metrics, ru_nvcsw, usage.ru_nvcsw );
UPDATE_VAL(procinfo_metrics, ru_nivcsw, usage.ru_nivcsw );
}
