void vi_si_compute_unit_write_checkpoint(struct vi_si_compute_unit_t *compute_unit, FILE *f) { int num_work_groups; int num_insts; int count; char *work_group_name; char *inst_name; struct vi_si_work_group_t *work_group; struct vi_si_inst_t *inst; /* Write number of work-groups */ num_work_groups = hash_table_count(compute_unit->work_group_table); count = fwrite(&num_work_groups, 1, 4, f); if (count != 4) fatal("%s: cannot write checkpoint", __FUNCTION__); /* Write work-groups */ HASH_TABLE_FOR_EACH(compute_unit->work_group_table, work_group_name, work_group) vi_si_work_group_write_checkpoint(work_group, f); /* Write number of instructions */ num_insts = hash_table_count(compute_unit->inst_table); count = fwrite(&num_insts, 1, 4, f); if (count != 4) fatal("%s: cannot write checkpoint", __FUNCTION__); /* Write instructions */ HASH_TABLE_FOR_EACH(compute_unit->inst_table, inst_name, inst) vi_si_inst_write_checkpoint(inst, f); }
void vi_x86_core_write_checkpoint(struct vi_x86_core_t *core, FILE *f) { struct vi_x86_context_t *context; struct vi_x86_inst_t *inst; int num_contexts; int num_insts; int count; char *context_name; char *inst_name; /* Number of contexts */ num_contexts = hash_table_count(core->context_table); count = fwrite(&num_contexts, 1, 4, f); if (count != 4) fatal("%s: cannot write checkpoint", __FUNCTION__); /* Contexts */ HASH_TABLE_FOR_EACH(core->context_table, context_name, context) str_write_to_file(f, context_name); /* Number of instructions */ num_insts = hash_table_count(core->inst_table); count = fwrite(&num_insts, 1, 4, f); if (count != 4) fatal("%s: cannot write checkpoint", __FUNCTION__); /* Instructions */ HASH_TABLE_FOR_EACH(core->inst_table, inst_name, inst) vi_x86_inst_write_checkpoint(inst, f); }
void vi_evg_compute_unit_read_checkpoint(struct vi_evg_compute_unit_t *compute_unit, FILE *f) { char *work_group_name; char *inst_name; struct vi_evg_work_group_t *work_group; struct vi_evg_inst_t *inst; int num_work_groups; int num_insts; int count; int i; /* Empty work-group list */ HASH_TABLE_FOR_EACH(compute_unit->work_group_table, work_group_name, work_group) vi_evg_work_group_free(work_group); hash_table_clear(compute_unit->work_group_table); /* Empty instruction list */ HASH_TABLE_FOR_EACH(compute_unit->inst_table, inst_name, inst) vi_evg_inst_free(inst); hash_table_clear(compute_unit->inst_table); /* Read number of work-groups */ count = fread(&num_work_groups, 1, 4, f); if (count != 4) fatal("%s: cannot read checkpoint", __FUNCTION__); /* Read work-groups */ for (i = 0; i < num_work_groups; i++) { work_group = vi_evg_work_group_create(NULL, 0, 0, 0, 0, 0); vi_evg_work_group_read_checkpoint(work_group, f); if (!hash_table_insert(compute_unit->work_group_table, work_group->name, work_group)) panic("%s: invalid work-group in checkpoint", __FUNCTION__); } /* Read number of instructions */ count = fread(&num_insts, 1, 4, f); if (count != 4) fatal("%s: cannot read checkpoint", __FUNCTION__); /* Read instructions */ for (i = 0; i < num_insts; i++) { inst = vi_evg_inst_create(NULL, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL); vi_evg_inst_read_checkpoint(inst, f); if (!hash_table_insert(compute_unit->inst_table, inst->name, inst)) panic("%s: invalid instruction in checkpoint", __FUNCTION__); } }
void Llvm2siSymbolTableDestroy(Llvm2siSymbolTable *self) { char *key; Llvm2siSymbol *symbol; /* Free symbol hash table */ HASH_TABLE_FOR_EACH(self->table, key, symbol) delete(symbol); hash_table_free(self->table); }
void frm_symbol_table_done(void) { struct frm_symbol_t *symbol; char *name; /* Free all symbols */ HASH_TABLE_FOR_EACH(frm_symbol_table, name, symbol) frm_symbol_free(symbol); /* Free symbol table */ hash_table_free(frm_symbol_table); }
void vi_si_compute_unit_free(struct vi_si_compute_unit_t *compute_unit) { struct vi_si_work_group_t *work_group; struct vi_si_inst_t *inst; char *work_group_name; char *inst_name; /* Free work-groups */ HASH_TABLE_FOR_EACH(compute_unit->work_group_table, work_group_name, work_group) vi_si_work_group_free(work_group); hash_table_free(compute_unit->work_group_table); /* Free instructions */ HASH_TABLE_FOR_EACH(compute_unit->inst_table, inst_name, inst) vi_si_inst_free(inst); hash_table_free(compute_unit->inst_table); /* Free compute unit */ free(compute_unit->name); free(compute_unit); }
void Llvm2siSymbolTableDump(Object *self, FILE *f) { Llvm2siSymbolTable *symbol_table; Llvm2siSymbol *symbol; char *key; symbol_table = asLlvm2siSymbolTable(self); fprintf(f, "Symbol table:\n"); HASH_TABLE_FOR_EACH(symbol_table->table, key, symbol) Llvm2siSymbolDump(asObject(symbol), f); fprintf(f, "\n"); }
void vi_x86_core_read_checkpoint(struct vi_x86_core_t *core, FILE *f) { struct vi_x86_inst_t *inst; int num_contexts; int num_insts; int count; int i; char context_name[MAX_STRING_SIZE]; char *inst_name; /* Clear table of contexts. * Elements are VI_X86_CONTEXT_EMPTY, no need to free. */ hash_table_clear(core->context_table); /* Create table of instructions */ HASH_TABLE_FOR_EACH(core->inst_table, inst_name, inst) vi_x86_inst_free(inst); hash_table_clear(core->inst_table); /* Number of contexts */ count = fread(&num_contexts, 1, 4, f); if (count != 4) fatal("%s: cannot read checkpoint", __FUNCTION__); /* Read contexts */ for (i = 0; i < num_contexts; i++) { str_read_from_file(f, context_name, sizeof context_name); if (!hash_table_insert(core->context_table, context_name, VI_X86_CONTEXT_EMPTY)) panic("%s: invalid context", __FUNCTION__); } /* Number of instructions */ count = fread(&num_insts, 1, 4, f); if (count != 4) fatal("%s: cannot read checkpoint", __FUNCTION__); /* Read instructions */ for (i = 0; i < num_insts; i++) { inst = vi_x86_inst_create(0, NULL, NULL, NULL, 0, 0); vi_x86_inst_read_checkpoint(inst, f); if (!hash_table_insert(core->inst_table, inst->name, inst)) panic("%s: invalid instruction", __FUNCTION__); } }
void vi_x86_core_free(struct vi_x86_core_t *core) { struct vi_x86_inst_t *inst; char *inst_name; /* Free contexts (elements are VI_X86_CONTEXT_EMPTY). */ hash_table_free(core->context_table); /* Free instructions */ HASH_TABLE_FOR_EACH(core->inst_table, inst_name, inst) vi_x86_inst_free(inst); hash_table_free(core->inst_table); /* Free core */ str_free(core->name); free(core); }