int lsmod_hash_cb (uint32_t nodeid, const char *json_str, zhash_t *mods) { flux_modlist_t modlist; mod_t *m; int i, len; const char *name, *digest; int size, idle; int rc = -1; if (!(modlist = flux_lsmod_json_decode (json_str))) goto done; if ((len = flux_modlist_count (modlist)) == -1) goto done; for (i = 0; i < len; i++) { if (flux_modlist_get (modlist, i, &name, &size, &digest, &idle) < 0) goto done; if ((m = zhash_lookup (mods, digest))) { if (idle < m->idle) m->idle = idle; if (!nodeset_add_rank (m->nodeset, nodeid)) oom (); } else { m = mod_create (name, size, digest, idle, nodeid); zhash_update (mods, digest, m); zhash_freefn (mods, digest, (zhash_free_fn *)mod_destroy); } } rc = 0; done: if (modlist) flux_modlist_destroy (modlist); return rc; }
struct evg_compute_unit_t *evg_compute_unit_create() { struct evg_compute_unit_t *compute_unit; char buf[MAX_STRING_SIZE]; /* Initialize */ compute_unit = xcalloc(1, sizeof(struct evg_compute_unit_t)); compute_unit->wavefront_pool = linked_list_create(); /* Local memory */ snprintf(buf, sizeof buf, "LocalMemory[%d]", compute_unit->id); compute_unit->local_memory = mod_create(buf, mod_kind_local_memory, evg_gpu_local_mem_num_ports, evg_gpu_local_mem_block_size, evg_gpu_local_mem_latency); /* Initialize CF Engine */ compute_unit->cf_engine.complete_queue = linked_list_create(); compute_unit->cf_engine.fetch_buffer = xcalloc(evg_gpu_max_wavefronts_per_compute_unit, sizeof(void *)); compute_unit->cf_engine.inst_buffer = xcalloc(evg_gpu_max_wavefronts_per_compute_unit, sizeof(void *)); /* Initialize ALU Engine */ compute_unit->alu_engine.pending_queue = linked_list_create(); compute_unit->alu_engine.finished_queue = linked_list_create(); compute_unit->alu_engine.fetch_queue = linked_list_create(); compute_unit->alu_engine.event_queue = heap_create(10); /* Initialize TEX Engine */ compute_unit->tex_engine.pending_queue = linked_list_create(); compute_unit->tex_engine.finished_queue = linked_list_create(); compute_unit->tex_engine.fetch_queue = linked_list_create(); compute_unit->tex_engine.load_queue = linked_list_create(); /* Return */ compute_unit->work_groups = xcalloc(evg_gpu_max_work_groups_per_compute_unit, sizeof(void *)); return compute_unit; }
mod_handle_t value_create(float value) { mod_handle_t handle = mod_create(value_fillblock, value_ontrigger, sizeof(float)); float* data = mod_data(handle); *data = value; return handle; }
static mod_handle_t cos_create(float freq, mod_handle_t freq_in) { if (!cos_table_ready) { create_cos_table(); } mod_handle_t handle = mod_create(cos_fillblock, cos_ontrigger, sizeof(cos_data_t)); cos_data_t* data = (cos_data_t*) mod_data(handle); if (freq > 0) { data->freq = freq; data->freq_in = -1; } else { data->freq_in = freq_in; data->freq = 0; } data->phase = 0; return handle; }
struct frm_sm_t *frm_sm_create() { struct frm_sm_t *sm; char buf[MAX_STRING_SIZE]; int i; /* Initialize */ sm = xcalloc(1, sizeof(struct frm_sm_t)); /* Local memory */ snprintf(buf, sizeof buf, "LDS[%d]", sm->id); sm->lds_module = mod_create(buf, mod_kind_local_memory, frm_gpu_lds_num_ports, frm_gpu_lds_block_size, frm_gpu_lds_latency); /* Hardware structures */ sm->num_warp_inst_queues = 2; sm->warp_inst_queues = xcalloc(sm->num_warp_inst_queues, sizeof(struct list_t *)); sm->fetch_buffers = xcalloc(sm->num_warp_inst_queues, sizeof(struct list_t *)); sm->num_simd_units = 2; sm->simd_units = xcalloc(sm->num_simd_units, sizeof(struct frm_simd_t*)); sm->branch_unit.issue_buffer = list_create(); sm->branch_unit.decode_buffer = list_create(); sm->branch_unit.read_buffer = list_create(); sm->branch_unit.exec_buffer = list_create(); sm->branch_unit.write_buffer = list_create(); sm->branch_unit.sm = sm; sm->vector_mem_unit.issue_buffer = list_create(); sm->vector_mem_unit.decode_buffer = list_create(); sm->vector_mem_unit.read_buffer = list_create(); sm->vector_mem_unit.mem_buffer = list_create(); sm->vector_mem_unit.write_buffer = list_create(); sm->vector_mem_unit.sm = sm; sm->lds_unit.issue_buffer = list_create(); sm->lds_unit.decode_buffer = list_create(); sm->lds_unit.read_buffer = list_create(); sm->lds_unit.mem_buffer = list_create(); sm->lds_unit.write_buffer = list_create(); sm->lds_unit.sm = sm; /* Allocate and initialize instruction buffers */ for (i = 0; i < sm->num_warp_inst_queues; i++) { sm->warp_inst_queues[i] = frm_warp_inst_queue_create(); sm->warp_inst_queues[i]->sm = sm; } for (i = 0; i < sm->num_warp_inst_queues; i++) sm->fetch_buffers[i] = list_create(); /* Allocate SIMD structures */ assert(sm->num_warp_inst_queues == sm->num_simd_units); for (i = 0; i < sm->num_simd_units; i++) { sm->simd_units[i] = xcalloc(1, sizeof(struct frm_simd_t)); sm->simd_units[i]->id_in_sm = i; sm->simd_units[i]->sm = sm; sm->simd_units[i]->warp_inst_queue = sm->warp_inst_queues[i]; sm->simd_units[i]->issue_buffer = list_create(); sm->simd_units[i]->decode_buffer = list_create(); sm->simd_units[i]->exec_buffer = list_create(); sm->simd_units[i]->subwarp_inst_queue = xcalloc(1, sizeof(struct frm_subwarp_inst_queue_t)); sm->simd_units[i]->sm = sm; sm->simd_units[i]->wkg_util = xcalloc(1, sizeof(struct frm_util_t)); sm->simd_units[i]->wvf_util = xcalloc(1, sizeof(struct frm_util_t)); sm->simd_units[i]->rdy_util = xcalloc(1, sizeof(struct frm_util_t)); sm->simd_units[i]->occ_util = xcalloc(1, sizeof(struct frm_util_t)); sm->simd_units[i]->wki_util = xcalloc(1, sizeof(struct frm_util_t)); sm->simd_units[i]->act_util = xcalloc(1, sizeof(struct frm_util_t)); sm->simd_units[i]->tot_util = xcalloc(1, sizeof(struct frm_util_t)); } sm->thread_blocks = xcalloc(frm_gpu_max_thread_blocks_per_sm, sizeof(void *)); /* Return */ return sm; }
module_t* mod_load(const char* path_name) { module_t* mod = mod_create(); int* api_version; int* type; int err = 0; boolean_t flag = B_FALSE; assert(mod != NULL); logmsg(LOG_INFO, "Loading module %s ...", path_name); err = plat_mod_open(&mod->mod_library, path_name); if(err != 0) { logmsg(LOG_WARN, "Failed loading, platform-specific error code: %d", err); logerror(); goto fail; } strcpy(mod->mod_path, path_name); /*Load module api version and name*/ MOD_LOAD_SYMBOL(api_version, mod, "mod_api_version", flag); MOD_LOAD_SYMBOL(type, mod, "mod_type", flag); MOD_LOAD_SYMBOL(mod->mod_name, mod, "mod_name", flag); if(flag) goto fail; if(*type != mod_type) { logmsg(LOG_INFO, "Ignoring module - wrong type %d", *type); goto fail; } if(*api_version != MOD_API_VERSION) { logmsg(LOG_WARN, "Wrong api version %d", *api_version); goto fail; } if(mod_search(mod->mod_name) != NULL) { logmsg(LOG_WARN, "Module %s already exists", mod->mod_name); goto fail; } MOD_LOAD_SYMBOL(mod->mod_config, mod, "mod_config", flag); MOD_LOAD_SYMBOL(mod->mod_unconfig, mod, "mod_unconfig", flag); /*Call helper*/ mod->mod_status = MOD_UNCONFIGURED; if(mod->mod_config(mod) != MOD_OK) { logmsg(LOG_INFO, "Failed to configure module %s (path: %s)", mod->mod_name, path_name); goto fail; } logmsg(LOG_INFO, "Loaded module %s (path: %s)", mod->mod_name, path_name); mod->mod_status = MOD_READY; mod_add(mod); return mod; fail: if(err != 0) plat_mod_close(&mod->mod_library); logmsg(LOG_WARN, "Failed to load module %s!", path_name); mod_destroy(mod); return NULL; }
struct si_compute_unit_t *si_compute_unit_create() { struct si_compute_unit_t *compute_unit; char buf[MAX_STRING_SIZE]; int i; /* Initialize */ compute_unit = xcalloc(1, sizeof(struct si_compute_unit_t)); /* Local memory */ snprintf(buf, sizeof buf, "LDS[%d]", compute_unit->id); compute_unit->lds_module = mod_create(buf, mod_kind_local_memory, si_gpu_lds_num_ports, si_gpu_lds_block_size, si_gpu_lds_latency); /* Hardware structures */ compute_unit->num_wavefront_pools = si_gpu_num_wavefront_pools; compute_unit->wavefront_pools = xcalloc( compute_unit->num_wavefront_pools, sizeof(struct si_wavefront_pool_t*)); compute_unit->fetch_buffers = xcalloc(compute_unit->num_wavefront_pools, sizeof(struct list_t*)); compute_unit->simd_units = xcalloc(compute_unit->num_wavefront_pools, sizeof(struct si_simd_t*)); compute_unit->scalar_unit.issue_buffer = list_create(); compute_unit->scalar_unit.decode_buffer = list_create(); compute_unit->scalar_unit.read_buffer = list_create(); compute_unit->scalar_unit.exec_buffer = list_create(); compute_unit->scalar_unit.write_buffer = list_create(); compute_unit->scalar_unit.inflight_buffer = list_create(); compute_unit->scalar_unit.compute_unit = compute_unit; compute_unit->branch_unit.issue_buffer = list_create(); compute_unit->branch_unit.decode_buffer = list_create(); compute_unit->branch_unit.read_buffer = list_create(); compute_unit->branch_unit.exec_buffer = list_create(); compute_unit->branch_unit.write_buffer = list_create(); compute_unit->branch_unit.compute_unit = compute_unit; compute_unit->vector_mem_unit.issue_buffer = list_create(); compute_unit->vector_mem_unit.decode_buffer = list_create(); compute_unit->vector_mem_unit.read_buffer = list_create(); compute_unit->vector_mem_unit.mem_buffer = list_create(); compute_unit->vector_mem_unit.write_buffer = list_create(); compute_unit->vector_mem_unit.compute_unit = compute_unit; compute_unit->lds_unit.issue_buffer = list_create(); compute_unit->lds_unit.decode_buffer = list_create(); compute_unit->lds_unit.read_buffer = list_create(); compute_unit->lds_unit.mem_buffer = list_create(); compute_unit->lds_unit.write_buffer = list_create(); compute_unit->lds_unit.compute_unit = compute_unit; for (i = 0; i < compute_unit->num_wavefront_pools; i++) { /* Allocate and initialize instruction buffers */ compute_unit->wavefront_pools[i] = si_wavefront_pool_create(); compute_unit->wavefront_pools[i]->id = i; compute_unit->wavefront_pools[i]->compute_unit = compute_unit; compute_unit->fetch_buffers[i] = list_create(); /* Allocate SIMD structures */ compute_unit->simd_units[i] = xcalloc(1, sizeof(struct si_simd_t)); compute_unit->simd_units[i]->id_in_compute_unit = i; compute_unit->simd_units[i]->compute_unit = compute_unit; compute_unit->simd_units[i]->wavefront_pool = compute_unit->wavefront_pools[i]; compute_unit->simd_units[i]->issue_buffer = list_create(); compute_unit->simd_units[i]->decode_buffer = list_create(); compute_unit->simd_units[i]->exec_buffer = list_create(); compute_unit->simd_units[i]->subwavefront_pool = xcalloc(1, sizeof(struct si_subwavefront_pool_t)); compute_unit->simd_units[i]->compute_unit = compute_unit; compute_unit->simd_units[i]->wkg_util = xcalloc(1, sizeof(struct si_util_t)); compute_unit->simd_units[i]->wvf_util = xcalloc(1, sizeof(struct si_util_t)); compute_unit->simd_units[i]->rdy_util = xcalloc(1, sizeof(struct si_util_t)); compute_unit->simd_units[i]->occ_util = xcalloc(1, sizeof(struct si_util_t)); compute_unit->simd_units[i]->wki_util = xcalloc(1, sizeof(struct si_util_t)); compute_unit->simd_units[i]->act_util = xcalloc(1, sizeof(struct si_util_t)); compute_unit->simd_units[i]->tot_util = xcalloc(1, sizeof(struct si_util_t)); } compute_unit->work_groups = xcalloc(si_gpu_max_work_groups_per_wavefront_pool * si_gpu_num_wavefront_pools, sizeof(void *)); /* Return */ return compute_unit; }