static struct mod_t *mem_system_command_get_mod(struct list_t *token_list,
char *command_line)
{
struct mod_t *mod;
char *mod_name;
/* Get module name */
mem_system_command_expect(token_list, command_line);
mod_name = str_token_list_first(token_list);
/* Find module */
if (!strcasecmp(mod_name, "None"))
mod = NULL;
else
{
mod = mem_system_get_mod(mod_name);
if (!mod)
fatal("%s: %s: invalid module name.\n\t> %s",
__FUNCTION__, mod_name, command_line);
}
/* Return module */
str_token_list_shift(token_list);
return mod;
}
void evg_mem_config_parse_entry(struct config_t *config, char *section)
{
char *file_name;
char *module_name;
int compute_unit_id;
struct evg_compute_unit_t *compute_unit;
/* Get configuration file name */
file_name = config_get_file_name(config);
/* Allow these sections in case we quit before reading them. */
config_var_allow(config, section, "Module");
/* Read compute unit */
compute_unit_id = config_read_int(config, section, "ComputeUnit", -1);
if (compute_unit_id < 0)
fatal("%s: section [%s]: invalid or missing value for 'ComputeUnit'",
file_name, section);
/* Check compute unit boundaries */
if (compute_unit_id >= evg_gpu_num_compute_units)
{
warning("%s: section [%s] ignored, referring to Evergreen compute unit %d.\n"
"\tThis section refers to a compute unit that does not currently exist.\n"
"\tPlease review your Evergreen configuration file if this is not the\n"
"\tdesired behavior.\n",
file_name, section, compute_unit_id);
return;
}
/* Check that entry has not been assigned before */
compute_unit = evg_gpu->compute_units[compute_unit_id];
if (compute_unit->global_memory)
fatal("%s: section [%s]: entry from compute unit %d already assigned.\n"
"\tA different [Entry <name>] section in the memory configuration file has already\n"
"\tassigned an entry for this particular compute unit. Please review your\n"
"\tconfiguration file to avoid duplicates.\n",
file_name, section, compute_unit_id);
/* Read module */
module_name = config_read_string(config, section, "Module", NULL);
if (!module_name)
fatal("%s: section [%s]: variable 'Module' missing.\n"
"\tPlease run use '--mem-help' for more information on the\n"
"\tconfiguration file format, or consult the Multi2Sim Guide.\n",
file_name, section);
/* Assign module */
compute_unit->global_memory = mem_system_get_mod(module_name);
if (!compute_unit->global_memory)
fatal("%s: section [%s]: '%s' is not a valid module name.\n"
"\tThe given module name must match a module declared in a section\n"
"\t[Module <name>] in the memory configuration file.\n",
file_name, section, module_name);
/* Add modules to list of memory entries */
linked_list_add(evg_emu_arch->mem_entry_mod_list, compute_unit->global_memory);
/* Debug */
mem_debug("\tEvergreen compute unit %d\n", compute_unit_id);
mem_debug("\t\tEntry -> %s\n", compute_unit->global_memory->name);
mem_debug("\n");
}
static int x86_acc_func_accDTW (struct x86_ctx_t *ctx)
{
struct x86_regs_t *regs = ctx->regs;
struct mem_t *mem = ctx->mem;
int core;
int thread;
unsigned int args_ptr;
//int x;
struct arglist func_args;
/* Read arguments */
args_ptr = regs->ecx;
/* Get function info */
mem_read(mem, args_ptr, sizeof(arglist), &func_args);
printf("\t\t**sample1 = %p (%p)\n", func_args.sample1, &(func_args.sample1[0][0]));
printf("\t\tlength1 = %u (%p)\n", func_args.length1, &func_args.length1);
printf("\t\t**sample2 = %p (%p)\n", func_args.sample2, &(func_args.sample2[0][0]));
printf("\t\tlength2 = %u (%p)\n", func_args.length2, &func_args.length2);
printf("\t\ti = %u (%p)\n", func_args.i, &func_args.i);
printf("\t\tj = %u (%p)\n", func_args.j, &func_args.j);
printf("\t\t*table = %p (%p)\n", func_args.table, &(func_args.table[0]));
/***********************************************/
#define L2ONLY
#define WITHACC
#ifdef L2ONLY
printf ("Cache Behavior Simulation\n");
char * mod_name = "mod-l2-0";
X86_THREAD.data_mod = mem_system_get_mod (mod_name);
#endif
#ifdef WITHACC
struct linked_list_t *sq = X86_THREAD.sq;
struct linked_list_t *lq = X86_THREAD.lq;
struct x86_uop_t *store;
struct x86_uop_t *load;
int quant = x86_cpu_issue_width;
unsigned int count1, count2;
for (count1 = 0; count1 < 124; count1 ++)
{
for(count2 = 0; count2 < 124; count2++)
{
linked_list_head(sq);
while (!linked_list_is_end(sq)&& quant )
{
store = linked_list_get(sq);
printf("\n\n$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n\n");
printf("physical addr @ store: %d\n",store->phy_addr);
assert(store->uinst->opcode == x86_uinst_store);
if (!store->ready && !x86_reg_file_ready(store))
{
linked_list_next(sq);
continue;
}
store->ready = 1;
printf ("data module kind: %d\n",X86_THREAD.data_mod->kind);
printf ("data module level: %d\n",X86_THREAD.data_mod->level);
printf ("data module name: %s\n",X86_THREAD.data_mod->name);
printf ("data module cache name: %s\n",X86_THREAD.data_mod->cache->name);
if (!mod_can_access(X86_THREAD.data_mod, store->phy_addr))
{
linked_list_next(sq);
continue;
}
int i = 3;
while (i--)
{
printf("Store Debug Point 6\n");
mod_access(X86_THREAD.data_mod, mod_access_store,
store->phy_addr, NULL, X86_CORE.event_queue, store);
}
quant--;
// MMU statistics
if (*mmu_report_file_name)
mmu_access_page(store->phy_addr, mmu_access_write);
}
quant = x86_cpu_issue_width;
//printf("Load Simulation ... \n");
linked_list_head(lq);
while (!linked_list_is_end(lq)&& quant )
{
load = linked_list_get(lq);
printf ("physical add @ load: %d\n",load->phy_addr);
assert(store->uinst->opcode == x86_uinst_store);
load->ready = 1;
if (!load->ready && !x86_reg_file_ready(load))
{
printf("load debug point 1\n");
linked_list_next(sq);
continue;
}
load->ready = 1;
//printf ("physical add: %d\n",load->phy_addr);
if (!mod_can_access(X86_THREAD.data_mod, store->phy_addr))
{
printf("load debug point 2\n");
linked_list_next(lq);
continue;
}
int j = 1;
while (j--)
{
printf("load debug point 3\n");
mod_access(X86_THREAD.data_mod, mod_access_load,
load->phy_addr, NULL, X86_CORE.event_queue, load);
}
quant--;
//printf("load debug point 4: quant = %d\n", quant);
// MMU statistics
if (*mmu_report_file_name)
mmu_access_page(load->phy_addr, mmu_access_read);
// Trace
x86_trace("x86.inst id=%lld core=%d stg=\"i\"\n",
load->id_in_core, load->core);
}
}
}
#endif
#ifdef L2ONLY
mod_name = "mod-dl1-0";
X86_THREAD.data_mod = mem_system_get_mod (mod_name);
#endif
/***********************************************/
int ret = DTWdistance(func_args.sample1, func_args.length1, func_args.sample2,
func_args.length2, func_args.i, func_args.j, func_args.table);
return ret;
}
void x86_mem_config_parse_entry(struct config_t *config, char *section)
{
char *file_name;
int core;
int thread;
int unified_present;
int data_inst_present;
char *data_module_name;
char *inst_module_name;
/* Get configuration file name */
file_name = config_get_file_name(config);
/* Allow these sections in case we quit before reading them. */
config_var_allow(config, section, "DataModule");
config_var_allow(config, section, "InstModule");
config_var_allow(config, section, "Module");
/* Check right presence of sections */
unified_present = config_var_exists(config, section, "Module");
data_inst_present = config_var_exists(config, section, "DataModule") &&
config_var_exists(config, section, "InstModule");
if (!(unified_present ^ data_inst_present))
fatal("%s: section [%s]: invalid combination of modules.\n"
"\tAn x86 entry to the memory hierarchy needs to specify either a unified\n"
"\tentry for data and instructions (variable 'Module'), or two separate\n"
"\tentries for data and instructions (variables 'DataModule' and 'InstModule'),\n"
"\tbut not both.\n",
file_name, section);
/* Read core */
core = config_read_int(config, section, "Core", -1);
if (core < 0)
fatal("%s: section [%s]: invalid or missing value for 'Core'",
file_name, section);
/* Read thread */
thread = config_read_int(config, section, "Thread", -1);
if (thread < 0)
fatal("%s: section [%s]: invalid or missing value for 'Thread'",
file_name, section);
/* Check bounds */
if (core >= x86_cpu_num_cores || thread >= x86_cpu_num_threads)
{
warning("%s: section [%s] ignored, referring to x86 Core %d, Thread %d.\n"
"\tThis section refers to a core or thread that does not currently exists.\n"
"\tPlease review your x86 configuration file if this behavior is not desired.\n",
file_name, section, core, thread);
return;
}
/* Check that entry has not been assigned before */
if (X86_THREAD.data_mod || X86_THREAD.inst_mod)
{
assert(X86_THREAD.data_mod && X86_THREAD.inst_mod);
fatal("%s: section [%s]: entry from Core %d, Thread %d already assigned.\n"
"\tA different [Entry <name>] section in the memory configuration file has already\n"
"\tassigned an entry for this particular core and thread. Please review your\n"
"\tconfiguration file to avoid duplicates.\n",
file_name, section, core, thread);
}
/* Read modules */
if (data_inst_present)
{
data_module_name = config_read_string(config, section, "DataModule", NULL);
inst_module_name = config_read_string(config, section, "InstModule", NULL);
assert(data_module_name);
assert(inst_module_name);
}
else
{
data_module_name = inst_module_name =
config_read_string(config, section, "Module", NULL);
assert(data_module_name);
}
/* Assign data module */
X86_THREAD.data_mod = mem_system_get_mod(data_module_name);
if (!X86_THREAD.data_mod)
fatal("%s: section [%s]: '%s' is not a valid module name.\n"
"\tThe given module name must match a module declared in a section\n"
"\t[Module <name>] in the memory configuration file.\n",
file_name, section, data_module_name);
/* Assign instruction module */
X86_THREAD.inst_mod = mem_system_get_mod(inst_module_name);
if (!X86_THREAD.inst_mod)
fatal("%s: section [%s]: '%s' is not a valid module name.\n"
"\tThe given module name must match a module declared in a section\n"
"\t[Module <name>] in the memory configuration file.\n",
file_name, section, inst_module_name);
/* Add modules to entry list */
linked_list_add(x86_emu_arch->mem_entry_mod_list, X86_THREAD.data_mod);
if (X86_THREAD.data_mod != X86_THREAD.inst_mod)
linked_list_add(x86_emu_arch->mem_entry_mod_list, X86_THREAD.inst_mod);
/* Debug */
mem_debug("\tx86 Core %d, Thread %d\n", core, thread);
mem_debug("\t\tEntry for instructions -> %s\n", X86_THREAD.inst_mod->name);
mem_debug("\t\tEntry for data -> %s\n", X86_THREAD.data_mod->name);
mem_debug("\n");
}
void FrmGpuMemConfigParseEntry(Timing *self, struct config_t *config, char *section)
{
char *file_name;
char *module_name;
int sm_id;
FrmSM *sm;
/* Get configuration file name */
file_name = config_get_file_name(config);
/* Allow these sections in case we quit before reading them. */
config_var_allow(config, section, "Module");
/* Read SM */
sm_id = config_read_int(config, section, "SM", -1);
if (sm_id < 0)
fatal("%s: section [%s]: invalid or missing value for 'SM'",
file_name, section);
/* Check SM boundaries */
if (sm_id >= frm_gpu_num_sms)
{
warning("%s: section [%s] ignored, referring to Fermi SM[%d].\n"
"\tThis section refers to a SM that does not currently exist.\n"
"\tPlease review your Fermi configuration file if this is not the\n"
"\tdesired behavior.\n",
file_name, section, sm_id);
return;
}
/* Check that entry has not been assigned before */
sm = frm_gpu->sms[sm_id];
if (sm->global_memory)
fatal("%s: section [%s]: entry from SM[%d] already assigned.\n"
"\tA different [Entry <name>] section in the memory configuration file has already\n"
"\tassigned an entry for this particular SM. Please review your\n"
"\tconfiguration file to avoid duplicates.\n",
file_name, section, sm_id);
/* Read module */
module_name = config_read_string(config, section, "Module", NULL);
if (!module_name)
fatal("%s: section [%s]: variable 'Module' missing.\n"
"\tPlease run use '--mem-help' for more information on the\n"
"\tconfiguration file format, or consult the Multi2Sim Guide.\n",
file_name, section);
/* Assign module */
sm->global_memory = mem_system_get_mod(module_name);
if (!sm->global_memory)
fatal("%s: section [%s]: '%s' is not a valid module name.\n"
"\tThe given module name must match a module declared in a section\n"
"\t[Module <name>] in the memory configuration file.\n",
file_name, section, module_name);
/* Add modules to list of memory entries */
linked_list_add(arch_fermi->mem_entry_mod_list,
sm->global_memory);
/* Debug */
mem_debug("\tFermi SM[%d]\n", sm_id);
mem_debug("\t\tEntry -> %s\n", sm->global_memory->name);
mem_debug("\n");
}
void SIGpuMemConfigParseEntry(Timing *self, struct config_t *config, char *section)
{
char *file_name;
char *vector_module_name;
char *scalar_module_name;
int unified_present;
int separate_present;
int compute_unit_id;
struct si_compute_unit_t *compute_unit;
/* Get configuration file name */
file_name = config_get_file_name(config);
/* Allow these sections in case we quit before reading them. */
config_var_allow(config, section, "DataModule");
config_var_allow(config, section, "ConstantDataModule");
config_var_allow(config, section, "Module");
unified_present = config_var_exists(config, section, "Module");
separate_present = config_var_exists(config, section,
"DataModule") && config_var_exists(config, section,
"ConstantDataModule");
if (!unified_present && !separate_present)
{
fatal(
"%s: section [%s]: variable 'Module' missing.\n"
"\tPlease run use '--mem-help' for more information on the\n"
"\tconfiguration file format, or consult the Multi2Sim Guide.\n",
file_name, section);
}
if (!(unified_present ^ separate_present))
{
fatal(
"%s: section [%s]: invalid combination of modules.\n"
"\tA Southern Islands entry to the memory hierarchy needs to specify\n"
"\teither a unified entry for vector and scalar caches (variable \n"
"\t'Module'), or two separate entries for data and scalar (constant)\n"
"\tdata (variables 'DataModule' and 'ConstantDataModule'), but not\n"
"\tboth.\n",
file_name, section);
}
/* Read compute unit */
compute_unit_id = config_read_int(config, section, "ComputeUnit", -1);
if (compute_unit_id < 0)
{
fatal("%s: section [%s]: invalid or missing value for "
"'ComputeUnit'", file_name, section);
}
/* Check compute unit boundaries */
if (compute_unit_id >= si_gpu_num_compute_units)
{
warning(
"%s: section [%s] ignored, referring to Southern Islands \n"
"\tcompute unit %d. This section refers to a compute unit that\n"
"\tdoes not currently exist. Please review your Southern Islands\n"
"\tconfiguration file if this is not the desired behavior.\n",
file_name, section, compute_unit_id);
return;
}
/* Check that entry has not been assigned before */
compute_unit = si_gpu->compute_units[compute_unit_id];
if (compute_unit->vector_cache)
{
fatal(
"%s: section [%s]: entry from compute unit %d already assigned.\n"
"\tA different [Entry <name>] section in the memory configuration\n"
"\tfile has already assigned an entry for this particular compute \n"
"\tunit. Please review your tconfiguration file to avoid duplicates.\n",
file_name, section, compute_unit_id);
}
/* Read modules */
if (separate_present)
{
vector_module_name = config_read_string(config, section,
"DataModule", NULL);
scalar_module_name = config_read_string(config, section,
"ConstantDataModule", NULL);
}
else
{
vector_module_name = scalar_module_name =
config_read_string(config, section, "Module", NULL);
}
assert(vector_module_name);
assert(scalar_module_name);
/* Assign modules */
compute_unit->vector_cache = mem_system_get_mod(vector_module_name);
if (!compute_unit->vector_cache)
{
fatal(
"%s: section [%s]: '%s' is not a valid module name.\n"
"\tThe given module name must match a module declared in a section\n"
"\t[Module <name>] in the memory configuration file.\n",
file_name, section, vector_module_name);
}
compute_unit->scalar_cache = mem_system_get_mod(scalar_module_name);
if (!compute_unit->scalar_cache)
{
fatal(
"%s: section [%s]: '%s' is not a valid module name.\n"
"\tThe given module name must match a module declared in a section\n"
"\t[Module <name>] in the memory configuration file.\n",
file_name, section, scalar_module_name);
}
/* Add modules to list of memory entries */
linked_list_add(arch_southern_islands->mem_entry_mod_list,
compute_unit->vector_cache);
linked_list_add(arch_southern_islands->mem_entry_mod_list,
compute_unit->scalar_cache);
/* Debug */
mem_debug("\tSouthern Islands compute unit %d\n", compute_unit_id);
mem_debug("\t\tEntry for vector mem -> %s\n",
compute_unit->vector_cache->name);
mem_debug("\t\tEntry for scalar mem -> %s\n",
compute_unit->scalar_cache->name);
mem_debug("\n");
}
