void mod_mshr_record_dump()
{
for (int i = 0; i < list_count(mem_system->mod_list); i++)
{
struct mod_t *mod = list_get(mem_system->mod_list, i);
if (!mod->mshr_record)
continue;
fclose(mod->mshr_record->access_record_file);
/* Run the script - Load script */
FILE *script_file;
char cmd[MAX_PATH_SIZE];
char script_file_name[MAX_PATH_SIZE];
char plot_file_name[MAX_PATH_SIZE];
/* Create plot file */
snprintf(plot_file_name, MAX_PATH_SIZE, "%s_mshr_record.eps",
mod->name);
if (!file_can_open_for_write(plot_file_name))
{
fatal("%s: cannot write GPU occupancy calculation plot",
plot_file_name);
}
int err = 0;
/* Generate gnuplot script for Offered Bandwidth */
script_file = file_create_temp(script_file_name, MAX_PATH_SIZE);
fprintf(script_file, "set term postscript eps color solid\n");
fprintf(script_file, "set nokey\n");
fprintf(script_file, "set title 'MSHR entry occupation - store - module %s'\n",
mod->name);
fprintf(script_file, "set ylabel 'MSHR entries '\n");
fprintf(script_file, "set xlabel 'Time (cycles) '\n");
fprintf(script_file, "unset xrange \n");
fprintf(script_file, "unset yrange \n");
fprintf(script_file, "set xtics font \"Helvettica, 8\" "
"rotate by 45 offset -1,-1 \n");
fprintf(script_file, "set size 0.65, 0.5\n");
fprintf(script_file, "set grid ytics\n");
/* lt is the color, lw is width, pt is the shape, ps is */
fprintf(script_file, "plot '%s' w points lt 1 "
"lw 1 pt 2 ps 1 \n",mod->mshr_record->access_record_file_name);
fclose(script_file);
/* Plot */
sprintf(cmd, "gnuplot %s > %s", script_file_name, plot_file_name);
err = system(cmd);
if (err)
warning("could not execute gnuplot, when creating network results\n");
/* Remove temporary files */
unlink(mod->mshr_record->access_record_file_name);
unlink(script_file_name);
}
}
void mem_system_snapshot_dump(struct mem_system_snapshot_t * snapshot)
{
if (mem_snap_period == 0)
return;
// Last Load accesses
for (int i = 0; i < list_count(snapshot->mem_regions_loads) ; i++)
{
int * element_value = list_get(snapshot->mem_regions_loads, i);
fprintf(snapshot->snapshot_load, "%lld %d %d \n" ,
snapshot->last_snapshot * mem_snap_period,
i * snapshot->mem_snapshot_region_size, * element_value);
fprintf(snapshot->snapshot_load, "%lld %d %d \n" ,
snapshot->last_snapshot * mem_snap_period,
(i + 1) * snapshot->mem_snapshot_region_size, * element_value);
}
fprintf(snapshot->snapshot_load, "\n");
for (int i = 0; i < list_count(snapshot->mem_regions_loads); i++)
{
int * element_value = list_get(snapshot->mem_regions_loads, i);
fprintf(snapshot->snapshot_load, "%lld %d %d \n" ,
(snapshot->last_snapshot + 1) * mem_snap_period,
i * snapshot->mem_snapshot_region_size, * element_value);
fprintf(snapshot->snapshot_load, "%lld %d %d \n" ,
(snapshot->last_snapshot + 1) * mem_snap_period,
(i + 1) * snapshot->mem_snapshot_region_size, * element_value);
if ( snapshot->max_accesses < * element_value)
snapshot->max_accesses = * element_value;
* element_value = 0;
}
fprintf(snapshot->snapshot_load, "\n");
fclose(snapshot->snapshot_load);
// Last store Accesses
for (int i = 0; i < list_count(snapshot->mem_regions_stores) ; i++)
{
int * element_value = list_get(snapshot->mem_regions_stores, i);
fprintf(snapshot->snapshot_store, "%lld %d %d \n" ,
snapshot->last_snapshot * mem_snap_period,
i * snapshot->mem_snapshot_region_size, * element_value);
fprintf(snapshot->snapshot_store, "%lld %d %d \n" ,
snapshot->last_snapshot * mem_snap_period,
(i + 1) * snapshot->mem_snapshot_region_size, * element_value);
}
fprintf(snapshot->snapshot_store, "\n");
for (int i = 0; i < list_count(snapshot->mem_regions_stores); i++)
{
int * element_value = list_get(snapshot->mem_regions_stores, i);
fprintf(snapshot->snapshot_store, "%lld %d %d \n" ,
(snapshot->last_snapshot + 1) * mem_snap_period,
i * snapshot->mem_snapshot_region_size, * element_value);
fprintf(snapshot->snapshot_store, "%lld %d %d \n" ,
(snapshot->last_snapshot + 1) * mem_snap_period,
(i + 1) * snapshot->mem_snapshot_region_size, * element_value);
if ( snapshot->max_accesses < * element_value)
snapshot->max_accesses = * element_value;
* element_value = 0;
}
fprintf(snapshot->snapshot_store, "\n");
fclose(snapshot->snapshot_store);
/* Run the script - Load script */
FILE *load_script_file;
char cmd[MAX_PATH_SIZE];
char load_script_file_name[MAX_PATH_SIZE];
char plot_file_name[MAX_PATH_SIZE];
/* Create plot file */
for (int i = 0; i < 4; i++)
{
if (i < 2)
snprintf(plot_file_name, MAX_PATH_SIZE, "%d_%d_%dD_loads.ps",
mem_snap_period, snapshot->mem_snapshot_region_size,i+2);
else
snprintf(plot_file_name, MAX_PATH_SIZE, "%d_%d_%dD_stores.ps",
mem_snap_period, snapshot->mem_snapshot_region_size,i);
if (!file_can_open_for_write(plot_file_name))
{
fatal("%s: cannot write GPU occupancy calculation plot",
plot_file_name);
}
load_script_file = file_create_temp(load_script_file_name,
MAX_PATH_SIZE);
fprintf(load_script_file, "unset origin\n");
fprintf(load_script_file, "unset label\n");
fprintf(load_script_file, "set term postscript eps enhanced color\n");
fprintf(load_script_file, "set ticslevel 0\n");
fprintf(load_script_file, "set nohidden3d\n");
fprintf(load_script_file, "set size square\n");
fprintf(load_script_file, "unset key\n");
fprintf(load_script_file, "set origin 0,-0.1\n");
switch(i%2)
{
case 1:
/* 3D view */
fprintf(load_script_file, "set view 30,40,0.5\n");
break;
case 0:
default:
/* 2D view */
fprintf(load_script_file, "set view 0,0, 0.5\n");
}
fprintf(load_script_file, "set pm3d\n");
fprintf(load_script_file, "set palette defined "
"(0 \"white\", 0.0001 \"black\", "
"10 \"gray\", 60 \"cyan\", 100 \"blue\")\n");
fprintf(load_script_file, "set colorbox vertical user origin "
".2,.28 size 0.03, 0.26\n");
fprintf(load_script_file, "unset surface\n");
fprintf(load_script_file, "set cbtics font \"Helvettica, 6\"\n");
fprintf(load_script_file, "set xlabel 'Time (cycles)' "
"font \"Helvettica, 7\"\n");
fprintf(load_script_file, "set xtics font \"Helvettica, 6\"\n");
fprintf(load_script_file, "set xtics offset -0.5,-0.2\n");
fprintf(load_script_file, "set ylabel 'Address (Hex)' "
"rotate by 135 offset 2, 0 font \"Helvettica, 7\"\n");
fprintf(load_script_file, "set ytics offset 1.5,0\n");
// fprintf(load_script_file, "set format y \"%.X\"\n");
fprintf(load_script_file, "set ytics font \"Helvettica, 8\"\n");
fprintf(load_script_file, "set mytics 4\n");
fprintf(load_script_file, "unset ztics\n");
fprintf(load_script_file, "set label \"Number of Accesses\" "
"font \"Helvetica,7\" at screen 0.27, "
"screen 0.35 rotate by 90\n");
if ( i < 2)
fprintf(load_script_file, "splot \"%s\" with lines\n",
snapshot->load_file_name);
else
fprintf(load_script_file, "splot \"%s\" with lines\n",
snapshot->store_file_name);
fprintf(load_script_file, "unset multiplot\n");
fclose(load_script_file);
/* Plot */
sprintf(cmd, "gnuplot %s > %s", load_script_file_name, plot_file_name);
int err = system(cmd);
if (err)
warning("could not execute gnuplot\nEither gnuplot is "
"not installed or is not the supported version\n");
/* Remove temporary files */
unlink(load_script_file_name);
}
unlink(snapshot->load_file_name);
unlink(snapshot->store_file_name);
}
int transform(const char *fpath, const struct stat *sb, int typeflag, struct FTW* ftwbuf)
{
int compress_type;
int fd_s, fd_t;
struct stat stbuf_s;
struct utimbuf utime_s;
char *tmpname;
off_t size;
compressor_t *decomp;
if (typeflag != FTW_F || !S_ISREG(sb->st_mode))
return 0;
/* internal file (attribute file, dedup DB) */
if (strncmp(&fpath[ftwbuf->base], FUSECOMPRESS_PREFIX, sizeof(FUSECOMPRESS_PREFIX) - 1) == 0)
return 0;
if (verbose)
fprintf(stderr, "%s: ", fpath);
if (comp && !is_compressible(&fpath[ftwbuf->base])) {
if (verbose)
fprintf(stderr, "incompressible\n");
return 0;
}
compress_type = is_compressed(fpath);
if (compress_type < -1)
{
fprintf(stderr, "failed to check %s for compression status\n", fpath);
errors++;
return 0;
}
/* if this is the type we are supposed to recompress, decompress
it first */
if (comp && recomp && compress_type == recomp->type) {
compressor_t *temp_c = comp;
int temp_v = verbose;
comp = NULL;
if (verbose)
fprintf(stderr, "recompress ");
verbose = 0;
transform(fpath, sb, typeflag, ftwbuf);
verbose = temp_v;
comp = temp_c;
compress_type = -1;
}
if (comp && compress_type >= 0)
{
if (verbose)
fprintf(stderr, "compressed already\n");
return 0;
}
if (!comp && compress_type < 0)
{
if (verbose)
fprintf(stderr, "uncompressed already\n");
return 0;
}
fd_s = file_open(fpath, O_RDONLY);
if (fstat(fd_s, &stbuf_s) < 0)
{
perror("unable to fstat");
return -1;
}
tmpname = file_create_temp(&fd_t);
current_tmp_file = tmpname;
if (!tmpname)
{
fprintf(stderr, "unable to create temporary file for compression\n");
return -1;
}
if (comp)
{
if (lseek(fd_t, sizeof(header_t), SEEK_SET) < 0)
{
perror("failed to seek beyond header");
goto out;
}
size = comp->compress(NULL, fd_s, fd_t);
if (lseek(fd_t, 0, SEEK_SET) < 0)
{
perror("failed to seek to beginning");
goto out;
}
if (file_write_header(fd_t, comp, stbuf_s.st_size) < 0)
{
perror("failed to write header");
goto out;
}
}
else
{
if (file_read_header_fd(fd_s, &decomp, &size) < 0)
{
perror("unable to read header");
goto out;
}
size = decomp->decompress(fd_s, fd_t);
}
if (size == (off_t) - 1)
{
fprintf(stderr, "compression failed\n");
goto out;
}
close(fd_s);
close(fd_t);
if (rename(tmpname, fpath) < 0)
{
perror("failed to rename tempfile");
goto out;
}
current_tmp_file = NULL;
if (lchown(fpath, stbuf_s.st_uid, stbuf_s.st_gid) < 0)
{
perror("unable to set owner/group");
/* do not abort; the filesystem may not support this */
}
if (chmod(fpath, stbuf_s.st_mode) < 0)
{
perror("unable to set permissions");
/* do not abort; the filesystem may not support this */
}
utime_s.actime = stbuf_s.st_atime;
utime_s.modtime = stbuf_s.st_mtime;
if (utime(fpath, &utime_s) < 0)
{
perror("failed to set timestamps");
goto out;
}
if (verbose)
fprintf(stderr, "ok\n");
return 0;
out:
close(fd_s);
close(fd_t);
unlink(tmpname);
return -1;
}
static void evg_calc_plot_local_mem_per_work_group(void) {
FILE *data_file, *script_file;
char plot_file_name[MAX_PATH_SIZE];
char data_file_name[MAX_PATH_SIZE];
char script_file_name[MAX_PATH_SIZE];
char cmd[MAX_PATH_SIZE];
int local_mem_per_work_group;
int work_items_per_work_group;
int registers_per_work_item;
int wavefronts_per_work_group;
int work_groups_per_compute_unit;
int wavefronts_per_compute_unit;
int local_mem_step;
int err;
/* Create plot file */
snprintf(plot_file_name, MAX_PATH_SIZE, "%s.%d.local_mem.eps",
evg_gpu_calc_file_name, evg_gpu->ndrange->id);
if (!file_can_open_for_write(plot_file_name))
fatal("%s: cannot write GPU occupancy calculation plot", plot_file_name);
/* Generate data file */
data_file = file_create_temp(data_file_name, MAX_PATH_SIZE);
registers_per_work_item = evg_gpu->ndrange->kernel->bin_file
->enc_dict_entry_evergreen->num_gpr_used;
local_mem_step = MAX(1, evg_gpu_local_mem_size / 32);
work_items_per_work_group = evg_gpu->ndrange->kernel->local_size;
wavefronts_per_work_group =
(work_items_per_work_group + evg_emu_wavefront_size - 1) /
evg_emu_wavefront_size;
for (local_mem_per_work_group = local_mem_step;
local_mem_per_work_group <= evg_gpu_local_mem_size;
local_mem_per_work_group += local_mem_step) {
/* Calculate point */
work_groups_per_compute_unit = evg_calc_get_work_groups_per_compute_unit(
work_items_per_work_group, registers_per_work_item,
local_mem_per_work_group);
wavefronts_per_compute_unit =
work_groups_per_compute_unit * wavefronts_per_work_group;
/* Dump line to data file */
fprintf(data_file, "%d %d\n", local_mem_per_work_group,
wavefronts_per_compute_unit);
}
fclose(data_file);
/* Current data point */
local_mem_per_work_group = evg_gpu->ndrange->local_mem_top;
work_groups_per_compute_unit = evg_calc_get_work_groups_per_compute_unit(
work_items_per_work_group, registers_per_work_item,
local_mem_per_work_group);
wavefronts_per_compute_unit =
work_groups_per_compute_unit * wavefronts_per_work_group;
/* Generate gnuplot script */
script_file = file_create_temp(script_file_name, MAX_PATH_SIZE);
fprintf(script_file, "set term postscript eps color solid\n");
fprintf(script_file, "set nokey\n");
fprintf(script_file, "set xlabel 'Local memory used per work-group (KB)'\n");
fprintf(script_file, "set ylabel 'Wavefronts per compute-unit'\n");
fprintf(script_file, "set xrange [0:%d]\n", evg_gpu_local_mem_size / 1024);
fprintf(script_file, "set yrange [0:]\n");
fprintf(script_file, "set size 0.65, 0.5\n");
fprintf(script_file, "set grid ytics\n");
fprintf(script_file,
"plot '%s' u ($1/1024):2 w linespoints lt 3 lw 5 pt 84 ps 2, ",
data_file_name);
fprintf(script_file,
"'-' u ($1/1024):2 w linespoints lt 1 lw 4 pt 82 ps 2\n%d %d\ne\n",
local_mem_per_work_group, wavefronts_per_compute_unit);
fclose(script_file);
/* Plot */
sprintf(cmd, "gnuplot %s > %s", script_file_name, plot_file_name);
err = system(cmd);
if (err) warning("could not execute gnuplot\n%s", err_gnuplot_msg);
/* Remove temporary files */
unlink(data_file_name);
unlink(script_file_name);
}
static void si_calc_plot_registers_per_work_item(void)
{
FILE *data_file, *script_file;
char plot_file_name[MAX_PATH_SIZE];
char data_file_name[MAX_PATH_SIZE];
char script_file_name[MAX_PATH_SIZE];
char cmd[MAX_PATH_SIZE];
int local_mem_per_work_group;
int work_items_per_work_group;
int registers_per_work_item;
int wavefronts_per_work_group;
int work_groups_per_wavefront_pool;
int wavefronts_per_wavefront_pool;
int err;
/* Create plot file */
snprintf(plot_file_name, MAX_PATH_SIZE, "%s.%d.registers.eps",
si_gpu_calc_file_name, si_emu->ndrange->id);
if (!file_can_open_for_write(plot_file_name))
{
fatal("%s: cannot write GPU occupancy calculation plot",
plot_file_name);
}
/* Generate data file */
data_file = file_create_temp(data_file_name, MAX_PATH_SIZE);
local_mem_per_work_group = si_emu->ndrange->local_mem_top;
work_items_per_work_group = si_emu->ndrange->local_size;
wavefronts_per_work_group = (work_items_per_work_group +
si_emu_wavefront_size - 1) / si_emu_wavefront_size;
for (registers_per_work_item = 1; registers_per_work_item <= 128;
registers_per_work_item += 4)
{
/* Calculate point */
work_groups_per_wavefront_pool =
si_calc_get_work_groups_per_wavefront_pool(
work_items_per_work_group,
registers_per_work_item,
local_mem_per_work_group);
wavefronts_per_wavefront_pool = work_groups_per_wavefront_pool *
wavefronts_per_work_group;
/* Dump line to data file */
fprintf(data_file, "%d %d\n", registers_per_work_item,
wavefronts_per_wavefront_pool);
}
fclose(data_file);
/* Current data point */
registers_per_work_item = si_emu->ndrange->num_vgpr_used;
work_groups_per_wavefront_pool =
si_calc_get_work_groups_per_wavefront_pool(
work_items_per_work_group,
registers_per_work_item, local_mem_per_work_group);
wavefronts_per_wavefront_pool = work_groups_per_wavefront_pool *
wavefronts_per_work_group;
/* Generate gnuplot script */
script_file = file_create_temp(script_file_name, MAX_PATH_SIZE);
fprintf(script_file, "set term postscript eps color solid\n");
fprintf(script_file, "set nokey\n");
fprintf(script_file, "set xlabel 'Registers per work-item'\n");
fprintf(script_file, "set ylabel 'Wavefronts per SIMD'\n");
fprintf(script_file, "set xrange [0:128]\n");
fprintf(script_file, "set yrange [0:]\n");
fprintf(script_file, "set xtics (0,16,32,48,64,80,96,112,128)\n");
fprintf(script_file, "set size 0.65, 0.5\n");
fprintf(script_file, "set grid ytics\n");
fprintf(script_file, "plot '%s' w linespoints lt 3 lw 5 pt 84 ps 2, ",
data_file_name);
fprintf(script_file, "'-' w linespoints lt 1 lw 4 pt 82 ps 2\n%d "
"%d\ne\n", registers_per_work_item,
wavefronts_per_wavefront_pool);
fclose(script_file);
/* Plot */
sprintf(cmd, "gnuplot %s > %s", script_file_name, plot_file_name);
err = system(cmd);
if (err)
warning("could not execute gnuplot\n%s", err_gnuplot_msg);
/* Remove temporary files */
unlink(data_file_name);
unlink(script_file_name);
}
