bool do_controller_flush_cmd(int argc, char *argv[]) { chunk_ptr msg = msg_new_flush(); word_t w; int fd; bool ok = true; set_iterstart(worker_fd_set); while (set_iternext(worker_fd_set, &w)) { fd = w; if (!chunk_write(fd, msg)) { err(false, "Failed to send flush message to worker with descriptor %d", fd); ok = false; } } set_iterstart(client_fd_set); while (set_iternext(client_fd_set, &w)) { fd = w; if (!chunk_write(fd, msg)) { err(false, "Failed to send flush message to client with descriptor %d", fd); ok = false; } } chunk_free(msg); free_global_ops(); gc_state = GC_READY; need_worker_cnt = 0; if (need_client_fd_set != NULL) set_free(need_client_fd_set); need_client_fd_set = NULL; if (defer_client_fd_set != NULL) set_free(defer_client_fd_set); defer_client_fd_set = NULL; return ok; }
static Set *new_matches(void) { Set *set; char *tmp; int r; set = set_new(trivial_hash_func, trivial_compare_func); if (!set) { log_oom(); return NULL; } tmp = strdup("MESSAGE_ID=fc2e22bc6ee647b6b90729ab34a250b1"); if (!tmp) { log_oom(); set_free(set); return NULL; } r = set_consume(set, tmp); if (r < 0) { log_error("failed to add to set: %s", strerror(-r)); set_free(set); return NULL; } return set; }
ddf_boolean ddf_CheckEmptiness(ddf_PolyhedraPtr poly, ddf_ErrorType *err) { ddf_rowset R, S; ddf_MatrixPtr M=NULL; ddf_boolean answer=ddf_FALSE; *err=ddf_NoError; if (poly->representation==ddf_Inequality){ M=ddf_CopyInequalities(poly); set_initialize(&R, M->rowsize); set_initialize(&S, M->rowsize); if (!ddf_ExistsRestrictedFace(M, R, S, err)){ poly->child->CompStatus=ddf_AllFound; poly->IsEmpty=ddf_TRUE; poly->n=0; answer=ddf_TRUE; } set_free(R); set_free(S); ddf_FreeMatrix(M); } else if (poly->representation==ddf_Generator && poly->m<=0){ *err=ddf_EmptyVrepresentation; poly->IsEmpty=ddf_TRUE; poly->child->CompStatus=ddf_AllFound; answer=ddf_TRUE; poly->child->Error=*err; } return answer;
void test_communicate() { int valuebuf[] = { 1 }; size_t i; ListObject *lp = list_new(); for(i = 0; i < 10; i++) { *valuebuf = i; list_add(lp, valuebuf); } ListObject *lp2 = list_new(); for(i = 5; i < 15; i++) { *valuebuf = i; list_add(lp2, valuebuf); } printf("list1 is:\n"); list_print(lp); printf("list2 is:\n"); list_print(lp2); SetObject *sp = set_fromlist(lp, int_hash, lp->keycmp, lp->keydup, 0); printf("set from list1 is:\n"); set_print_int(sp); SetObject *sp2 = set_fromlist(lp2, int_hash, lp2->keycmp, lp2->keydup, 0); printf("set from list2 is:\n"); set_print_int(sp2); printf("so, intersection of the two list is\n"); set_print_int(set_and(sp, sp2)); list_free(lp); list_free(lp2); set_free(sp); set_free(sp2); }
void exit_status_set_free(ExitStatusSet *x) { assert(x); set_free(x->status); set_free(x->signal); x->status = x->signal = NULL; }
static void test_set(void) { char *keys1[] = {"a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a"}; char *keys2[] = {"a", "l", "a", "c", "a", "z", "a", "m"}; SetObject *a = set_new(); SetObject *b = set_new(); set_addfrom(a, (void**)keys1, 11); set_addfrom(b, (void**)keys2, 8); set_print(a); // { 'c', 'd', 'r', 'a', 'b', } set_print(b); // { 'c', 'l', 'm', 'a', 'z', } set_print(set_rsub(a, b)); //{ 'd', 'b', 'r', } set_print(set_ror(a, b)); //{ 'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z', } set_print(set_rand(a, b)); //{ 'c', 'a', } set_print(set_rxor(a, b)); //{ 'b', 'd', 'l', 'm', 'r', 'z', } set_ior(a, b); set_print(a); set_isub(a, b); set_print(a); set_ixor(a, b); set_print(a); set_iand(a, b); set_print(a); set_free(a); set_free(b); char *keys3[] = {"a", "b"}; char *keys4[] = {"a", "b", "d", "c", "e", "f", "g", "h"}; SetObject *c = set_new(); SetObject *d = set_new(); set_addfrom(c, (void**)keys3, 2); set_addfrom(d, (void**)keys4, 8); set_print(set_xor(c, d)); set_print(set_and(c, d)); set_print(set_sub(c, d)); }
static Set *new_matches(void) { Set *set; char *tmp; int r; set = set_new(NULL); if (!set) { log_oom(); return NULL; } tmp = strdup("MESSAGE_ID=fc2e22bc6ee647b6b90729ab34a250b1"); if (!tmp) { log_oom(); set_free(set); return NULL; } r = set_consume(set, tmp); if (r < 0) { log_error_errno(r, "failed to add to set: %m"); set_free(set); return NULL; } return set; }
Set *set_union(Set *set1, Set *set2) { SetIterator iterator; Set *new_set; SetValue value; new_set = set_new(set1->hash_func, set1->equal_func); if (new_set == NULL) { return NULL; } /* Add all values from the first set */ set_iterate(set1, &iterator); while (set_iter_has_more(&iterator)) { /* Read the next value */ value = set_iter_next(&iterator); /* Copy the value into the new set */ if (!set_insert(new_set, value)) { /* Failed to insert */ set_free(new_set); return NULL; } } /* Add all values from the second set */ set_iterate(set2, &iterator); while (set_iter_has_more(&iterator)) { /* Read the next value */ value = set_iter_next(&iterator); /* Has this value been put into the new set already? * If so, do not insert this again */ if (set_query(new_set, value) == 0) { if (!set_insert(new_set, value)) { /* Failed to insert */ set_free(new_set); return NULL; } } } return new_set; }
void test_set_intersection (void) { int numbers1[] = {1, 2, 3, 4, 5, 6, 7}; int numbers2[] = {5, 6, 7, 8, 9, 10, 11}; int result[] = {5, 6, 7}; int i; Set* set1; Set* set2; Set* result_set; size_t allocated; /* Create the first set */ set1 = set_new (int_hash, int_equal); for (i = 0; i < 7; ++i) { set_insert (set1, &numbers1[i]); } /* Create the second set */ set2 = set_new (int_hash, int_equal); for (i = 0; i < 7; ++i) { set_insert (set2, &numbers2[i]); } /* Perform the intersection */ result_set = set_intersection (set1, set2); assert (set_num_entries (result_set) == 3); for (i = 0; i < 3; ++i) { assert (set_query (result_set, &result[i]) != 0); } /* Test out of memory scenario */ alloc_test_set_limit (0); assert (set_intersection (set1, set2) == NULL); /* Can allocate set, can't copy all values */ alloc_test_set_limit (2 + 2); allocated = alloc_test_get_allocated(); assert (set_intersection (set1, set2) == NULL); assert (alloc_test_get_allocated() == allocated); set_free (set1); set_free (set2); set_free (result_set); }
void set_test() { printf("SET S: "); set* s = set_init(); set_add(s, (SETDATA*)1); set_add(s, (SETDATA*)2); set_add(s, (SETDATA*)3); set_add(s, (SETDATA*)4); set_add(s, (SETDATA*)5); set_add(s, (SETDATA*)6); set_print(s, set_testcb); printf("S \\ 2, 6: "); set_remove(s, (SETDATA*)6); set_remove(s, (SETDATA*)2); set_print(s, set_testcb); printf("SET T: "); set* t = set_init(); set_add(t, (SETDATA*)1); set_add(t, (SETDATA*)2); set_add(t, (SETDATA*)9); set_add(t, (SETDATA*)4); set_print(t, set_testcb); printf("UNION OF S, T: "); set* u = set_init(); set_union(u, s, t); set_print(u, set_testcb); printf("INTERSECTION OF S, T: "); set* i = set_init(); set_intersection(i, s, t); set_print(i, set_testcb); printf("DIFFERENCE OF S, T: "); set* d = set_init(); set_difference(d, s, t); set_print(d, set_testcb); printf("CLEAR S: "); set_clear(s); set_print(s, set_testcb); set_free(s); set_free(t); set_free(u); set_free(i); set_free(d); }
static void validate_free(validate_type * validate) { if (validate->common_selection_set != NULL) set_free(validate->common_selection_set); if (validate->indexed_selection_set != NULL) { for (int i = 0; i < validate->argc_max; i++) if (validate->indexed_selection_set[i] != NULL) set_free(validate->indexed_selection_set[i]); free(validate->indexed_selection_set); } int_vector_free( validate->type_map ); if (validate->required_children != NULL) stringlist_free(validate->required_children); if (validate->required_children_value != NULL) hash_free(validate->required_children_value); free(validate); }
void split_item(item_p i, size_t size) { if (block_size(i) <= size) return; item_p j = get_unmatched_item(); if (j == NULL) return; j->size = block_size(i) - size; i->size = size; set_free(i); set_free(j); j->data = i->data + size; j->next = i->next; i->next = j; freeblks++; }
static void automount_done(Unit *u) { Automount *a = AUTOMOUNT(u); assert(a); unmount_autofs(a); a->where = mfree(a->where); a->tokens = set_free(a->tokens); a->expire_tokens = set_free(a->expire_tokens); a->expire_event_source = sd_event_source_unref(a->expire_event_source); }
static void context_free(Context *context) { sd_event_source *es; Connection *c; assert(context); while ((es = set_steal_first(context->listen))) sd_event_source_unref(es); while ((c = set_first(context->connections))) connection_free(c); set_free(context->listen); set_free(context->connections); }
/* 0 files to go -> "0s " */ TEST word_adds_find_dupes() { set *s = set_new(2, dumb_hash, cmp); int duplicates[word_count]; bzero(duplicates, word_count * sizeof(int)); for (int i=0; i<word_count; i++) { char *w = words[i]; ASSERT(w); if (set_known(s, w)) { duplicates[i] = 1; } else { if (set_store(s, (void *) w) == TABLE_SET_FAIL) FAIL(); } } for (int i=0; i<word_count; i++) { if (0) printf("%d - %s %d\n", i, words[i], duplicates[i]); } for (int i=0; i<18; i++) { ASSERT_EQm("none of the first 18 are duplicates", 0, duplicates[i]); } ASSERT_EQm("words[19] (\"onion\") is a dup", 1, duplicates[19]); ASSERT_EQm("the last word (\"fennel\") is a dup", 1, duplicates[word_count - 1]); set_free(s, NULL); PASS(); }
long mem_get(long request){ long l = request; long lidx = 0; long idx = 2; while(idx != 0){ if(get_length(idx) >= l && get_free(idx)){ /* Gat gevonden waar de aanvraag in past. */ lidx = idx; l = get_length(idx); break; } idx = get_next(idx); } if(lidx == 0){ /* Geen gat groot genoeg. */ return -1; }else if(l == request){ /* Gat precies groot genoeg. */ mem[0] += request; mem[1] += ADMIN_SIZE; set_free(lidx, 0); return lidx + ADMIN_SIZE; }else{ /* Alleen een gat > request. */ return split_block(lidx, request); } }
void broadcast_signal(int sig, bool wait_for_exit) { sigset_t mask, oldmask; Set *pids = NULL; if (wait_for_exit) pids = set_new(trivial_hash_func, trivial_compare_func); assert_se(sigemptyset(&mask) == 0); assert_se(sigaddset(&mask, SIGCHLD) == 0); assert_se(sigprocmask(SIG_BLOCK, &mask, &oldmask) == 0); if (kill(-1, SIGSTOP) < 0 && errno != ESRCH) log_warning("kill(-1, SIGSTOP) failed: %m"); killall(sig, pids); if (kill(-1, SIGCONT) < 0 && errno != ESRCH) log_warning("kill(-1, SIGCONT) failed: %m"); if (wait_for_exit) wait_for_children(pids, &mask); assert_se(sigprocmask(SIG_SETMASK, &oldmask, NULL) == 0); set_free(pids); }
int fdset_new_listen_fds(FDSet **_s, bool unset) { int n, fd, r; FDSet *s; assert(_s); /* Creates an fdset and fills in all passed file descriptors */ s = fdset_new(); if (!s) { r = -ENOMEM; goto fail; } n = sd_listen_fds(unset); for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd ++) { r = fdset_put(s, fd); if (r < 0) goto fail; } *_s = s; return 0; fail: if (s) set_free(MAKE_SET(s)); return r; }
void ddf_InitialDataSetup(ddf_ConePtr cone) { long j, r; ddf_rowset ZSet; static ddf_Arow Vector1,Vector2; static ddf_colrange last_d=0; if (last_d < cone->d){ if (last_d>0) { for (j=0; j<last_d; j++){ ddf_clear(Vector1[j]); ddf_clear(Vector2[j]); } free(Vector1); free(Vector2); } Vector1=(myfloat*)calloc(cone->d,sizeof(myfloat)); Vector2=(myfloat*)calloc(cone->d,sizeof(myfloat)); for (j=0; j<cone->d; j++){ ddf_init(Vector1[j]); ddf_init(Vector2[j]); } last_d=cone->d; } cone->RecomputeRowOrder=ddf_FALSE; cone->ArtificialRay = NULL; cone->FirstRay = NULL; cone->LastRay = NULL; set_initialize(&ZSet,cone->m); ddf_AddArtificialRay(cone); set_copy(cone->AddedHalfspaces, cone->InitialHalfspaces); set_copy(cone->WeaklyAddedHalfspaces, cone->InitialHalfspaces); ddf_UpdateRowOrderVector(cone, cone->InitialHalfspaces); for (r = 1; r <= cone->d; r++) { for (j = 0; j < cone->d; j++){ ddf_set(Vector1[j], cone->B[j][r-1]); ddf_neg(Vector2[j], cone->B[j][r-1]); } ddf_Normalize(cone->d, Vector1); ddf_Normalize(cone->d, Vector2); ddf_ZeroIndexSet(cone->m, cone->d, cone->A, Vector1, ZSet); if (set_subset(cone->EqualitySet, ZSet)){ if (ddf_debug) { fprintf(stderr,"add an initial ray with zero set:"); set_fwrite(stderr,ZSet); } ddf_AddRay(cone, Vector1); if (cone->InitialRayIndex[r]==0) { ddf_AddRay(cone, Vector2); if (ddf_debug) { fprintf(stderr,"and add its negative also.\n"); } } } } ddf_CreateInitialEdges(cone); cone->Iteration = cone->d + 1; if (cone->Iteration > cone->m) cone->CompStatus=ddf_AllFound; /* 0.94b */ set_free(ZSet);
/* ------------------------------------------------------------------------- * --- set_free * ------------------------------------------------------------------------- */ static void set_prod_free(Set* set) { assert(set_prod_is_valid(set)); set_free(set->prod.set_a); set_free(set->prod.set_b); set->head.refc--; if (set->head.refc == 0) { SID_del2(set->prod); free(set); } }
atom_list() #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { set_free(zzaRet.label); { zzBLOCK(zztasp2); zzMake0; { while ( (setwd3[LA(1)]&0x1) ) { near_atom(); set_orin(&(zzaRet.label),zzaArg(zztasp2,1 ).label); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x2); } }
void ecl_config_free(ecl_config_type * ecl_config) { ecl_io_config_free( ecl_config->io_config ); if (ecl_config->eclbase != NULL) path_fmt_free( ecl_config->eclbase ); set_free( ecl_config->static_kw_set ); stringlist_free( ecl_config->user_static_kw ); util_safe_free(ecl_config->data_file); if (ecl_config->sched_file != NULL) sched_file_free(ecl_config->sched_file); util_safe_free(ecl_config->schedule_target_file); hash_free( ecl_config->fixed_length_kw ); util_safe_free(ecl_config->input_init_section); util_safe_free(ecl_config->init_section); util_safe_free(ecl_config->schedule_prediction_file); if (ecl_config->grid != NULL) ecl_grid_free( ecl_config->grid ); ecl_refcase_list_free( ecl_config->refcase_list ); free(ecl_config); }
static int list_vconsole_keymaps(DBusConnection *bus, char **args, unsigned n) { char _cleanup_strv_free_ **l = NULL; char **i; keymaps = set_new(string_hash_func, string_compare_func); if (!keymaps) return log_oom(); nftw("/usr/share/kbd/keymaps/", nftw_cb, 20, FTW_MOUNT|FTW_PHYS); nftw("/usr/lib/kbd/keymaps/", nftw_cb, 20, FTW_MOUNT|FTW_PHYS); nftw("/lib/kbd/keymaps/", nftw_cb, 20, FTW_MOUNT|FTW_PHYS); l = set_get_strv(keymaps); if (!l) { set_free_free(keymaps); return log_oom(); } set_free(keymaps); if (strv_isempty(l)) { log_error("Couldn't find any console keymaps."); return -ENOENT; } strv_sort(l); pager_open_if_enabled(); STRV_FOREACH(i, l) puts(*i); return 0; }
static int list_vconsole_keymaps(sd_bus *bus, char **args, unsigned n) { _cleanup_strv_free_ char **l = NULL; const char *dir; keymaps = set_new(string_hash_func, string_compare_func); if (!keymaps) return log_oom(); NULSTR_FOREACH(dir, KBD_KEYMAP_DIRS) nftw(dir, nftw_cb, 20, FTW_MOUNT|FTW_PHYS); l = set_get_strv(keymaps); if (!l) { set_free_free(keymaps); return log_oom(); } set_free(keymaps); if (strv_isempty(l)) { log_error("Couldn't find any console keymaps."); return -ENOENT; } strv_sort(l); pager_open_if_enabled(); strv_print(l); return 0; }
void compact() { void* threshold = NULL; void* last = NULL; item_p i = matched; item_p* prev = &matched; while (i != NULL) { threshold = i->data + block_size(i); if (is_free(i)) { *prev = i->next; i->next = unmatched; unmatched = i; if (last == NULL) last = i->data; i = *prev; } else { if (last != NULL) { memcpy(last, i->data, block_size(i)); i->data = last; last = last + block_size(i); prev = &(i->next); } i = i->next; } } freeblks = 0; if (last != NULL && last != threshold) { i = get_unmatched_item(); i->data = last; i->size = (char*)threshold - (char*)last; set_free(i); *prev = i; freeblks++; } }
void symbol_exit(void) { Symbol* q; Symbol* p; int i; for(p = anchor; p != NULL; p = q) { assert(symbol_is_valid(p)); SID_del(p); q = p->next; for(i = 0; i < p->used; i++) entry_free(p->entry[i]); free(p->entry); set_free(p->set); hash_free(p->hash); if (p->deflt != NULL) entry_free(p->deflt); free(p); } anchor = NULL; }
/* Deze methode wijst length woorden toe aan een proces. De overgebleven * woorden worden gezien als nieuw vrij blok. */ int split_block(long index, long length){ long blockleng = get_length(index); long newidx = index + length + ADMIN_SIZE; long newleng = blockleng - length - ADMIN_SIZE; if(blockleng < length + ADMIN_SIZE + 1){ /* Geen ruimte voor een nieuw blok van minimaal 1 woord. */ return -1; } /* Maak het nieuwe blok. Plaats deze na 'length' woorden. */ new_block(newidx, newleng, index, get_next(index)); /* Als het huidige blok een volgende blok heeft moet de pointer van * dat blok welke naar zijn vorige blok wijst naar het nieuwe blok * gezet worden.*/ if(get_next(index) != 0){ set_prev(get_next(index), newidx); } /* Zet het volgende blok van het huidige blok naar het nieuwe blok. */ set_next(index, newidx); /* Zet de length van het huidige blok en zet hem op toegewezen. */ set_length(index, length); set_free(index, 0); /* Verhoog het aantal loze woorden. */ mem[1] += ADMIN_SIZE; /* Verhoog het aantal toegewezen woorden. */ mem[0] += length; /* De index waar begonnen mag worden met schrijven is het blok index * plus de lengte van de administratie. */ return index + ADMIN_SIZE; }
void reduce_v(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]) { dd_ErrorType err; dd_MatrixPtr V,V1; dd_rowset red; if (nrhs == 1 && nlhs >= 1 && nlhs <= 2 && mxIsStruct(prhs[0])) { dd_set_global_constants(); /* First, this must be called. */ V = FT_get_V_MatrixPtr(prhs[0]); red = dd_RedundantRows(V, &err); /* find redundant rows */ if (err == dd_NoError) { /* remove the red rows */ V1 = dd_MatrixSubmatrix(V, red); plhs[0] = FT_set_V_MatrixPtr(V1); dd_FreeMatrix(V1); if (nlhs == 2) { plhs[1] = FT_set_Set(red); } } else { dd_WriteErrorMessages(stdout,err); mexErrMsgTxt("CDD returned an error, see above(!) for details"); } dd_FreeMatrix(V); set_free(red); return; } else { mexErrMsgTxt("reduce_v expects an V input struct and produces a V output struct and an optional vector of removed vertices"); } }
/* Deze methode zet het blok op index op vrij, indien mogelijk fuseert het * met omringende vrije blokken. */ void free_block(long index){ long prev = get_prev(index); long next = get_next(index); if(!get_free(index)){ /* Zet het blok op vrij. */ set_free(index, 1); mem[0] -= get_length(index); } /* Voeg vorige blok samen met het huidige als deze vrij is als een groot * vrij blok. */ if(prev != 0 && get_free(prev)){ set_length(prev, get_length(prev) + get_length(index) + ADMIN_SIZE); set_next(prev, next); if(next != 0){ set_prev(next, prev); } mem[1] -= ADMIN_SIZE; } /* Voeg volgende blok samen met het huidige als deze vrij is als een * groot vrij blok. */ if(next != 0 && get_free(next)){ free_block(next); } }
/* * graph_resize() * * Resizes graph g to given size. If size > g->n, the new vertices are * not connected to any others and their weights are set to 1. * If size < g->n, the last g->n - size vertices are removed. */ void graph_resize(graph_t *g, int size) { int i; ASSERT(g!=NULL); ASSERT(g->n > 0); ASSERT(size > 0); if (g->n == size) return; /* Free/alloc extra edge-sets */ for (i=size; i < g->n; i++) set_free(g->edges[i]); g->edges=realloc(g->edges, size * sizeof(set_t)); for (i=g->n; i < size; i++) g->edges[i]=set_new(size); /* Resize original sets */ for (i=0; i < MIN(g->n,size); i++) { g->edges[i]=set_resize(g->edges[i],size); } /* Weights */ g->weights=realloc(g->weights,size * sizeof(int)); for (i=g->n; i<size; i++) g->weights[i]=1; g->n=size; return; }