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);
}
