T_KREventLoop *kr_event_loop_create(int setsize) { T_KREventLoop *eventLoop; int i; if ((eventLoop = kr_malloc(sizeof(*eventLoop))) == NULL) goto err; eventLoop->events = kr_malloc(sizeof(T_KRFileEvent)*setsize); eventLoop->fired = kr_malloc(sizeof(T_KRFiredEvent)*setsize); if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err; eventLoop->setsize = setsize; eventLoop->timeEventHead = NULL; eventLoop->timeEventNextId = 0; eventLoop->stop = 0; eventLoop->maxfd = -1; eventLoop->beforesleep = NULL; if (kr_event_api_create(eventLoop) == -1) goto err; /* Events with mask == KR_EVENT_NONE are not set. So let's initialize the * vector with it. */ for (i = 0; i < setsize; i++) eventLoop->events[i].mask = KR_EVENT_NONE; return eventLoop; err: if (eventLoop) { kr_free(eventLoop->events); kr_free(eventLoop->fired); kr_free(eventLoop); } return NULL; }
T_KRData* kr_data_construct(T_KRParam *ptParam, T_KRModule *ptModule, KRGetTypeFunc pfGetType, KRGetValueFunc pfGetValue) { T_KRData *ptData = kr_malloc(sizeof(T_KRData)); if (ptData == NULL) { KR_LOG(KR_LOGERROR, "kr_malloc ptData Failed!"); return NULL; } ptData->ptModule = ptModule; ptData->pfGetType = pfGetType; ptData->pfGetValue = pfGetValue; ptData->ptItemTable = kr_hashtable_new_full( (KRHashFunc )kr_string_hash, \ (KREqualFunc )kr_string_equal,\ NULL, (KRDestroyNotify )kr_data_item_free); if (ptData->ptItemTable == NULL) { KR_LOG(KR_LOGERROR, "kr_hashtable_new_full item table Failed!"); return NULL; } //load data item according parameter if (kr_data_item_load(ptData, ptParam) != 0) { KR_LOG(KR_LOGERROR, "load item table error!"); return NULL; } ptData->tConstructTime = kr_param_load_time(ptParam); return ptData; }
void armci_shmalloc_exchange_offsets(context_t *ctx_local) { void **ptr_arr; void *ptr; armci_size_t bytes = 128; int i; ptr_arr = (void**)malloc(armci_nproc*sizeof(void*)); offset_arr = (long*) malloc(armci_nproc*sizeof(long)); if(!ptr_arr || !offset_arr) armci_die("armci_shmalloc_get_offsets: malloc failed", 0); /* get memory with same size on all procs */ ptr = kr_malloc(bytes, ctx_local); if(!ptr) armci_die("armci_shmalloc_get_offsets: kr_malloc failed",bytes); bzero((char*)ptr_arr,armci_nproc*sizeof(void*)); ptr_arr[armci_me] = ptr; /* now combine individual addresses into a single array */ armci_exchange_address(ptr_arr, armci_nproc); /* identify offets */ for (i=0; i<armci_nproc; i++) { offset_arr[i] = (long) ((char*)ptr - (char*)ptr_arr[i]); } /* release memory */ kr_free(ptr, ctx_local); }
void armci_altix_shm_malloc(void *ptr_arr[], armci_size_t bytes) { long size=bytes; void *ptr; int i; ARMCI_PR_DBG("enter",0); armci_msg_lgop(&size,1,"max"); ptr=kr_malloc((size_t)size, &altix_ctx_shmem); bzero(ptr_arr,(armci_nproc)*sizeof(void*)); ptr_arr[armci_me] = ptr; if(size!=0 && ptr==NULL) armci_die("armci_altix_shm_malloc(): malloc failed", armci_me); for(i=0; i< armci_nproc; i++) if(i!=armci_me) ptr_arr[i]=shmem_ptr(ptr,i); ARMCI_PR_DBG("exit",0); }
int main() { void *pMalloc=NULL; size_t malloc_size = 100; pMalloc = kr_malloc(malloc_size); assert(pMalloc != NULL); pMalloc = kr_realloc(pMalloc, malloc_size*2); assert(pMalloc != NULL); kr_free(pMalloc); char *pStrDup = kr_strdup("Tiger"); assert(pStrDup != NULL); printf("pStrDup=[%s]\n", pStrDup); kr_free(pStrDup); int i=0; char *paMalloc[100]; for(i=0; i<100; i++) { paMalloc[i] = (char *)kr_malloc(malloc_size*i); assert(paMalloc[i] != NULL); } printf("used memory:[%u], fragmentation_ratio:[%f], rss:[%u]\n", \ kr_malloc_used_memory(), kr_malloc_get_fragmentation_ratio(), kr_malloc_get_rss()); for(i=0; i<100; i++) { kr_free(paMalloc[i]); } return 0; }
static T_KRHdiCacheValue *kr_hdi_cache_value_new(long hid) { T_KRHdiCacheValue *cache_value = \ (T_KRHdiCacheValue *)kr_malloc(sizeof(T_KRHdiCacheValue)); if (cache_value == NULL) { KR_LOG(KR_LOGERROR, "kr_calloc cache_value Failed!"); return NULL; } cache_value->lHDIId = hid; cache_value->eValueType = KR_TYPE_UNKNOWN; memset(cache_value->caDate, 0x00, sizeof(cache_value->caDate)); cache_value->eValueInd = KR_VALUE_UNSET; memset(&cache_value->uValue, 0x00, sizeof(cache_value->uValue)); return cache_value; }
long long kr_event_time_create(T_KREventLoop *eventLoop, long long milliseconds, KREventTimeFunc *proc, void *clientData, KREventFinalizerFunc *finalizerProc) { long long id = eventLoop->timeEventNextId++; T_KRTimeEvent *te; te = kr_malloc(sizeof(*te)); if (te == NULL) return KR_EVENT_ERR; te->id = id; aeAddMillisecondsToNow(milliseconds,&te->when_sec,&te->when_ms); te->timeProc = proc; te->finalizerProc = finalizerProc; te->clientData = clientData; te->next = eventLoop->timeEventHead; eventLoop->timeEventHead = te; return id; }
void armci_altix_shm_malloc_group(void *ptr_arr[], armci_size_t bytes, ARMCI_Group *group) { long size=bytes; void *ptr; int i,grp_me, grp_nproc; armci_grp_attr_t *grp_attr=ARMCI_Group_getattr(group); ARMCI_PR_DBG("enter",0); ARMCI_Group_size(group, &grp_nproc); ARMCI_Group_rank(group, &grp_me); armci_msg_group_lgop(&size,1,"max",group); ptr=kr_malloc((size_t)size, &altix_ctx_shmem_grp); if(size!=0 && ptr==NULL) armci_die("armci_altix_shm_malloc_group(): malloc failed for groups. Increase _SHMMAX_ALTIX_GRP", armci_me); bzero(ptr_arr,(grp_nproc)*sizeof(void*)); ptr_arr[grp_me] = ptr; for(i=0; i< grp_nproc; i++) if(i!=grp_me) ptr_arr[i]=shmem_ptr(ptr,ARMCI_Absolute_id(group, i)); ARMCI_PR_DBG("exit",0); }
T_KRMessage *kr_message_read(int fd) { int readLen = 0; char msghead[KR_MSGHEADER_LEN+1] = {0}; /* read message head */ readLen = kr_net_read(fd, msghead, KR_MSGHEADER_LEN); if (readLen <= 0) { return NULL; } else if (readLen == 0) { return NULL; } /*alloc message*/ T_KRMessage *krmsg = kr_message_alloc(); if (krmsg == NULL) { return NULL; } krmsg->fd = fd; /* parse message head */ if (kr_message_head_parse(msghead, krmsg) != 0) { kr_message_free(krmsg); return NULL; } /* read message body */ if (readLen == KR_MSGHEADER_LEN && krmsg->msglen > 0) { krmsg->msgbuf = kr_malloc(krmsg->msglen); if (krmsg->msgbuf == NULL) { kr_message_free(krmsg); return NULL; } readLen = kr_net_read(fd, krmsg->msgbuf, krmsg->msglen); if (readLen != krmsg->msglen) { kr_message_free(krmsg); return NULL; } } return krmsg; }
void armci_altix_shm_init() { ARMCI_PR_DBG("enter",0); altix_pagesize = getpagesize(); kr_malloc_init(SHM_UNIT, _SHMMAX_ALTIX, 0, armci_altix_allocate, 0, &altix_ctx_shmem); kr_malloc_init(SHM_UNIT, _SHMMAX_ALTIX_GRP, _SHMMAX_ALTIX_GRP, armci_altix_allocate, 0, &altix_ctx_shmem_grp); /* allocate a huge segment for groups. When kr_malloc() is called for the first time for this altix_ctx_shmem_grp context with some minimal size of 8 bytes, a huge segment of size (SHM_UNIT*_SHMMAX_ALTIX_GRP) will be created */ { void *ptr; ptr=kr_malloc((size_t)8, &altix_ctx_shmem_grp); if(ptr==NULL) armci_die("armci_altix_shm_init(): malloc failed", armci_me); } ARMCI_PR_DBG("exit",0); }
T_KRSkipListNode * kr_skiplist_create_node(int level, unsigned int key, void *value) { T_KRSkipListNode *node = kr_malloc(sizeof(T_KRSkipListNode)); if (node == NULL) { fprintf(stderr, "kr_malloc node failed!\n"); return NULL; } node->key = key; node->value = value; node->forward = kr_calloc(level * sizeof(T_KRSkipListNode)); if (node->forward == NULL) { fprintf(stderr, "kr_malloc node->forward failed!\n"); kr_free(node); return NULL; } return node; }
T_KRSkipList *kr_skiplist_create(KRCompareFunc compare_func) { T_KRSkipList *krsl; int i; krsl = kr_malloc(sizeof(T_KRSkipList)); if (krsl == NULL) { fprintf(stderr, "kr_malloc krsl failed!\n"); return NULL; } krsl->header = kr_skiplist_create_node(ZSKIPLIST_MAXLEVEL, 0, NULL); for (i = 0; i < ZSKIPLIST_MAXLEVEL; i++) { krsl->header->forward[i] = NULL; } krsl->length = 0; krsl->level = 1; krsl->compare_func = compare_func; return krsl; }
void *kr_param_persist_file_load_pre(T_KRParamPersistConfig *ptConfig) { char *psFileName = ptConfig->value.file; FILE *fp=fopen(psFileName,"rb"); if (fp == NULL) { KR_LOG(KR_LOGERROR, "fopen %s failed!", psFileName); return NULL; } fseek(fp, 0, SEEK_END); long len=ftell(fp); fseek(fp, 0, SEEK_SET); char *data=(char*)kr_malloc(len+1); int n=fread(data,1,len,fp); fclose(fp); cJSON *root=cJSON_Parse(data); kr_free(data); if (root == NULL) { KR_LOG(KR_LOGERROR, "json parse %s failed! %s", data, cJSON_GetErrorPtr()); return NULL; } char *version = cJSON_GetString(root, "version"); if (strcmp(ptConfig->version, version) != 0) { KR_LOG(KR_LOGERROR, "version mismatch expected:%s actual:%s", ptConfig->version, version); return NULL; } return root; }
/*\ Collective Memory Allocation on shared memory systems \*/ void armci_shmem_malloc(void *ptr_arr[], armci_size_t bytes) { void *myptr=NULL, *ptr=NULL; long idlist[SHMIDLEN]; long size=0, offset=0; long *size_arr; void **ptr_ref_arr; int i,cn, len; int nproc = armci_clus_info[armci_clus_me].nslave; ARMCI_PR_DBG("enter",0); bzero((char*)ptr_arr,armci_nproc*sizeof(void*)); /* allocate work arrays */ size_arr = (long*)calloc(armci_nproc,sizeof(long)); if(!size_arr)armci_die("armci_malloc:calloc failed",armci_nproc); /* allocate arrays for cluster address translations */ # if defined(DATA_SERVER) len = armci_nclus; # else len = nproc; # endif ptr_ref_arr = calloc(len,sizeof(void*)); /* must be zero */ if(!ptr_ref_arr)armci_die("armci_malloc:calloc 2 failed",len); /* combine all memory requests into size_arr */ size_arr[armci_me] = bytes; armci_msg_lgop(size_arr, armci_nproc, "+"); /* determine aggregate request size on the cluster node */ for(i=0, size=0; i< nproc; i++) size += size_arr[i+armci_master]; /* master process creates shmem region and then others attach to it */ if(armci_me == armci_master ){ /* can malloc if there is no data server process and has 1 process/node*/ # ifndef RMA_NEEDS_SHMEM if(nproc == 1) myptr = kr_malloc(size, &ctx_localmem); else # endif myptr = Create_Shared_Region(idlist+1,size,idlist); if(!myptr && size>0 )armci_die("armci_malloc: could not create", (int)(size>>10)); /* place its address at begining of attached region for others to see */ if(size)armci_master_exp_attached_ptr(myptr); if(DEBUG_){ printf("%d:armci_malloc addr mptr=%p size=%ld\n",armci_me,myptr,size); fflush(stdout); } } /* broadcast shmem id to other processes on the same cluster node */ armci_msg_clus_brdcst(idlist, SHMIDLEN*sizeof(long)); if(armci_me != armci_master){ myptr=(double*)Attach_Shared_Region(idlist+1,size,idlist[0]); if(!myptr)armci_die("armci_malloc: could not attach", (int)(size>>10)); /* now every process in a SMP node needs to find out its offset * w.r.t. master - this offset is necessary to use memlock table */ if(size) armci_set_mem_offset(myptr); if(DEBUG_){ printf("%d:armci_malloc attached addr mptr=%p ref=%p size=%ld\n", armci_me,myptr, *(void**)myptr,size); fflush(stdout); } }
void* malloc(size_t size) { return kr_malloc(size); }