aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--libcuda/cuda_runtime_api.cc48
-rw-r--r--src/abstract_hardware_model.cc9
-rw-r--r--src/abstract_hardware_model.h2
-rw-r--r--src/cuda-sim/cuda-sim.cc38
-rw-r--r--src/cuda-sim/cuda_device_runtime.cc5
-rw-r--r--src/gpgpu-sim/gpu-sim.cc4
-rw-r--r--src/gpgpusim_entrypoint.cc161
-rw-r--r--src/gpgpusim_entrypoint.h46
8 files changed, 180 insertions, 133 deletions
diff --git a/libcuda/cuda_runtime_api.cc b/libcuda/cuda_runtime_api.cc
index fcd5b07..3d85b62 100644
--- a/libcuda/cuda_runtime_api.cc
+++ b/libcuda/cuda_runtime_api.cc
@@ -185,7 +185,7 @@ struct cudaArray
cudaError_t g_last_cudaError = cudaSuccess;
-extern stream_manager *g_stream_manager;
+//extern stream_manager *g_stream_manager();
void register_ptx_function( const char *name, function_info *impl )
{
@@ -375,7 +375,8 @@ private:
struct _cuda_device_id *GPGPUSim_Init()
{
- static _cuda_device_id *the_device = NULL;
+ //static _cuda_device_id *the_device = NULL;
+ _cuda_device_id *the_device = GPGPUsim_ctx_ptr()->the_cude_device;
if( !the_device ) {
gpgpu_sim *the_gpu = gpgpu_ptx_sim_init_perf();
@@ -420,7 +421,8 @@ struct _cuda_device_id *GPGPUSim_Init()
prop->maxThreadsPerMultiProcessor = the_gpu->threads_per_core();
#endif
the_gpu->set_prop(prop);
- the_device = new _cuda_device_id(the_gpu);
+ GPGPUsim_ctx_ptr()->the_cude_device = new _cuda_device_id(the_gpu);
+ the_device = GPGPUsim_ctx_ptr()->the_cude_device;
}
start_sim_thread(1);
return the_device;
@@ -428,10 +430,12 @@ struct _cuda_device_id *GPGPUSim_Init()
static CUctx_st* GPGPUSim_Context()
{
- static CUctx_st *the_context = NULL;
+ //static CUctx_st *the_context = NULL;
+ CUctx_st *the_context = GPGPUsim_ctx_ptr()->the_context;
if( the_context == NULL ) {
_cuda_device_id *the_gpu = GPGPUSim_Init();
- the_context = new CUctx_st(the_gpu);
+ GPGPUsim_ctx_ptr()->the_context = new CUctx_st(the_gpu);
+ the_context = GPGPUsim_ctx_ptr()->the_context;
}
return the_context;
}
@@ -699,21 +703,21 @@ __host__ cudaError_t CUDARTAPI cudaMemcpy(void *dst, const void *src, size_t cou
if(g_debug_execution >= 3)
printf("GPGPU-Sim PTX: cudaMemcpy(): devPtr = %p\n", dst);
if( kind == cudaMemcpyHostToDevice )
- g_stream_manager->push( stream_operation(src,(size_t)dst,count,0) );
+ g_stream_manager()->push( stream_operation(src,(size_t)dst,count,0) );
else if( kind == cudaMemcpyDeviceToHost )
- g_stream_manager->push( stream_operation((size_t)src,dst,count,0) );
+ g_stream_manager()->push( stream_operation((size_t)src,dst,count,0) );
else if( kind == cudaMemcpyDeviceToDevice )
- g_stream_manager->push( stream_operation((size_t)src,(size_t)dst,count,0) );
+ g_stream_manager()->push( stream_operation((size_t)src,(size_t)dst,count,0) );
else if ( kind == cudaMemcpyDefault ) {
if ((size_t)src >= GLOBAL_HEAP_START) {
if ((size_t)dst >= GLOBAL_HEAP_START)
- g_stream_manager->push( stream_operation((size_t)src,(size_t)dst,count,0) ); // device to device
+ g_stream_manager()->push( stream_operation((size_t)src,(size_t)dst,count,0) ); // device to device
else
- g_stream_manager->push( stream_operation((size_t)src,dst,count,0) ); // device to host
+ g_stream_manager()->push( stream_operation((size_t)src,dst,count,0) ); // device to host
}
else {
if ((size_t)dst >= GLOBAL_HEAP_START)
- g_stream_manager->push( stream_operation(src,(size_t)dst,count,0) );
+ g_stream_manager()->push( stream_operation(src,(size_t)dst,count,0) );
else {
printf("GPGPU-Sim PTX: cudaMemcpy - ERROR : unsupported transfer: host to host\n");
abort();
@@ -855,7 +859,7 @@ __host__ cudaError_t CUDARTAPI cudaMemcpyToSymbol(const char *symbol, const void
assert(kind == cudaMemcpyHostToDevice);
printf("GPGPU-Sim PTX: cudaMemcpyToSymbol: symbol = %p\n", symbol);
//stream_operation( const char *symbol, const void *src, size_t count, size_t offset )
- g_stream_manager->push( stream_operation(src,symbol,count,offset,0) );
+ g_stream_manager()->push( stream_operation(src,symbol,count,offset,0) );
//gpgpu_ptx_sim_memcpy_symbol(symbol,src,count,offset,1,context->get_device()->get_gpgpu());
return g_last_cudaError = cudaSuccess;
}
@@ -869,7 +873,7 @@ __host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbol(void *dst, const char *symbo
//CUctx_st *context = GPGPUSim_Context();
assert(kind == cudaMemcpyDeviceToHost);
printf("GPGPU-Sim PTX: cudaMemcpyFromSymbol: symbol = %p\n", symbol);
- g_stream_manager->push( stream_operation(symbol,dst,count,offset,0) );
+ g_stream_manager()->push( stream_operation(symbol,dst,count,offset,0) );
//gpgpu_ptx_sim_memcpy_symbol(symbol,dst,count,offset,0,context->get_device()->get_gpgpu());
return g_last_cudaError = cudaSuccess;
}
@@ -898,9 +902,9 @@ __host__ cudaError_t CUDARTAPI cudaMemcpyAsync(void *dst, const void *src, size_
}
struct CUstream_st *s = (struct CUstream_st *)stream;
switch( kind ) {
- case cudaMemcpyHostToDevice: g_stream_manager->push( stream_operation(src,(size_t)dst,count,s) ); break;
- case cudaMemcpyDeviceToHost: g_stream_manager->push( stream_operation((size_t)src,dst,count,s) ); break;
- case cudaMemcpyDeviceToDevice: g_stream_manager->push( stream_operation((size_t)src,(size_t)dst,count,s) ); break;
+ case cudaMemcpyHostToDevice: g_stream_manager()->push( stream_operation(src,(size_t)dst,count,s) ); break;
+ case cudaMemcpyDeviceToHost: g_stream_manager()->push( stream_operation((size_t)src,dst,count,s) ); break;
+ case cudaMemcpyDeviceToDevice: g_stream_manager()->push( stream_operation((size_t)src,(size_t)dst,count,s) ); break;
default:
abort();
}
@@ -1611,7 +1615,7 @@ __host__ cudaError_t CUDARTAPI cudaLaunch( const char *hostFun )
printf("GPGPU-Sim PTX: pushing kernel \'%s\' to stream %u, gridDim= (%u,%u,%u) blockDim = (%u,%u,%u) \n",
kname.c_str(), stream?stream->get_uid():0, gridDim.x,gridDim.y,gridDim.z,blockDim.x,blockDim.y,blockDim.z );
stream_operation op(grid,g_ptx_sim_mode,stream);
- g_stream_manager->push(op);
+ g_stream_manager()->push(op);
context->g_cuda_launch_stack.pop_back();
return g_last_cudaError = cudaSuccess;
}
@@ -1650,7 +1654,7 @@ __host__ cudaError_t CUDARTAPI cudaStreamCreate(cudaStream_t *stream)
printf("GPGPU-Sim PTX: cudaStreamCreate\n");
#if (CUDART_VERSION >= 3000)
*stream = new struct CUstream_st();
- g_stream_manager->add_stream(*stream);
+ g_stream_manager()->add_stream(*stream);
#else
*stream = 0;
printf("GPGPU-Sim PTX: WARNING: Asynchronous kernel execution not supported (%s)\n", __my_func__);
@@ -1689,7 +1693,7 @@ __host__ cudaError_t CUDARTAPI cudaStreamDestroy(cudaStream_t stream)
//per-stream synchronization required for application using external libraries without explicit synchronization in the code to
//avoid the stream_manager from spinning forever to destroy non-empty streams without making any forward progress.
stream->synchronize();
- g_stream_manager->destroy_stream(stream);
+ g_stream_manager()->destroy_stream(stream);
#endif
return g_last_cudaError = cudaSuccess;
}
@@ -1769,7 +1773,7 @@ __host__ cudaError_t CUDARTAPI cudaEventRecord(cudaEvent_t event, cudaStream_t s
if( !e ) return g_last_cudaError = cudaErrorUnknown;
struct CUstream_st *s = (struct CUstream_st *)stream;
stream_operation op(e,s);
- g_stream_manager->push(op);
+ g_stream_manager()->push(op);
return g_last_cudaError = cudaSuccess;
}
@@ -1785,11 +1789,11 @@ __host__ cudaError_t CUDARTAPI cudaStreamWaitEvent(cudaStream_t stream, cudaEven
return g_last_cudaError = cudaSuccess;
}
if (!stream){
- g_stream_manager->pushCudaStreamWaitEventToAllStreams(e, flags);
+ g_stream_manager()->pushCudaStreamWaitEventToAllStreams(e, flags);
} else {
struct CUstream_st *s = (struct CUstream_st *)stream;
stream_operation op(s,e,flags);
- g_stream_manager->push(op);
+ g_stream_manager()->push(op);
}
return g_last_cudaError = cudaSuccess;
}
diff --git a/src/abstract_hardware_model.cc b/src/abstract_hardware_model.cc
index 63b139e..7755477 100644
--- a/src/abstract_hardware_model.cc
+++ b/src/abstract_hardware_model.cc
@@ -34,6 +34,7 @@
#include "cuda-sim/cuda-sim.h"
#include "gpgpu-sim/gpu-sim.h"
#include "option_parser.h"
+#include "gpgpusim_entrypoint.h"
#include <algorithm>
#include <sys/stat.h>
#include <sstream>
@@ -771,14 +772,14 @@ void kernel_info_t::notify_parent_finished() {
extern unsigned long long g_total_param_size;
g_total_param_size -= ((m_kernel_entry->get_args_aligned_size() + 255)/256*256);
m_parent_kernel->remove_child(this);
- g_stream_manager->register_finished_kernel(m_parent_kernel->get_uid());
+ g_stream_manager()->register_finished_kernel(m_parent_kernel->get_uid());
}
}
CUstream_st * kernel_info_t::create_stream_cta(dim3 ctaid) {
assert(get_default_stream_cta(ctaid));
CUstream_st * stream = new CUstream_st();
- g_stream_manager->add_stream(stream);
+ g_stream_manager()->add_stream(stream);
assert(m_cta_streams.find(ctaid) != m_cta_streams.end());
assert(m_cta_streams[ctaid].size() >= 1); //must have default stream
m_cta_streams[ctaid].push_back(stream);
@@ -794,7 +795,7 @@ CUstream_st * kernel_info_t::get_default_stream_cta(dim3 ctaid) {
else {
m_cta_streams[ctaid] = std::list<CUstream_st *>();
CUstream_st * stream = new CUstream_st();
- g_stream_manager->add_stream(stream);
+ g_stream_manager()->add_stream(stream);
m_cta_streams[ctaid].push_back(stream);
return stream;
}
@@ -826,7 +827,7 @@ void kernel_info_t::destroy_cta_streams() {
for(auto s = m_cta_streams.begin(); s != m_cta_streams.end(); s++) {
stream_size += s->second.size();
for(auto ss = s->second.begin(); ss != s->second.end(); ss++)
- g_stream_manager->destroy_stream(*ss);
+ g_stream_manager()->destroy_stream(*ss);
s->second.clear();
}
printf("size %lu\n", stream_size);
diff --git a/src/abstract_hardware_model.h b/src/abstract_hardware_model.h
index 1735c2f..77d5f58 100644
--- a/src/abstract_hardware_model.h
+++ b/src/abstract_hardware_model.h
@@ -197,7 +197,7 @@ void increment_x_then_y_then_z( dim3 &i, const dim3 &bound);
#include "stream_manager.h"
class stream_manager;
struct CUstream_st;
-extern stream_manager * g_stream_manager;
+//extern stream_manager * g_stream_manager;
//support for pinned memories added
extern std::map<void *,void **> pinned_memory;
extern std::map<void *, size_t> pinned_memory_size;
diff --git a/src/cuda-sim/cuda-sim.cc b/src/cuda-sim/cuda-sim.cc
index e733b7f..261d605 100644
--- a/src/cuda-sim/cuda-sim.cc
+++ b/src/cuda-sim/cuda-sim.cc
@@ -448,8 +448,8 @@ void gpgpu_t::memcpy_to_gpu( size_t dst_start_addr, const void *src, size_t coun
m_global_mem->write(dst_start_addr+n,1, src_data+n,NULL,NULL);
// Copy into the performance model.
- extern gpgpu_sim* g_the_gpu;
- g_the_gpu->perf_memcpy_to_gpu(dst_start_addr, count);
+ //extern gpgpu_sim* g_the_gpu;
+ g_the_gpu()->perf_memcpy_to_gpu(dst_start_addr, count);
if(g_debug_execution >= 3) {
printf( " done.\n");
fflush(stdout);
@@ -467,8 +467,8 @@ void gpgpu_t::memcpy_from_gpu( void *dst, size_t src_start_addr, size_t count )
m_global_mem->read(src_start_addr+n,1,dst_data+n);
// Copy into the performance model.
- extern gpgpu_sim* g_the_gpu;
- g_the_gpu->perf_memcpy_to_gpu(src_start_addr, count);
+ //extern gpgpu_sim* g_the_gpu;
+ g_the_gpu()->perf_memcpy_to_gpu(src_start_addr, count);
if(g_debug_execution >= 3) {
printf( " done.\n");
fflush(stdout);
@@ -1270,8 +1270,8 @@ void function_info::finalize( memory_space *param_mem )
void function_info::param_to_shared( memory_space *shared_mem, symbol_table *symtab )
{
// TODO: call this only for PTXPlus with GT200 models
- extern gpgpu_sim* g_the_gpu;
- if (not g_the_gpu->get_config().convert_to_ptxplus()) return;
+ //extern gpgpu_sim* g_the_gpu;
+ if (not g_the_gpu()->get_config().convert_to_ptxplus()) return;
// copies parameters into simulated shared memory
for( std::map<unsigned,param_info>::iterator i=m_ptx_kernel_param_info.begin(); i!=m_ptx_kernel_param_info.end(); i++ ) {
@@ -2150,7 +2150,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
printf("GPGPU-Sim: Performing Functional Simulation, executing kernel %s...\n",kernel.name().c_str());
//using a shader core object for book keeping, it is not needed but as most function built for performance simulation need it we use it here
- extern gpgpu_sim *g_the_gpu;
+ //extern gpgpu_sim *g_the_gpu;
//before we execute, we should do PDOM analysis for functional simulation scenario.
function_info *kernel_func_info = kernel.entry();
const struct gpgpu_ptx_sim_info *kernel_info = ptx_sim_kernel_info(kernel_func_info);
@@ -2165,7 +2165,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
kernel_func_info->set_pdom();
}
- unsigned max_cta_tot = max_cta(kernel_info,kernel.threads_per_cta(), g_the_gpu->getShaderCoreConfig()->warp_size, g_the_gpu->getShaderCoreConfig()->n_thread_per_shader, g_the_gpu->getShaderCoreConfig()->gpgpu_shmem_size, g_the_gpu->getShaderCoreConfig()->gpgpu_shader_registers, g_the_gpu->getShaderCoreConfig()->max_cta_per_core);
+ unsigned max_cta_tot = max_cta(kernel_info,kernel.threads_per_cta(), g_the_gpu()->getShaderCoreConfig()->warp_size, g_the_gpu()->getShaderCoreConfig()->n_thread_per_shader, g_the_gpu()->getShaderCoreConfig()->gpgpu_shmem_size, g_the_gpu()->getShaderCoreConfig()->gpgpu_shader_registers, g_the_gpu()->getShaderCoreConfig()->max_cta_per_core);
printf("Max CTA : %d\n",max_cta_tot);
@@ -2173,11 +2173,11 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
int inst_count=50;
- int cp_op= g_the_gpu->checkpoint_option;
- int cp_CTA = g_the_gpu->checkpoint_CTA;
- int cp_kernel= g_the_gpu->checkpoint_kernel;
- cp_count= g_the_gpu->checkpoint_insn_Y;
- cp_cta_resume= g_the_gpu->checkpoint_CTA_t;
+ int cp_op= g_the_gpu()->checkpoint_option;
+ int cp_CTA = g_the_gpu()->checkpoint_CTA;
+ int cp_kernel= g_the_gpu()->checkpoint_kernel;
+ cp_count= g_the_gpu()->checkpoint_insn_Y;
+ cp_cta_resume= g_the_gpu()->checkpoint_CTA_t;
int cta_launched =0;
//we excute the kernel one CTA (Block) at the time, as synchronization functions work block wise
@@ -2189,8 +2189,8 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
{
functionalCoreSim cta(
&kernel,
- g_the_gpu,
- g_the_gpu->getShaderCoreConfig()->warp_size
+ g_the_gpu(),
+ g_the_gpu()->getShaderCoreConfig()->warp_size
);
cta.execute(cp_count,temp);
@@ -2211,7 +2211,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
{
char f1name[2048];
snprintf(f1name,2048,"checkpoint_files/global_mem_%d.txt", kernel.get_uid() );
- g_checkpoint->store_global_mem(g_the_gpu->get_global_memory(), f1name , "%08x");
+ g_checkpoint->store_global_mem(g_the_gpu()->get_global_memory(), f1name , "%08x");
}
@@ -2221,8 +2221,8 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
//openCL kernel simulation calls don't register the kernel so we don't register its exit
if(!openCL) {
- extern stream_manager *g_stream_manager;
- g_stream_manager->register_finished_kernel(kernel.get_uid());
+ //extern stream_manager *g_stream_manager;
+ g_stream_manager()->register_finished_kernel(kernel.get_uid());
}
//******PRINTING*******
@@ -2237,7 +2237,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
//g_simulation_starttime is initilized by gpgpu_ptx_sim_init_perf() in gpgpusim_entrypoint.cc upon starting gpgpu-sim
time_t end_time, elapsed_time, days, hrs, minutes, sec;
end_time = time((time_t *)NULL);
- elapsed_time = MAX(end_time - g_simulation_starttime, 1);
+ elapsed_time = MAX(end_time - GPGPUsim_ctx_ptr()->g_simulation_starttime, 1);
//calculating and printing simulation time in terms of days, hours, minutes and seconds
diff --git a/src/cuda-sim/cuda_device_runtime.cc b/src/cuda-sim/cuda_device_runtime.cc
index 86e8147..be8369f 100644
--- a/src/cuda-sim/cuda_device_runtime.cc
+++ b/src/cuda-sim/cuda_device_runtime.cc
@@ -18,6 +18,7 @@ unsigned long long g_max_total_param_size = 0;
#include "cuda-sim.h"
#include "ptx_ir.h"
#include "../stream_manager.h"
+#include "../gpgpusim_entrypoint.h"
#include "cuda_device_runtime.h"
#define DEV_RUNTIME_REPORT(a) \
@@ -64,7 +65,7 @@ public:
std::map<void *, device_launch_config_t> g_cuda_device_launch_param_map;
std::list<device_launch_operation_t> g_cuda_device_launch_op;
-extern stream_manager *g_stream_manager;
+//extern stream_manager *g_stream_manager();
//Handling device runtime api:
//void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize)
@@ -322,7 +323,7 @@ void launch_one_device_kernel() {
device_launch_operation_t &op = g_cuda_device_launch_op.front();
stream_operation stream_op = stream_operation(op.grid, g_ptx_sim_mode, op.stream);
- g_stream_manager->push(stream_op);
+ g_stream_manager()->push(stream_op);
g_cuda_device_launch_op.pop_front();
}
}
diff --git a/src/gpgpu-sim/gpu-sim.cc b/src/gpgpu-sim/gpu-sim.cc
index 6f19640..a557d6f 100644
--- a/src/gpgpu-sim/gpu-sim.cc
+++ b/src/gpgpu-sim/gpu-sim.cc
@@ -1131,7 +1131,7 @@ void gpgpu_sim::gpu_print_stat()
time_t curr_time;
time(&curr_time);
- unsigned long long elapsed_time = MAX( curr_time - g_simulation_starttime, 1 );
+ unsigned long long elapsed_time = MAX( curr_time - GPGPUsim_ctx_ptr()->g_simulation_starttime, 1 );
printf( "gpu_total_sim_rate=%u\n", (unsigned)( ( gpu_tot_sim_insn + gpu_sim_insn ) / elapsed_time ) );
//shader_print_l1_miss_stat( stdout );
@@ -1701,7 +1701,7 @@ void gpgpu_sim::cycle()
time_t days, hrs, minutes, sec;
time_t curr_time;
time(&curr_time);
- unsigned long long elapsed_time = MAX(curr_time - g_simulation_starttime, 1);
+ unsigned long long elapsed_time = MAX(curr_time - GPGPUsim_ctx_ptr()->g_simulation_starttime, 1);
if ( (elapsed_time - last_liveness_message_time) >= m_config.liveness_message_freq && DTRACE(LIVENESS) ) {
days = elapsed_time/(3600*24);
hrs = elapsed_time/3600 - 24*days;
diff --git a/src/gpgpusim_entrypoint.cc b/src/gpgpusim_entrypoint.cc
index aa0c249..de937b0 100644
--- a/src/gpgpusim_entrypoint.cc
+++ b/src/gpgpusim_entrypoint.cc
@@ -36,21 +36,25 @@
#include "gpgpu-sim/icnt_wrapper.h"
#include "stream_manager.h"
-
#define MAX(a,b) (((a)>(b))?(a):(b))
- sem_t g_sim_signal_start;
- sem_t g_sim_signal_finish;
- sem_t g_sim_signal_exit;
- time_t g_simulation_starttime;
- pthread_t g_simulation_thread;
- class gpgpu_sim_config *g_the_gpu_config;
- class gpgpu_sim *g_the_gpu;
- class stream_manager *g_stream_manager;
+struct GPGPUsim_ctx* the_gpgpusim = NULL;
+
+struct GPGPUsim_ctx* GPGPUsim_ctx_ptr(){
+ if(the_gpgpusim == NULL)
+ the_gpgpusim = new GPGPUsim_ctx();
+
+ return the_gpgpusim;
+}
+
+class gpgpu_sim* g_the_gpu() {
+ return GPGPUsim_ctx_ptr()->g_the_gpu;
+}
- static int sg_argc = 3;
- static const char *sg_argv[] = {"", "-config","gpgpusim.config"};
+class stream_manager* g_stream_manager() {
+ return GPGPUsim_ctx_ptr()->g_stream_manager;
+}
static void print_simulation_time();
@@ -59,29 +63,26 @@ void *gpgpu_sim_thread_sequential(void*)
// at most one kernel running at a time
bool done;
do {
- sem_wait(&g_sim_signal_start);
+ sem_wait(&(GPGPUsim_ctx_ptr()->g_sim_signal_start));
done = true;
- if( g_the_gpu->get_more_cta_left() ) {
+ if( GPGPUsim_ctx_ptr()->g_the_gpu->get_more_cta_left() ) {
done = false;
- g_the_gpu->init();
- while( g_the_gpu->active() ) {
- g_the_gpu->cycle();
- g_the_gpu->deadlock_check();
+ GPGPUsim_ctx_ptr()->g_the_gpu->init();
+ while( GPGPUsim_ctx_ptr()->g_the_gpu->active() ) {
+ GPGPUsim_ctx_ptr()->g_the_gpu->cycle();
+ GPGPUsim_ctx_ptr()->g_the_gpu->deadlock_check();
}
- g_the_gpu->print_stats();
- g_the_gpu->update_stats();
+ GPGPUsim_ctx_ptr()->g_the_gpu->print_stats();
+ GPGPUsim_ctx_ptr()->g_the_gpu->update_stats();
print_simulation_time();
}
- sem_post(&g_sim_signal_finish);
+ sem_post(&(GPGPUsim_ctx_ptr()->g_sim_signal_finish));
} while(!done);
- sem_post(&g_sim_signal_exit);
+ sem_post(&(GPGPUsim_ctx_ptr()->g_sim_signal_exit));
return NULL;
}
-pthread_mutex_t g_sim_lock = PTHREAD_MUTEX_INITIALIZER;
-bool g_sim_active = false;
-bool g_sim_done = true;
-bool break_limit = false;
+
static void termination_callback()
{
@@ -98,19 +99,19 @@ void *gpgpu_sim_thread_concurrent(void*)
printf("GPGPU-Sim: *** simulation thread starting and spinning waiting for work ***\n");
fflush(stdout);
}
- while( g_stream_manager->empty_protected() && !g_sim_done )
+ while( GPGPUsim_ctx_ptr()->g_stream_manager->empty_protected() && !GPGPUsim_ctx_ptr()->g_sim_done )
;
if(g_debug_execution >= 3) {
printf("GPGPU-Sim: ** START simulation thread (detected work) **\n");
- g_stream_manager->print(stdout);
+ GPGPUsim_ctx_ptr()->g_stream_manager->print(stdout);
fflush(stdout);
}
- pthread_mutex_lock(&g_sim_lock);
- g_sim_active = true;
- pthread_mutex_unlock(&g_sim_lock);
+ pthread_mutex_lock(&(GPGPUsim_ctx_ptr()->g_sim_lock));
+ GPGPUsim_ctx_ptr()->g_sim_active = true;
+ pthread_mutex_unlock(&(GPGPUsim_ctx_ptr()->g_sim_lock));
bool active = false;
bool sim_cycles = false;
- g_the_gpu->init();
+ GPGPUsim_ctx_ptr()->g_the_gpu->init();
do {
// check if a kernel has completed
// launch operation on device if one is pending and can be run
@@ -122,70 +123,70 @@ void *gpgpu_sim_thread_concurrent(void*)
// another kernel, the gpu is not re-initialized and the inter-kernel
// behaviour may be incorrect. Check that a kernel has finished and
// no other kernel is currently running.
- if(g_stream_manager->operation(&sim_cycles) && !g_the_gpu->active())
+ if(GPGPUsim_ctx_ptr()->g_stream_manager->operation(&sim_cycles) && !GPGPUsim_ctx_ptr()->g_the_gpu->active())
break;
//functional simulation
- if( g_the_gpu->is_functional_sim()) {
- kernel_info_t * kernel = g_the_gpu->get_functional_kernel();
+ if( GPGPUsim_ctx_ptr()->g_the_gpu->is_functional_sim()) {
+ kernel_info_t * kernel = GPGPUsim_ctx_ptr()->g_the_gpu->get_functional_kernel();
assert(kernel);
gpgpu_cuda_ptx_sim_main_func(*kernel);
- g_the_gpu->finish_functional_sim(kernel);
+ GPGPUsim_ctx_ptr()->g_the_gpu->finish_functional_sim(kernel);
}
//performance simulation
- if( g_the_gpu->active() ) {
- g_the_gpu->cycle();
- sim_cycles = true;
- g_the_gpu->deadlock_check();
+ if( GPGPUsim_ctx_ptr()->g_the_gpu->active() ) {
+ GPGPUsim_ctx_ptr()->g_the_gpu->cycle();
+ sim_cycles = true;
+ GPGPUsim_ctx_ptr()->g_the_gpu->deadlock_check();
}else {
- if(g_the_gpu->cycle_insn_cta_max_hit()){
- g_stream_manager->stop_all_running_kernels();
- g_sim_done = true;
- break_limit = true;
+ if(GPGPUsim_ctx_ptr()->g_the_gpu->cycle_insn_cta_max_hit()){
+ GPGPUsim_ctx_ptr()->g_stream_manager->stop_all_running_kernels();
+ GPGPUsim_ctx_ptr()->g_sim_done = true;
+ GPGPUsim_ctx_ptr()->break_limit = true;
}
}
- active=g_the_gpu->active() || !g_stream_manager->empty_protected();
+ active=GPGPUsim_ctx_ptr()->g_the_gpu->active() || !(GPGPUsim_ctx_ptr()->g_stream_manager->empty_protected());
- } while( active && !g_sim_done);
+ } while( active && !GPGPUsim_ctx_ptr()->g_sim_done);
if(g_debug_execution >= 3) {
printf("GPGPU-Sim: ** STOP simulation thread (no work) **\n");
fflush(stdout);
}
if(sim_cycles) {
- g_the_gpu->print_stats();
- g_the_gpu->update_stats();
+ GPGPUsim_ctx_ptr()->g_the_gpu->print_stats();
+ GPGPUsim_ctx_ptr()->g_the_gpu->update_stats();
print_simulation_time();
}
- pthread_mutex_lock(&g_sim_lock);
- g_sim_active = false;
- pthread_mutex_unlock(&g_sim_lock);
- } while( !g_sim_done );
+ pthread_mutex_lock(&(GPGPUsim_ctx_ptr()->g_sim_lock));
+ GPGPUsim_ctx_ptr()->g_sim_active = false;
+ pthread_mutex_unlock(&(GPGPUsim_ctx_ptr()->g_sim_lock));
+ } while( !GPGPUsim_ctx_ptr()->g_sim_done );
printf("GPGPU-Sim: *** simulation thread exiting ***\n");
fflush(stdout);
- if(break_limit) {
+ if(GPGPUsim_ctx_ptr()->break_limit) {
printf("GPGPU-Sim: ** break due to reaching the maximum cycles (or instructions) **\n");
exit(1);
}
- sem_post(&g_sim_signal_exit);
+ sem_post(&(GPGPUsim_ctx_ptr()->g_sim_signal_exit));
return NULL;
}
void synchronize()
{
printf("GPGPU-Sim: synchronize waiting for inactive GPU simulation\n");
- g_stream_manager->print(stdout);
+ GPGPUsim_ctx_ptr()->g_stream_manager->print(stdout);
fflush(stdout);
// sem_wait(&g_sim_signal_finish);
bool done = false;
do {
- pthread_mutex_lock(&g_sim_lock);
- done = ( g_stream_manager->empty() && !g_sim_active ) || g_sim_done;
- pthread_mutex_unlock(&g_sim_lock);
+ pthread_mutex_lock(&(GPGPUsim_ctx_ptr()->g_sim_lock));
+ done = ( GPGPUsim_ctx_ptr()->g_stream_manager->empty() && !GPGPUsim_ctx_ptr()->g_sim_active ) || GPGPUsim_ctx_ptr()->g_sim_done;
+ pthread_mutex_unlock(&(GPGPUsim_ctx_ptr()->g_sim_lock));
} while (!done);
printf("GPGPU-Sim: detected inactive GPU simulation thread\n");
fflush(stdout);
@@ -194,10 +195,10 @@ void synchronize()
void exit_simulation()
{
- g_sim_done=true;
+ GPGPUsim_ctx_ptr()->g_sim_done=true;
printf("GPGPU-Sim: exit_simulation called\n");
fflush(stdout);
- sem_wait(&g_sim_signal_exit);
+ sem_wait(&(GPGPUsim_ctx_ptr()->g_sim_signal_exit));
printf("GPGPU-Sim: simulation thread signaled exit\n");
fflush(stdout);
}
@@ -216,37 +217,37 @@ gpgpu_sim *gpgpu_ptx_sim_init_perf()
ptx_opcocde_latency_options(opp);
icnt_reg_options(opp);
- g_the_gpu_config = new gpgpu_sim_config();
- g_the_gpu_config->reg_options(opp); // register GPU microrachitecture options
+ GPGPUsim_ctx_ptr()->g_the_gpu_config = new gpgpu_sim_config();
+ GPGPUsim_ctx_ptr()->g_the_gpu_config->reg_options(opp); // register GPU microrachitecture options
- option_parser_cmdline(opp, sg_argc, sg_argv); // parse configuration options
+ option_parser_cmdline(opp, GPGPUsim_ctx_ptr()->sg_argc, GPGPUsim_ctx_ptr()->sg_argv); // parse configuration options
fprintf(stdout, "GPGPU-Sim: Configuration options:\n\n");
option_parser_print(opp, stdout);
// Set the Numeric locale to a standard locale where a decimal point is a "dot" not a "comma"
// so it does the parsing correctly independent of the system environment variables
assert(setlocale(LC_NUMERIC,"C"));
- g_the_gpu_config->init();
+ GPGPUsim_ctx_ptr()->g_the_gpu_config->init();
- g_the_gpu = new gpgpu_sim(*g_the_gpu_config);
- g_stream_manager = new stream_manager(g_the_gpu,g_cuda_launch_blocking);
+ GPGPUsim_ctx_ptr()->g_the_gpu = new gpgpu_sim(*(GPGPUsim_ctx_ptr()->g_the_gpu_config));
+ GPGPUsim_ctx_ptr()->g_stream_manager = new stream_manager((GPGPUsim_ctx_ptr()->g_the_gpu),g_cuda_launch_blocking);
- g_simulation_starttime = time((time_t *)NULL);
+ GPGPUsim_ctx_ptr()->g_simulation_starttime = time((time_t *)NULL);
- sem_init(&g_sim_signal_start,0,0);
- sem_init(&g_sim_signal_finish,0,0);
- sem_init(&g_sim_signal_exit,0,0);
+ sem_init(&(GPGPUsim_ctx_ptr()->g_sim_signal_start),0,0);
+ sem_init(&(GPGPUsim_ctx_ptr()->g_sim_signal_finish),0,0);
+ sem_init(&(GPGPUsim_ctx_ptr()->g_sim_signal_exit),0,0);
- return g_the_gpu;
+ return GPGPUsim_ctx_ptr()->g_the_gpu;
}
void start_sim_thread(int api)
{
- if( g_sim_done ) {
- g_sim_done = false;
+ if( GPGPUsim_ctx_ptr()->g_sim_done ) {
+ GPGPUsim_ctx_ptr()->g_sim_done = false;
if( api == 1 ) {
- pthread_create(&g_simulation_thread,NULL,gpgpu_sim_thread_concurrent,NULL);
+ pthread_create(&(GPGPUsim_ctx_ptr()->g_simulation_thread),NULL,gpgpu_sim_thread_concurrent,NULL);
} else {
- pthread_create(&g_simulation_thread,NULL,gpgpu_sim_thread_sequential,NULL);
+ pthread_create(&(GPGPUsim_ctx_ptr()->g_simulation_thread),NULL,gpgpu_sim_thread_sequential,NULL);
}
}
}
@@ -255,7 +256,7 @@ void print_simulation_time()
{
time_t current_time, difference, d, h, m, s;
current_time = time((time_t *)NULL);
- difference = MAX(current_time - g_simulation_starttime, 1);
+ difference = MAX(current_time - GPGPUsim_ctx_ptr()->g_simulation_starttime, 1);
d = difference/(3600*24);
h = difference/3600 - 24*d;
@@ -265,16 +266,16 @@ void print_simulation_time()
fflush(stderr);
printf("\n\ngpgpu_simulation_time = %u days, %u hrs, %u min, %u sec (%u sec)\n",
(unsigned)d, (unsigned)h, (unsigned)m, (unsigned)s, (unsigned)difference );
- printf("gpgpu_simulation_rate = %u (inst/sec)\n", (unsigned)(g_the_gpu->gpu_tot_sim_insn / difference) );
- printf("gpgpu_simulation_rate = %u (cycle/sec)\n", (unsigned)(g_the_gpu->gpu_tot_sim_cycle / difference) );
+ printf("gpgpu_simulation_rate = %u (inst/sec)\n", (unsigned)(GPGPUsim_ctx_ptr()->g_the_gpu->gpu_tot_sim_insn / difference) );
+ printf("gpgpu_simulation_rate = %u (cycle/sec)\n", (unsigned)(GPGPUsim_ctx_ptr()->g_the_gpu->gpu_tot_sim_cycle / difference) );
fflush(stdout);
}
int gpgpu_opencl_ptx_sim_main_perf( kernel_info_t *grid )
{
- g_the_gpu->launch(grid);
- sem_post(&g_sim_signal_start);
- sem_wait(&g_sim_signal_finish);
+ GPGPUsim_ctx_ptr()->g_the_gpu->launch(grid);
+ sem_post(&(GPGPUsim_ctx_ptr()->g_sim_signal_start));
+ sem_wait(&(GPGPUsim_ctx_ptr()->g_sim_signal_finish));
return 0;
}
diff --git a/src/gpgpusim_entrypoint.h b/src/gpgpusim_entrypoint.h
index eacb2d7..406dd00 100644
--- a/src/gpgpusim_entrypoint.h
+++ b/src/gpgpusim_entrypoint.h
@@ -33,20 +33,60 @@
#include <semaphore.h>
#include <time.h>
-extern time_t g_simulation_starttime;
+//extern time_t g_simulation_starttime;
-struct GPU_ctx {
+struct GPGPUsim_ctx {
- struct gpgpu_ptx_sim_arg *grid_params;
+ GPGPUsim_ctx() {
+ g_sim_active = false;
+ g_sim_done = true;
+ break_limit = false;
+ g_sim_lock = PTHREAD_MUTEX_INITIALIZER;
+ sg_argc = 3;
+ sg_argv = {"", "-config","gpgpusim.config"};
+ g_the_gpu_config=NULL;
+ g_the_gpu=NULL;
+ g_stream_manager=NULL;
+ the_cude_device=NULL;
+ the_context=NULL;
+ }
+
+ //struct gpgpu_ptx_sim_arg *grid_params;
+
+ sem_t g_sim_signal_start;
+ sem_t g_sim_signal_finish;
+ sem_t g_sim_signal_exit;
+ time_t g_simulation_starttime;
+ pthread_t g_simulation_thread;
+
+ class gpgpu_sim_config *g_the_gpu_config;
+ class gpgpu_sim *g_the_gpu;
+ class stream_manager *g_stream_manager;
+
+ struct _cuda_device_id *the_cude_device;
+ struct CUctx_st* the_context;
+
+
+ int sg_argc;
+ const char *sg_argv[3];
+
+ pthread_mutex_t g_sim_lock;
+ bool g_sim_active;
+ bool g_sim_done;
+ bool break_limit;
};
class gpgpu_sim *gpgpu_ptx_sim_init_perf();
void start_sim_thread(int api);
+class gpgpu_sim* g_the_gpu();
+struct GPGPUsim_ctx* GPGPUsim_ctx_ptr();
+class stream_manager* g_stream_manager();
+
int gpgpu_opencl_ptx_sim_main_perf( kernel_info_t *grid );
int gpgpu_opencl_ptx_sim_main_func( kernel_info_t *grid );
generated by cgit v1.3 (git 2.53.0) at 2026-07-20 19:24:09 +0000