void rtw_mstat_update(const enum mstat_f flags, const MSTAT_STATUS status, u32 sz)
{
static u32 update_time = 0;
int peak, alloc;
int i;
/* initialization */
if(!update_time) {
for(i=0;i<mstat_tf_idx(MSTAT_TYPE_MAX);i++) {
ATOMIC_SET(&(rtw_mem_type_stat[i].alloc), 0);
ATOMIC_SET(&(rtw_mem_type_stat[i].peak), 0);
ATOMIC_SET(&(rtw_mem_type_stat[i].alloc_cnt), 0);
ATOMIC_SET(&(rtw_mem_type_stat[i].alloc_err_cnt), 0);
}
for(i=0;i<mstat_ff_idx(MSTAT_FUNC_MAX);i++) {
ATOMIC_SET(&(rtw_mem_func_stat[i].alloc), 0);
ATOMIC_SET(&(rtw_mem_func_stat[i].peak), 0);
ATOMIC_SET(&(rtw_mem_func_stat[i].alloc_cnt), 0);
ATOMIC_SET(&(rtw_mem_func_stat[i].alloc_err_cnt), 0);
}
}
switch(status) {
case MSTAT_ALLOC_SUCCESS:
ATOMIC_INC(&(rtw_mem_type_stat[mstat_tf_idx(flags)].alloc_cnt));
alloc = ATOMIC_ADD_RETURN(&(rtw_mem_type_stat[mstat_tf_idx(flags)].alloc), sz);
peak=ATOMIC_READ(&(rtw_mem_type_stat[mstat_tf_idx(flags)].peak));
if (peak<alloc)
ATOMIC_SET(&(rtw_mem_type_stat[mstat_tf_idx(flags)].peak), alloc);
ATOMIC_INC(&(rtw_mem_func_stat[mstat_ff_idx(flags)].alloc_cnt));
alloc = ATOMIC_ADD_RETURN(&(rtw_mem_func_stat[mstat_ff_idx(flags)].alloc), sz);
peak=ATOMIC_READ(&(rtw_mem_func_stat[mstat_ff_idx(flags)].peak));
if (peak<alloc)
ATOMIC_SET(&(rtw_mem_func_stat[mstat_ff_idx(flags)].peak), alloc);
break;
case MSTAT_ALLOC_FAIL:
ATOMIC_INC(&(rtw_mem_type_stat[mstat_tf_idx(flags)].alloc_err_cnt));
ATOMIC_INC(&(rtw_mem_func_stat[mstat_ff_idx(flags)].alloc_err_cnt));
break;
case MSTAT_FREE:
ATOMIC_DEC(&(rtw_mem_type_stat[mstat_tf_idx(flags)].alloc_cnt));
ATOMIC_SUB(&(rtw_mem_type_stat[mstat_tf_idx(flags)].alloc), sz);
ATOMIC_DEC(&(rtw_mem_func_stat[mstat_ff_idx(flags)].alloc_cnt));
ATOMIC_SUB(&(rtw_mem_func_stat[mstat_ff_idx(flags)].alloc), sz);
break;
};
//if (rtw_get_passing_time_ms(update_time) > 5000) {
// rtw_mstat_dump();
update_time=rtw_get_current_time();
//}
}
void
slab_free(void *p, void *address)
{
struct bufentry *buf, *pbuf;
int found = 0;
uint32_t hindx;
if (!address) return;
if (bypass) { free(address); return; }
hindx = hash6432shift((uint64_t)(address)) & (HTABLE_SZ - 1);
pthread_mutex_lock(&hbucket_locks[hindx]);
buf = htable[hindx];
pbuf = NULL;
while (buf) {
if (buf->ptr == address) {
if (hash_entries <=0) {
fprintf(stderr, "Inconsistent allocation hash\n");
abort();
}
if (pbuf)
pbuf->next = buf->next;
else
htable[hindx] = buf->next;
pthread_mutex_unlock(&hbucket_locks[hindx]);
ATOMIC_SUB(hash_entries, 1);
if (buf->slab == NULL) {
free(buf->ptr);
free(buf);
found = 1;
break;
} else {
pthread_mutex_lock(&(buf->slab->slab_lock));
buf->next = buf->slab->avail;
buf->slab->avail = buf;
pthread_mutex_unlock(&(buf->slab->slab_lock));
found = 1;
break;
}
}
pbuf = buf;
buf = buf->next;
}
if (!found) {
pthread_mutex_unlock(&hbucket_locks[hindx]);
free(address);
fprintf(stderr, "Freed buf(%p) not in slab allocations!\n", address);
abort();
fflush(stderr);
}
}
static void /* assumes exclusive access to bucket */
dynstats_destroyCountersIn(dynstats_bucket_t *b, htable *table, dynstats_ctr_t *ctrs) {
dynstats_ctr_t *ctr;
int ctrs_purged = 0;
hashtable_destroy(table, 0);
while (ctrs != NULL) {
ctr = ctrs;
ctrs = ctrs->next;
dynstats_destroyCtr(ctr);
ctrs_purged++;
}
STATSCOUNTER_ADD(b->ctrMetricsPurged, b->mutCtrMetricsPurged, ctrs_purged);
ATOMIC_SUB(&b->metricCount, ctrs_purged, &b->mutMetricCount);
}
void easy_mempool_free(easy_mempool_t *pool, void *ptr)
{
if (NULL != pool
&& NULL != ptr) {
easy_mempool_buf_t *buf = (easy_mempool_buf_t *)((char *)ptr - sizeof(easy_mempool_buf_t));
if (EASY_MEMPOOL_BUF_MAGIC_NUM == buf->magic_num) {
int64_t size = buf->size;
buf->magic_num = EASY_MEMPOOL_BUF_FREE_FLAG;
if (EASY_MEMPOOL_DIRECT_ALLOC == buf->alloc_type) {
pool->allocator->free(buf);
ATOMIC_DEC(&(pool->direct_alloc_cnt));
} else {
easy_mempool_deref_page_(pool, buf->page_pos);
}
ATOMIC_SUB(&(pool->mem_total), size);
}
}
}
void *easy_mempool_thread_realloc(void *ptr, size_t size)
{
void *ret = NULL;
void *alloc_ptr = NULL;
easy_mempool_thread_info_t *thread_info = (easy_mempool_thread_info_t *)pthread_getspecific(easy_mempool_g_thread_key);
if (NULL == thread_info) {
thread_info = (easy_mempool_thread_info_t *)easy_mempool_g_allocator.memalign(EASY_MEMPOOL_ALIGNMENT,
sizeof(easy_mempool_thread_info_t));
if (NULL != thread_info) {
thread_info->ref_cnt = 1;
thread_info->pool = easy_mempool_create(0);
}
pthread_setspecific(easy_mempool_g_thread_key, thread_info);
}
if (0 != size
&& NULL != thread_info
&& easy_mempool_g_thread_memlimit >= (int64_t)(easy_mempool_g_thread_memtotal + size)) {
alloc_ptr = easy_mempool_alloc(thread_info->pool, size + sizeof(easy_mempool_thread_info_t *));
if (NULL != alloc_ptr) {
*(easy_mempool_thread_info_t **)(alloc_ptr) = thread_info;
ret = (char *)alloc_ptr + sizeof(easy_mempool_thread_info_t *);
ATOMIC_INC(&(thread_info->ref_cnt));
ATOMIC_ADD(&easy_mempool_g_thread_memtotal, size);
}
}
if (NULL != ptr && NULL != ret) {
easy_mempool_buf_t *buf = (easy_mempool_buf_t *)((char *)ptr -
sizeof(easy_mempool_thread_info_t *) - sizeof(easy_mempool_buf_t));
if (NULL == buf) {
easy_mempool_free(thread_info->pool, alloc_ptr);
} else {
memcpy(ret, ptr, buf->size > size ? size : buf->size);
}
}
if (NULL != ptr) {
ptr = (char *)ptr - sizeof(easy_mempool_thread_info_t *);
easy_mempool_buf_t *buf = (easy_mempool_buf_t *)((char *)ptr - sizeof(easy_mempool_buf_t));
easy_mempool_thread_info_t *host = *(easy_mempool_thread_info_t **)ptr;
if (NULL != buf) {
ATOMIC_SUB(&easy_mempool_g_thread_memtotal, buf->size - sizeof(easy_mempool_thread_info_t *));
}
if (NULL != host) {
easy_mempool_free(host->pool, ptr);
if (0 == ATOMIC_DEC_FETCH(&(host->ref_cnt))) {
easy_mempool_destroy(host->pool);
easy_mempool_g_allocator.free(host);
}
}
}
return ret;
}
/* dequeue should be called by kperf_*()
NB: these calls are already in place
*/
void message_dequeue(CSOUND *csound) {
if(csound->msg_queue != NULL) {
long rp = csound->msg_queue_rstart;
long items = csound->msg_queue_items;
long rend = rp + items;
while(rp < rend) {
message_queue_t* msg = csound->msg_queue[rp % API_MAX_QUEUE];
switch(msg->message) {
case INPUT_MESSAGE:
{
const char *str = msg->args;
csoundInputMessageInternal(csound, str);
}
break;
case READ_SCORE:
{
const char *str = msg->args;
csoundReadScoreInternal(csound, str);
}
break;
case SCORE_EVENT:
{
char type;
const MYFLT *pfields;
long numFields;
type = msg->args[0];
memcpy(&pfields, msg->args + ARG_ALIGN,
sizeof(MYFLT *));
memcpy(&numFields, msg->args + ARG_ALIGN*2,
sizeof(long));
csoundScoreEventInternal(csound, type, pfields, numFields);
}
break;
case SCORE_EVENT_ABS:
{
char type;
const MYFLT *pfields;
long numFields;
double ofs;
type = msg->args[0];
memcpy(&pfields, msg->args + ARG_ALIGN,
sizeof(MYFLT *));
memcpy(&numFields, msg->args + ARG_ALIGN*2,
sizeof(long));
memcpy(&ofs, msg->args + ARG_ALIGN*3,
sizeof(double));
csoundScoreEventAbsoluteInternal(csound, type, pfields, numFields,
ofs);
}
break;
case TABLE_COPY_OUT:
{
int table;
MYFLT *ptable;
memcpy(&table, msg->args, sizeof(int));
memcpy(&ptable, msg->args + ARG_ALIGN,
sizeof(MYFLT *));
csoundTableCopyOutInternal(csound, table, ptable);
}
break;
case TABLE_COPY_IN:
{
int table;
MYFLT *ptable;
memcpy(&table, msg->args, sizeof(int));
memcpy(&ptable, msg->args + ARG_ALIGN,
sizeof(MYFLT *));
csoundTableCopyInInternal(csound, table, ptable);
}
break;
case TABLE_SET:
{
int table, index;
MYFLT value;
memcpy(&table, msg->args, sizeof(int));
memcpy(&index, msg->args + ARG_ALIGN,
sizeof(int));
memcpy(&value, msg->args + 2*ARG_ALIGN,
sizeof(MYFLT));
csoundTableSetInternal(csound, table, index, value);
}
break;
case MERGE_STATE:
{
ENGINE_STATE *e;
TYPE_TABLE *t;
OPDS *ids;
memcpy(&e, msg->args, sizeof(ENGINE_STATE *));
memcpy(&t, msg->args + ARG_ALIGN,
sizeof(TYPE_TABLE *));
memcpy(&ids, msg->args + 2*ARG_ALIGN,
sizeof(OPDS *));
merge_state(csound, e, t, ids);
}
break;
case KILL_INSTANCE:
{
MYFLT instr;
int mode, insno, rls;
INSDS *ip;
memcpy(&instr, msg->args, sizeof(MYFLT));
memcpy(&insno, msg->args + ARG_ALIGN,
sizeof(int));
memcpy(&ip, msg->args + ARG_ALIGN*2,
sizeof(INSDS *));
memcpy(&mode, msg->args + ARG_ALIGN*3,
sizeof(int));
memcpy(&rls, msg->args + ARG_ALIGN*4,
sizeof(int));
killInstance(csound, instr, insno, ip, mode, rls);
}
break;
}
msg->message = 0;
rp += 1;
}
ATOMIC_SUB(csound->msg_queue_items, items);
csound->msg_queue_rstart = rp % API_MAX_QUEUE;
}
}
