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;
}
