inflate_blocks_statef *inflate_blocks_new( z_streamp z, check_func c, uInt w) { inflate_blocks_statef *s; if ((s = (inflate_blocks_statef *)ZALLOC (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL) return s; if ((s->hufts = (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL) { ZFREE(z, s); return Z_NULL; } if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL) { ZFREE(z, s->hufts); ZFREE(z, s); return Z_NULL; } s->end = s->window + w; s->checkfn = c; s->mode = TYPE; Tracev((stderr, "inflate: blocks allocated\n")); inflate_blocks_reset(s, z, Z_NULL); return s; }
void nitro_prefix_trie_add(nitro_prefix_trie_node **t, const uint8_t *rep, uint8_t length, void *ptr) { nitro_prefix_trie_node *n, *on; if (!*t) { ZALLOC(*t); if (length) { (*t)->length = length; (*t)->rep = malloc(length); memmove((*t)->rep, rep, length); } } on = n = *t; if (n->length < length && !memcmp(n->rep, rep, n->length)) { uint8_t c = rep[n->length]; nitro_prefix_trie_add(&n->subs[c], rep, length, ptr); } else { // alloc nitro_prefix_trie_mem *m; ZALLOC(m); m->ptr = ptr; if (n->length == length && !memcmp(n->rep, rep, length)) { DL_APPEND(n->members, m); } else { ZALLOC(n); n->length = length; n->rep = malloc(length); memmove(n->rep, rep, length); DL_APPEND(n->members, m); if (n->length < on->length && !memcmp(on->rep, n->rep, n->length)) { *t = n; n->subs[on->rep[length]] = on; } else if (n->length > on->length && !memcmp(on->rep, n->rep, on->length)) { *t = on; on->subs[n->rep[on->length]] = n; } else { int i; for (i = 0; i < length && on->rep[i] == n->rep[i]; i++) {} nitro_prefix_trie_node *parent; ZALLOC(parent); parent->length = i; parent->rep = malloc(parent->length); memmove(parent->rep, rep, parent->length); parent->subs[rep[parent->length]] = n; parent->subs[on->rep[parent->length]] = on; *t = parent; } } } }
gen_table * make_gen_tables (insn_table *isa, decode_table *rules) { gen_table *gen = ZALLOC (gen_table); gen->isa = isa; gen->rules = rules; if (options.gen.multi_sim) { gen_list **last = &gen->tables; model_entry *model; filter *processors; if (options.model_filter != NULL) processors = options.model_filter; else processors = isa->model->processors; for (model = isa->model->models; model != NULL; model = model->next) { if (filter_is_member (processors, model->name)) { *last = make_table (isa, rules, model); last = &(*last)->next; } } } else { gen->tables = make_table (isa, rules, NULL); } return gen; }
lf * lf_open (char *name, char *real_name, lf_file_references references, lf_file_type type, const char *program) { /* create a file object */ lf *new_lf = ZALLOC (lf); ASSERT (new_lf != NULL); new_lf->references = references; new_lf->type = type; new_lf->name = (real_name == NULL ? name : real_name); new_lf->program = program; /* attach to stdout if pipe */ if (!strcmp (name, "-")) { new_lf->stream = stdout; } else { /* create a new file */ new_lf->stream = fopen (name, "w"); if (new_lf->stream == NULL) { perror (name); exit (1); } } return new_lf; }
nitro_async_t *nitro_async_new(int type) { /* eventually.. pool? */ nitro_async_t *a; ZALLOC(a); a->type = type; return a; }
decode_table * load_decode_table(char *file_name, int hi_bit_nr) { table *file = table_open(file_name, nr_decode_fields, 0); table_entry *entry; decode_table *table = NULL; decode_table **curr_rule = &table; while ((entry = table_entry_read(file)) != NULL) { decode_table *new_rule = ZALLOC(decode_table); new_rule->type = name2i(entry->fields[op_options], decode_type_map); new_rule->gen = (overriding_gen_type != invalid_gen ? overriding_gen_type : name2i(entry->fields[op_options], decode_gen_map)); new_rule->force_slash = name2i(entry->fields[op_options], decode_slash_map); new_rule->first = target_a2i(hi_bit_nr, entry->fields[op_first]); new_rule->last = target_a2i(hi_bit_nr, entry->fields[op_last]); new_rule->force_first = (strlen(entry->fields[op_force_first]) ? target_a2i(hi_bit_nr, entry->fields[op_force_first]) : new_rule->last + 1); new_rule->force_last = (strlen(entry->fields[op_force_last]) ? target_a2i(hi_bit_nr, entry->fields[op_force_last]) : new_rule->first - 1); new_rule->force_expansion = entry->fields[op_force_expansion]; new_rule->special_mask = a2i(entry->fields[op_special_mask]); new_rule->special_value = a2i(entry->fields[op_special_value]); new_rule->special_constant = a2i(entry->fields[op_special_constant]); *curr_rule = new_rule; curr_rule = &new_rule->next; } return table; }
static sim_core_mapping * new_sim_core_mapping (SIM_DESC sd, int level, int space, address_word addr, address_word nr_bytes, unsigned modulo, #if WITH_HW struct hw *device, #else device *device, #endif void *buffer, void *free_buffer) { sim_core_mapping *new_mapping = ZALLOC (sim_core_mapping); /* common */ new_mapping->level = level; new_mapping->space = space; new_mapping->base = addr; new_mapping->nr_bytes = nr_bytes; new_mapping->bound = addr + (nr_bytes - 1); if (modulo == 0) new_mapping->mask = (unsigned) 0 - 1; else new_mapping->mask = modulo - 1; new_mapping->buffer = buffer; new_mapping->free_buffer = free_buffer; new_mapping->device = device; return new_mapping; }
static form_fields * insn_table_cache_fields (insn_table *isa) { form_fields *forms = NULL; insn_entry *insn; for (insn = isa->insns; insn != NULL; insn = insn->next) { form_fields **form = &forms; while (1) { if (*form == NULL) { /* new format name, add it */ form_fields *new_form = ZALLOC (form_fields); new_form->name = insn->format_name; filter_add (&new_form->fields, insn->field_names); *form = new_form; break; } else if (strcmp ((*form)->name, insn->format_name) == 0) { /* already present, add field names to the existing list */ filter_add (&(*form)->fields, insn->field_names); break; } form = &(*form)->next; } } return forms; }
static icache_tree * icache_tree_insert(icache_tree *tree, char *name) { icache_tree *new_tree; /* find it */ icache_tree **ptr_to_cur_tree = &tree->children; icache_tree *cur_tree = *ptr_to_cur_tree; while (cur_tree != NULL && strcmp(cur_tree->name, name) < 0) { ptr_to_cur_tree = &cur_tree->next; cur_tree = *ptr_to_cur_tree; } ASSERT(cur_tree == NULL || strcmp(cur_tree->name, name) >= 0); /* already in the tree */ if (cur_tree != NULL && strcmp(cur_tree->name, name) == 0) return cur_tree; /* missing, insert it */ ASSERT(cur_tree == NULL || strcmp(cur_tree->name, name) > 0); new_tree = ZALLOC(icache_tree); new_tree->name = name; new_tree->next = cur_tree; *ptr_to_cur_tree = new_tree; return new_tree; }
static void insn_table_insert_expanded(insn_table *table, insn *old_insn, int new_opcode_nr, insn_bits *new_bits) { insn_table **ptr_to_cur_entry = &table->entries; insn_table *cur_entry = *ptr_to_cur_entry; /* find the new table for this entry */ while (cur_entry != NULL && cur_entry->opcode_nr < new_opcode_nr) { ptr_to_cur_entry = &cur_entry->sibling; cur_entry = *ptr_to_cur_entry; } if (cur_entry == NULL || cur_entry->opcode_nr != new_opcode_nr) { insn_table *new_entry = ZALLOC(insn_table); new_entry->opcode_nr = new_opcode_nr; new_entry->expanded_bits = new_bits; new_entry->opcode_rule = table->opcode_rule->next; new_entry->sibling = cur_entry; new_entry->parent = table; *ptr_to_cur_entry = new_entry; cur_entry = new_entry; table->nr_entries++; } /* ASSERT new_bits == cur_entry bits */ ASSERT(cur_entry != NULL && cur_entry->opcode_nr == new_opcode_nr); insn_table_insert_insn(cur_entry, old_insn->file_entry, old_insn->fields); }
static void storeline(GVC_t *gvc, textlabel_t *lp, char *line, char terminator) { pointf size; textspan_t *span; static textfont_t tf; int oldsz = lp->u.txt.nspans + 1; lp->u.txt.span = ZALLOC(oldsz + 1, lp->u.txt.span, textspan_t, oldsz); span = &(lp->u.txt.span[lp->u.txt.nspans]); span->str = line; span->just = terminator; if (line && line[0]) { tf.name = lp->fontname; tf.size = lp->fontsize; span->font = dtinsert(gvc->textfont_dt, &tf); size = textspan_size(gvc, span); } else { size.x = 0.0; span->size.y = size.y = (int)(lp->fontsize * LINESPACING); } lp->u.txt.nspans++; /* width = max line width */ lp->dimen.x = MAX(lp->dimen.x, size.x); /* accumulate height */ lp->dimen.y += size.y; }
static void model_table_insert(insn_table *table, table_entry *file_entry) { int len; /* create a new model */ model *new_model = ZALLOC(model); new_model->name = file_entry->fields[model_identifer]; new_model->printable_name = file_entry->fields[model_name]; new_model->insn_default = file_entry->fields[model_default]; while (*new_model->insn_default && isspace(*new_model->insn_default)) new_model->insn_default++; len = strlen(new_model->insn_default); if (max_model_fields_len < len) max_model_fields_len = len; /* append it to the end of the model list */ if (last_model) last_model->next = new_model; else models = new_model; last_model = new_model; }
static line_ref * current_line (open_table * file) { line_ref *entry = ZALLOC (line_ref); *entry = file->pseudo_line; return entry; }
static void test_detect() { struct memory_block mhuge_used = { .chunk_id = 0, 0, 0, 0 }; struct memory_block mhuge_free = { .chunk_id = 1, 0, 0, 0 }; struct memory_block mrun = { .chunk_id = 2, 0, 0, 0 }; pop->hlayout->zone0.chunk_headers[0].size_idx = 1; pop->hlayout->zone0.chunk_headers[0].type = CHUNK_TYPE_USED; pop->hlayout->zone0.chunk_headers[1].size_idx = 1; pop->hlayout->zone0.chunk_headers[1].type = CHUNK_TYPE_FREE; pop->hlayout->zone0.chunk_headers[2].size_idx = 1; pop->hlayout->zone0.chunk_headers[2].type = CHUNK_TYPE_RUN; UT_ASSERTeq(memblock_autodetect_type(&mhuge_used, pop->hlayout), MEMORY_BLOCK_HUGE); UT_ASSERTeq(memblock_autodetect_type(&mhuge_free, pop->hlayout), MEMORY_BLOCK_HUGE); UT_ASSERTeq(memblock_autodetect_type(&mrun, pop->hlayout), MEMORY_BLOCK_RUN); } static void test_block_size() { struct memory_block mhuge = { .chunk_id = 0, 0, 0, 0 }; struct memory_block mrun = { .chunk_id = 1, 0, 0, 0 }; pop->hlayout->zone0.chunk_headers[0].size_idx = 1; pop->hlayout->zone0.chunk_headers[0].type = CHUNK_TYPE_USED; pop->hlayout->zone0.chunk_headers[1].size_idx = 1; pop->hlayout->zone0.chunk_headers[1].type = CHUNK_TYPE_RUN; struct chunk_run *run = (struct chunk_run *) &pop->hlayout->zone0.chunks[1]; run->block_size = 1234; UT_ASSERTeq(MEMBLOCK_OPS(, &mhuge)->block_size(&mhuge, pop->hlayout), CHUNKSIZE); UT_ASSERTeq(MEMBLOCK_OPS(, &mrun)->block_size(&mrun, pop->hlayout), 1234); } int main(int argc, char *argv[]) { START(argc, argv, "obj_memblock"); PMEMobjpool pool; pop = &pool; pop->hlayout = ZALLOC(sizeof(struct heap_layout) + NCHUNKS * sizeof(struct chunk)); test_detect(); test_block_size(); DONE(NULL); }
static void * hw_eeprom_create(const char *name, const device_unit *unit_address, const char *args) { hw_eeprom_device *eeprom = ZALLOC(hw_eeprom_device); return eeprom; }
static void * hw_vm_create(const char *name, const device_unit *address, const char *args) { hw_vm_device *vm = ZALLOC(hw_vm_device); return vm; }
static void * hw_nvram_create(const char *name, const device_unit *unit_address, const char *args) { hw_nvram_device *nvram = ZALLOC(hw_nvram_device); return nvram; }
static void * hw_ide_create(const char *name, const device_unit *unit_address, const char *args) { hw_ide_device *ide = ZALLOC(hw_ide_device); return ide; }
static void * hw_com_create(const char *name, const device_unit *unit_address, const char *args) { /* create the descriptor */ hw_com_device *hw_com = ZALLOC(hw_com_device); return hw_com; }
extern void insn_table_insert_insn(insn_table *table, table_entry *file_entry, insn_fields *fields) { insn **ptr_to_cur_insn = &table->insns; insn *cur_insn = *ptr_to_cur_insn; table_model_entry *insn_model_ptr; model *model_ptr; /* create a new instruction */ insn *new_insn = ZALLOC(insn); new_insn->file_entry = file_entry; new_insn->fields = fields; /* Check out any model information returned to make sure the model is correct. */ for(insn_model_ptr = file_entry->model_first; insn_model_ptr; insn_model_ptr = insn_model_ptr->next) { char *name = insn_model_ptr->fields[insn_model_name]; int len = strlen (insn_model_ptr->fields[insn_model_fields]); while (len > 0 && isspace(*insn_model_ptr->fields[insn_model_fields])) { len--; insn_model_ptr->fields[insn_model_fields]++; } if (max_model_fields_len < len) max_model_fields_len = len; for(model_ptr = models; model_ptr; model_ptr = model_ptr->next) { if (strcmp(name, model_ptr->printable_name) == 0) { /* Replace the name field with that of the global model, so that when we want to print it out, we can just compare pointers. */ insn_model_ptr->fields[insn_model_name] = model_ptr->printable_name; break; } } if (!model_ptr) error("%s:%d: machine model `%s' was not known about\n", file_entry->file_name, file_entry->line_nr, name); } /* insert it according to the order of the fields */ while (cur_insn != NULL && new_insn->fields->value >= cur_insn->fields->value) { ptr_to_cur_insn = &cur_insn->next; cur_insn = *ptr_to_cur_insn; } new_insn->next = cur_insn; *ptr_to_cur_insn = new_insn; table->nr_insn++; }
static table_entry * new_table_entry (open_table * file, table_entry_type type) { table_entry *entry; entry = ZALLOC (table_entry); entry->file = file->root; entry->line = current_line (file); entry->type = type; return entry; }
int main(int argc, char *argv[]) { START(argc, argv, "obj_fragmentation2"); if (argc < 3) UT_FATAL("usage: %s filename workload [seed]", argv[0]); const char *path = argv[1]; PMEMobjpool *pop = pmemobj_create(path, LAYOUT_NAME, DEFAULT_FILE_SIZE, S_IWUSR | S_IRUSR); if (pop == NULL) UT_FATAL("!pmemobj_create: %s", path); int w = atoi(argv[2]); if (argc > 3) seed = (unsigned)atoi(argv[3]); else seed = time(NULL); objects = ZALLOC(sizeof(uint64_t) * MAX_OBJECTS); UT_ASSERTne(objects, NULL); workloads[w - 1](pop); PMEMoid oid; size_t remaining = 0; size_t chunk = 100; /* calc at chunk level */ while (pmemobj_alloc(pop, &oid, chunk, 0, NULL, NULL) == 0) remaining += pmemobj_alloc_usable_size(oid) + 16; size_t allocated_sum = 0; oid = pmemobj_root(pop, 1); for (size_t n = 0; n < nobjects; ++n) { if (objects[n] == 0) continue; oid.off = objects[n]; allocated_sum += pmemobj_alloc_usable_size(oid) + 16; } size_t used = DEFAULT_FILE_SIZE - remaining; float frag = ((float)used / allocated_sum) - 1.f; UT_ASSERT(frag <= workloads_target[w - 1]); pmemobj_close(pop); FREE(objects); DONE(NULL); }
event_queue_create(void) { event_queue *new_event_queue = ZALLOC(event_queue); new_event_queue->processing = 0; new_event_queue->queue = NULL; new_event_queue->held = NULL; new_event_queue->held_end = &new_event_queue->held; /* both times are already zero */ return new_event_queue; }
void sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn) { struct module_list *modules = STATE_MODULES (sd); MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST); SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); SIM_ASSERT (STATE_MODULES (sd) != NULL); l->fn = fn; l->next = modules->uninstall_list; modules->uninstall_list = l; }
static void * hw_pal_create(const char *name, const device_unit *unit_address, const char *args) { /* create the descriptor */ hw_pal_device *hw_pal = ZALLOC(hw_pal_device); hw_pal->output.status = 1; hw_pal->output.buffer = '\0'; hw_pal->input.status = 0; hw_pal->input.buffer = '\0'; return hw_pal; }
insn_table * load_insn_table(const char *file_name, decode_table *decode_rules, filter *filters) { table *file = table_open(file_name, nr_insn_table_fields, nr_insn_model_table_fields); insn_table *table = ZALLOC(insn_table); table_entry *file_entry; table->opcode_rule = decode_rules; while ((file_entry = table_entry_read(file)) != NULL) { if (it_is("function", file_entry->fields[insn_flags]) || it_is("internal", file_entry->fields[insn_flags])) { insn_table_insert_function(table, file_entry); } else if (it_is("model", file_entry->fields[insn_flags])) { model_table_insert(table, file_entry); } else if (it_is("model-macro", file_entry->fields[insn_flags])) { model_table_insert_specific(table, file_entry, &model_macros, &last_model_macro); } else if (it_is("model-function", file_entry->fields[insn_flags])) { model_table_insert_specific(table, file_entry, &model_functions, &last_model_function); } else if (it_is("model-internal", file_entry->fields[insn_flags])) { model_table_insert_specific(table, file_entry, &model_internal, &last_model_internal); } else if (it_is("model-static", file_entry->fields[insn_flags])) { model_table_insert_specific(table, file_entry, &model_static, &last_model_static); } else if (it_is("model-data", file_entry->fields[insn_flags])) { model_table_insert_specific(table, file_entry, &model_data, &last_model_data); } else { insn_fields *fields; /* skip instructions that aren't relevant to the mode */ if (is_filtered_out(file_entry->fields[insn_flags], filters)) { fprintf(stderr, "Dropping %s - %s\n", file_entry->fields[insn_name], file_entry->fields[insn_flags]); } else { /* create/insert the new instruction */ fields = parse_insn_format(file_entry, file_entry->fields[insn_format]); insn_table_insert_insn(table, file_entry, fields); } } } return table; }
nitro_sockopt_t *nitro_sockopt_new() { nitro_sockopt_t *opt; ZALLOC(opt); /* defaults (otherwise, 0) */ opt->ident = malloc(SOCKET_IDENT_LENGTH); opt->ident_buf = nitro_counted_buffer_new(opt->ident, just_free, NULL); opt->close_linger = 1.0; opt->reconnect_interval = 0.2; /* seconds */ opt->max_message_size = 16 * NITRO_MB; opt->error_handler = nitro_error_log_handler; return opt; }
static void model_table_insert_specific(insn_table *table, table_entry *file_entry, insn **start_ptr, insn **end_ptr) { insn *ptr = ZALLOC(insn); ptr->file_entry = file_entry; if (*end_ptr) (*end_ptr)->next = ptr; else (*start_ptr) = ptr; (*end_ptr) = ptr; }
static device_instance * hw_eeprom_create_instance(device *me, const char *path, const char *args) { hw_eeprom_device *eeprom = device_data(me); hw_eeprom_instance *data = ZALLOC(hw_eeprom_instance); data->eeprom = eeprom; data->me = me; return device_create_instance_from(me, NULL, data, path, args, &hw_eeprom_instance_callbacks); }
/* * open_file_add -- add an open file to the lut */ static struct fd_lut * open_file_add(struct fd_lut *root, int fdnum, const char *fdfile) { if (root == NULL) { root = ZALLOC(sizeof (*root)); root->fdnum = fdnum; root->fdfile = STRDUP(fdfile); } else if (root->fdnum == fdnum) FATAL("duplicate fdnum: %d", fdnum); else if (root->fdnum < fdnum) root->left = open_file_add(root->left, fdnum, fdfile); else root->right = open_file_add(root->right, fdnum, fdfile); return root; }