void hashmap_add(hashmap *map, const char *key, void *data, boolean is_alias) { hashnode *node; uint16_t bucket; assert(map); assert(key); assert(data); if ((node = malloc(sizeof(hashnode))) == NULL) { quit_error(POUTOFMEM); } node->key = key; node->data = data; node->hash = hashmap_hash(key); node->is_alias = is_alias; bucket = node->hash % map->buckets; if (!map->data[bucket]) { map->data[bucket] = darray_create(); darray_push(map->data[bucket], node); } else { darray_push(map->data[bucket], node); } }
void Server_queue_cleanup() { if(darray_end(SERVER_QUEUE) < SERVER_ACTIVE) { // skip it, not enough to care about return; } // pop the last one off to make sure it's never deleted Server *cur_srv = darray_pop(SERVER_QUEUE); uint32_t too_old = time(NULL) - SERVER_TTL; int i = 0; // TODO: kind of a dumb way to do this since it reorders the list // go through all but the max we want to keep for(i = 0; i < darray_end(SERVER_QUEUE) - SERVER_ACTIVE; i++) { Server *srv = darray_get(SERVER_QUEUE, i); if(srv->created_on < too_old) { Server *replace = darray_pop(SERVER_QUEUE); darray_set(SERVER_QUEUE, i, replace); srv->listen_fd = -1; // don't close it Server_destroy(srv); } } // put the sacred server back on the end darray_push(SERVER_QUEUE, cur_srv); return; }
static int simple_set_session( ssl_context *ssl ) { time_t t = THE_CURRENT_TIME_IS; int i = 0; ssl_session *cur = NULL; int make_new = 1; check(setup_ssl_session_cache() == 0, "Failed to initialize SSL session cache."); for(i = 0; i < darray_end(SSL_SESSION_CACHE); i++) { cur = darray_get(SSL_SESSION_CACHE, i); if( ssl->timeout != 0 && t - cur->start > ssl->timeout ) { make_new = 0; break; /* expired, reuse this slot */ } if( memcmp( ssl->session->id, cur->id, cur->length ) == 0 ) { make_new = 0; break; /* client reconnected */ } } if(make_new) { cur = (ssl_session *) darray_new(SSL_SESSION_CACHE); check_mem(cur); darray_push(SSL_SESSION_CACHE, cur); } *cur = *ssl->session; return 0; error: return 1; }
int master_init(vr_conf *conf) { rstatus_t status; uint32_t j; sds *host, listen_str; vr_listen **vlisten; int threads_num; int filelimit; master.cbsul = NULL; pthread_mutex_init(&master.cbsullock, NULL); conf_server_get(CONFIG_SOPN_THREADS,&threads_num); filelimit = threads_num*2+CONFIG_MIN_RESERVED_FDS; vr_eventloop_init(&master.vel,filelimit); master.vel.thread.fun_run = master_thread_run; darray_init(&master.listens,darray_n(&cserver->binds),sizeof(vr_listen*)); for (j = 0; j < darray_n(&cserver->binds); j ++) { host = darray_get(&cserver->binds,j); listen_str = sdsdup(*host); listen_str = sdscatfmt(listen_str, ":%i", cserver->port); vlisten = darray_push(&master.listens); *vlisten = vr_listen_create(listen_str); if (*vlisten == NULL) { darray_pop(&master.listens); log_error("Create listen %s failed", listen_str); sdsfree(listen_str); return VR_ERROR; } sdsfree(listen_str); } for (j = 0; j < darray_n(&master.listens); j ++) { vlisten = darray_get(&master.listens, j); status = vr_listen_begin(*vlisten); if (status != VR_OK) { log_error("Begin listen to %s failed", (*vlisten)->name); return VR_ERROR; } } master.cbsul = dlistCreate(); if (master.cbsul == NULL) { log_error("Create list failed: out of memory"); return VR_ENOMEM; } setup_master(); return VR_OK; }
int hashmap_set(Hashmap *map, void *key, void *data) { uint32_t hash = 0; DArray *bucket = hashmap_find_bucket(map, key, 1, &hash); check(bucket, "error: can't create bucket"); HashmapNode *node = hashmap_node_create(hash, key, data); check_mem(node); darray_push(bucket, node); return 0; error: return -1; }
DArray * darray_radix_sort(DArray *array) { DArray *buckets, *bucket; int *val, i, j, cur, mask, sortval, sorted; buckets = darray_init(); mask = 1; do { sorted = 1; // reset the buckets for (i = 0; i < 10; i++) { darray_set(buckets, i, darray_init()); } // sort the values into buckets for (i = 0; i <= (array->last); i++) { val = (int*)darray_get(array, i); sortval = (*val / mask) % 10; if (sortval > 0) { sorted = 0; } darray_push((PDArray)darray_get(buckets, sortval), val); } // rebuild array cur = 0; for (i = 0; i < 10; i++) { bucket = (PDArray)darray_get(buckets, i); for (j = 0; j <= (bucket->last); j++) { darray_set(array, cur++, darray_get(bucket, j)); } } mask *= 10; } while (!sorted); return array; }
char *test_push_pop() { int i = 0; for(i=0; i<1000; i++) { int *val = darray_new(array); *val = i*333; darray_push(array, val); } mu_assert(array->max==1300, "Wrong max size"); for(i=999; i>=0; i--) { int *val = darray_pop(array); mu_assert(val!=NULL, "Shouldn't get a NULL."); mu_assert(*val==i*333, "Wrong value."); free(val); } return NULL; }
int vrt_dispatch_data_init(int threads_count, char *test_target_groups, int connections) { int j; dispatch_data_threads_count = threads_count; dispatch_data_threads = darray_create(threads_count, sizeof(dispatch_data_thread)); if (dispatch_data_threads == NULL) { return VRT_ERROR; } for (j = 0; j < threads_count; j ++) { dispatch_data_thread *ddt = darray_push(dispatch_data_threads); if (dispatch_data_thread_init(ddt, test_target_groups, connections) != VRT_OK) { return VRT_ERROR; } ddt->id = j; } return VRT_OK; }
int Filter_add(StateEvent state, filter_cb cb, bstring load_path, tns_value_t *config) { darray_t *filters = Filter_lookup_create(state); check(filters != NULL, "Invalid filter state: %d given for filter %s", state, bdata(load_path)); Filter *filter = darray_new(filters); check_mem(filter); filter->state = state; filter->cb = cb; filter->load_path = bstrcpy(load_path); filter->config = config; darray_attach(filters, filter); darray_push(filters, filter); return 0; error: return -1; }
void Server_queue_push(Server *srv) { Server_queue_cleanup(); darray_push(SERVER_QUEUE, srv); hattach(srv, SERVER_QUEUE); }
int main(void) { darray(long) arr = darray_new(); darray_char str = darray_new(); darray(long*) arrp = darray_new(); arrp.onFree = _arr_free_handler; #define reset(arr) do {darray_free(arr); darray_init(arr);} while(0) size_t i; trace("Generating amalgams (internal)"); generateAmalgams(); plan_tests(54); testLits(); testing(darray_pushptr); { int vMaxCount = 10;//ARRAY_SIZE(lotsOfNumbers); for (int k=0; k < vMaxCount; k++) { long* p = malloc(sizeof(long)); *p = lotsOfNumbers[k]; darray_push(arrp, p); } ok1(darray_size(arrp) == vMaxCount); ok1(darray_alloc(arrp) >= darray_size(arrp)); long **i; size_t j = 0; darray_foreach(i, arrp) { if (i - arrp.item != j) break; if (**i != (long)lotsOfNumbers[j]) break; j++; }; ok1(j == vMaxCount); darray_free_all(arrp); ok1(_free_count == vMaxCount); } testing(darray_push); { for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++) darray_push(arr, lotsOfNumbers[i]); ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)); ok1(darray_alloc(arr) >= darray_size(arr)); ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers))); } testing(darray_insert); { darray_insert(arr, 0, 123456); ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)+1); ok1(!memcmp(arr.item+1, lotsOfNumbers, sizeof(lotsOfNumbers))); ok1(darray_item(arr, 0) == 123456); darray_insert(arr, 15, 0x112233); ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)+2); ok1(darray_item(arr, 15) == 0x112233); ok1(!memcmp(arr.item+1, lotsOfNumbers, 14*sizeof(long))); ok1(!memcmp(arr.item+16, &lotsOfNumbers[14], ARRAY_SIZE(lotsOfNumbers)-(15*sizeof(long)))); } testing(darray_del); { darray_del(arr, 15); darray_del(arr, 0); ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)); ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers))); } reset(arr); testing(darray_prepend, darray_pop); { for (i = ARRAY_SIZE(lotsOfNumbers); i;) darray_prepend(arr, lotsOfNumbers[--i]); ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)); ok1(darray_alloc(arr) >= darray_size(arr)); ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers))); for (i = ARRAY_SIZE(lotsOfNumbers); i;) { if (darray_pop(arr) != (long)lotsOfNumbers[--i]) { i++; break; } } ok1(i==0); ok1(darray_size(arr) == 0); } reset(arr); testing(darray_from_c, darray_foreach, darray_foreach_reverse); { long *i; size_t j; darray_from_c(arr, lotsOfNumbers); ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)); ok1(darray_alloc(arr) >= darray_size(arr)); ok1(memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)) == 0); j = 0; darray_foreach(i, arr) { if (i - arr.item != j) break; if (*i != (long)lotsOfNumbers[j]) break; j++; }; ok1(j == ARRAY_SIZE(lotsOfNumbers)); j = 0; darray_foreach_reverse(i, arr) { if (i - arr.item != darray_size(arr)-j-1) break; if (*i != (long)lotsOfNumbers[darray_size(arr)-j-1]) break; j++; }; ok1(j == ARRAY_SIZE(lotsOfNumbers)); } reset(arr); testing(darray_append_string); { for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) darray_append_string(str, lotsOfStrings[i]); ok1(str.size == amalgams.stringsSize); ok1(str.alloc > str.size); ok1(str.item[str.size] == 0); ok1(!strcmp(str.item, amalgams.stringsF)); } reset(str); testing(darray_prepend_string); { for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) darray_prepend_string(str, lotsOfStrings[i]); ok1(str.size == amalgams.stringsSize); ok1(str.alloc > str.size); ok1(str.item[str.size] == 0); ok1(!strcmp(str.item, amalgams.stringsB)); } reset(str); testing(darray_from_string); { for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) { darray_from_string(str, lotsOfStrings[i]); if (str.size != strlen(lotsOfStrings[i])) break; if (str.alloc < strlen(lotsOfStrings[i])+1) break; if (strcmp(str.item, lotsOfStrings[i])) break; } ok1(i == ARRAY_SIZE(lotsOfStrings)); } reset(str); testing(darray_resize0); { size_t prevSize=0, size; for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++, prevSize=size) { size = lotsOfNumbers[i] & 0xFFFF; darray_resize0(arr, size); if (darray_size(arr) != size) break; if (darray_alloc(arr) < size) break; if (size>prevSize) { if (!isZeros(arr.item+prevSize, (size-prevSize)*sizeof(*arr.item))) break; } //fill the darray with lotsOfNumbers garbage memtile(arr.item, darray_size(arr)*sizeof(*arr.item), lotsOfNumbers, sizeof(lotsOfNumbers)); } ok1(i == ARRAY_SIZE(lotsOfNumbers)); } reset(arr); testing(darray_realloc); { size_t s,a; for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++) { arr.size = (s = lotsOfNumbers[i] >> 16); //give size a nonsense value to make sure darray_realloc doesn't care about it a = amalgams.stringsSize/sizeof(*arr.item)+2; darray_realloc(arr, a = lotsOfNumbers[i] % ((amalgams.stringsSize/sizeof(*arr.item))+1)); if (a*sizeof(*arr.item) > amalgams.stringsSize) break; if (darray_alloc(arr) != a) break; if (darray_size(arr) != s) break; memtile(arr.item, a*sizeof(*arr.item), amalgams.stringsF, a*sizeof(*arr.item)); if (memcmp(arr.item, amalgams.stringsF, a*sizeof(*arr.item))) break; } ok1(i == ARRAY_SIZE(lotsOfNumbers)); } reset(arr); testing(darray_growalloc); { size_t prevA, s, a; for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++) { arr.size = (s = lotsOfNumbers[i] >> 16); //give size a nonsense value to make sure darray_growalloc doesn't care about it a = amalgams.stringsSize/sizeof(*arr.item)+2; prevA = darray_alloc(arr); darray_growalloc(arr, a = lotsOfNumbers[i] % ((amalgams.stringsSize/sizeof(*arr.item))+1)); if (a*sizeof(*arr.item) > amalgams.stringsSize) break; if (darray_alloc(arr) < a) break; if (darray_alloc(arr) < prevA) break; if (darray_size(arr) != s) break; memtile(arr.item, a*sizeof(*arr.item), amalgams.stringsF, a*sizeof(*arr.item)); if (memcmp(arr.item, amalgams.stringsF, a*sizeof(*arr.item))) break; //clear the darray every now and then if (!(lotsOfNumbers[i] & 15)) { reset(arr); } } ok1(i == ARRAY_SIZE(lotsOfNumbers)); } reset(arr); testing(darray_make_room); { for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) { char *dest = darray_make_room(str, strlen(lotsOfStrings[i])); if (str.alloc < str.size+strlen(lotsOfStrings[i])) break; if (dest != str.item+str.size) break; memcpy(dest, lotsOfStrings[i], strlen(lotsOfStrings[i])); str.size += strlen(lotsOfStrings[i]); } ok1(i == ARRAY_SIZE(lotsOfStrings)); ok1(str.size == amalgams.stringsSize); darray_append(str, 0); ok1(!strcmp(str.item, amalgams.stringsF)); } reset(str); testing(darray_appends, darray_prepends, darray_pop_check); { darray(const char*) arr = darray_new(); const char *n[9] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight"}; #if HAVE_TYPEOF darray_appends(arr, n[5], n[6], n[7], n[8]); #else darray_appends_t(arr, const char *, n[5], n[6], n[7], n[8]); #endif ok1(darray_size(arr)==4 && darray_alloc(arr)>=4); #if HAVE_TYPEOF darray_prepends(arr, n[0], n[1], n[2], n[3], n[4]); #else darray_prepends_t(arr, const char *, n[0], n[1], n[2], n[3], n[4]); #endif ok1(darray_size(arr)==9 && darray_alloc(arr)>=9); ok1(arr.item[0]==n[0] && arr.item[1]==n[1] && arr.item[2]==n[2] && arr.item[3]==n[3] && arr.item[4]==n[4] && arr.item[5]==n[5] && arr.item[6]==n[6] && arr.item[7]==n[7] && arr.item[8]==n[8]); ok1(darray_pop_check(arr)==n[8] && darray_pop_check(arr)==n[7] && darray_pop_check(arr)==n[6] && darray_pop_check(arr)==n[5] && darray_pop_check(arr)==n[4] && darray_pop_check(arr)==n[3] && darray_pop_check(arr)==n[2] && darray_pop_check(arr)==n[1] && darray_pop_check(arr)==n[0]); ok1(darray_size(arr)==0); ok1(darray_pop_check(arr)==NULL && darray_pop_check(arr)==NULL && darray_pop_check(arr)==NULL); darray_free(arr); } trace("Freeing amalgams (internal)"); freeAmalgams(); return exit_status(); }
void MemoryAllocation_PushA(DArray *array, MemoryAllocation *s) { darray_push(array, s); }
char *test_darray_operations() { darray_t *array = darray_create(sizeof(int), 100); mu_assert(array != NULL, "darray_create failed."); mu_assert(array->contents != NULL, "contents are wrong in darray"); mu_assert(array->end == 0, "end isn't at the right spot"); mu_assert(array->element_size == sizeof(int), "element size is wrong."); mu_assert(array->max == 100, "wrong max length on initial size"); int *val1 = darray_new(array); mu_assert(val1 != NULL, "failed to make a new element"); int *val2 = darray_new(array); mu_assert(val2 != NULL, "failed to make a new element"); darray_set(array, 0, val1); darray_set(array, 1, val2); mu_assert(darray_get(array, 0) == val1, "Wrong first value."); mu_assert(darray_get(array, 1) == val2, "Wrong second value."); int *val_check = darray_remove(array, 0); mu_assert(val_check != NULL, "Should not get NULL."); mu_assert(*val_check == *val1, "Should get the first value."); mu_assert(darray_get(array, 0) == NULL, "Should be gone."); darray_free(val_check); val_check = darray_remove(array, 1); mu_assert(val_check != NULL, "Should not get NULL."); mu_assert(*val_check == *val2, "Should get the first value."); mu_assert(darray_get(array, 1) == NULL, "Should be gone."); darray_free(val_check); int old_max = array->max; darray_expand(array); mu_assert(array->max == old_max + array->expand_rate, "Wrong size after expand."); darray_contract(array); mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least."); darray_contract(array); mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least."); int i = 0; for(i = 0; i < 1000; i++) { int *val = darray_new(array); darray_attach(array, val); *val = i * 333; darray_push(array, val); } mu_assert(array->max == 1201, "Wrong max size."); for(i = 999; i > 0; i--) { int *val = darray_pop(array); mu_assert(val != NULL, "Shouldn't get a NULL."); mu_assert(*val == i * 333, "Wrong value."); darray_free(val); } darray_destroy(array); return NULL; }
static int dispatch_data_thread_init(dispatch_data_thread *ddt, char *test_target_groups, int connections) { int i, j, k; ddt->id = 0; ddt->thread_id = 0; ddt->el = NULL; ddt->hz = 10; ddt->cronloops = 0; ddt->datas = NULL; ddt->rdatas = NULL; ddt->abgs = NULL; ddt->pause = 0; ddt->count_wait_for_reply = 0; ddt->reply_total_count_per_cycle = 0; ddt->reply_type_err_count_per_cycle = 0; ddt->el = aeCreateEventLoop(200); if (ddt->el == NULL) { return VRT_ERROR; } ddt->datas = dmtqueue_create(); if (ddt->datas == NULL) { return VRT_ERROR; } if (dmtqueue_init_with_lockqueue(ddt->datas, NULL) != 0) { return VRT_ERROR; } ddt->rdatas = dlistCreate(); if (ddt->rdatas == NULL) { return VRT_ERROR; } ddt->abgs = abtest_groups_create(test_target_groups); if (ddt->abgs == NULL) { return VRT_ERROR; } /* Init connection context for each server */ for (i = 0; i < darray_n(ddt->abgs); i ++) { abtest_group *abg = darray_get(ddt->abgs, i); for (j = 0; j < darray_n(&abg->abtest_servers); j ++) { abtest_server *abs = darray_get(&abg->abtest_servers, j); abs->conn_contexts = darray_create(connections, sizeof(conn_context)); for (k = 0; k < connections; k ++) { conn_context *cc = darray_push(abs->conn_contexts); if (dispatch_conn_context_init(cc,abs->host,abs->port) != VRT_OK) { return VRT_ERROR; } cc->actx->data = ddt; redisAeAttach(ddt->el, cc->actx); redisAsyncSetConnectCallback(cc->actx,connect_callback); redisAsyncSetDisconnectCallback(cc->actx,disconnect_callback); } } } if (aeCreateTimeEvent(ddt->el, 1, dispatch_data_thread_cron, ddt, NULL) == AE_ERR) { return VRT_ERROR; } return VRT_OK; }