diff options
Diffstat (limited to 'src')
43 files changed, 1140 insertions, 968 deletions
diff --git a/src/Makefile b/src/Makefile index 6001669..3ad511e 100644 --- a/src/Makefile +++ b/src/Makefile @@ -51,6 +51,8 @@ else CXXFLAGS += endif +CXXFLAGS += -I$(CUDA_INSTALL_PATH)/include + OPTFLAGS += -g3 -fPIC CPP = g++ $(SNOW) diff --git a/src/abstract_hardware_model.cc b/src/abstract_hardware_model.cc index cebdb25..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> @@ -198,6 +199,9 @@ gpgpu_t::gpgpu_t( const gpgpu_functional_sim_config &config ) if(m_function_model_config.get_ptx_inst_debug_to_file() != 0) ptx_inst_debug_file = fopen(m_function_model_config.get_ptx_inst_debug_file(), "w"); + + gpu_sim_cycle=0; + gpu_tot_sim_cycle=0; } address_type line_size_based_tag_func(new_addr_type address, new_addr_type line_size) @@ -768,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); @@ -791,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; } @@ -823,17 +827,18 @@ 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); m_cta_streams.clear(); } -simt_stack::simt_stack( unsigned wid, unsigned warpSize) +simt_stack::simt_stack( unsigned wid, unsigned warpSize, class gpgpu_sim * gpu) { m_warp_id=wid; m_warp_size = warpSize; + m_gpu=gpu; reset(); } @@ -1033,7 +1038,7 @@ void simt_stack::update( simt_mask_t &thread_done, addr_vector_t &next_pc, addre simt_stack_entry new_stack_entry; new_stack_entry.m_pc = tmp_next_pc; new_stack_entry.m_active_mask = tmp_active_mask; - new_stack_entry.m_branch_div_cycle = gpu_sim_cycle+gpu_tot_sim_cycle; + new_stack_entry.m_branch_div_cycle = m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle; new_stack_entry.m_type = STACK_ENTRY_TYPE_CALL; m_stack.push_back(new_stack_entry); return; @@ -1065,7 +1070,7 @@ void simt_stack::update( simt_mask_t &thread_done, addr_vector_t &next_pc, addre new_recvg_pc = recvg_pc; if (new_recvg_pc != top_recvg_pc) { m_stack.back().m_pc = new_recvg_pc; - m_stack.back().m_branch_div_cycle = gpu_sim_cycle+gpu_tot_sim_cycle; + m_stack.back().m_branch_div_cycle = m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle; m_stack.push_back(simt_stack_entry()); } @@ -1157,7 +1162,7 @@ void core_t::initilizeSIMTStack(unsigned warp_count, unsigned warp_size) { m_simt_stack = new simt_stack*[warp_count]; for (unsigned i = 0; i < warp_count; ++i) - m_simt_stack[i] = new simt_stack(i,warp_size); + m_simt_stack[i] = new simt_stack(i,warp_size,m_gpu); m_warp_size = warp_size; m_warp_count = warp_count; } diff --git a/src/abstract_hardware_model.h b/src/abstract_hardware_model.h index 22ef509..68cb693 100644 --- a/src/abstract_hardware_model.h +++ b/src/abstract_hardware_model.h @@ -173,9 +173,7 @@ enum _memory_op_t { #include <algorithm> #if !defined(__VECTOR_TYPES_H__) -struct dim3 { - unsigned int x, y, z; -}; +#include "vector_types.h" #endif struct dim3comp { bool operator() (const dim3 & a, const dim3 & b) const @@ -197,7 +195,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; @@ -399,7 +397,7 @@ typedef std::vector<address_type> addr_vector_t; class simt_stack { public: - simt_stack( unsigned wid, unsigned warpSize); + simt_stack( unsigned wid, unsigned warpSize, class gpgpu_sim * gpu); void reset(); void launch( address_type start_pc, const simt_mask_t &active_mask ); @@ -416,6 +414,7 @@ protected: unsigned m_warp_id; unsigned m_warp_size; + enum stack_entry_type { STACK_ENTRY_TYPE_NORMAL = 0, STACK_ENTRY_TYPE_CALL @@ -433,6 +432,8 @@ protected: }; std::deque<simt_stack_entry> m_stack; + + class gpgpu_sim * m_gpu; }; #define GLOBAL_HEAP_START 0xC0000000 @@ -451,19 +452,7 @@ protected: #if !defined(__CUDA_RUNTIME_API_H__) -enum cudaChannelFormatKind { - cudaChannelFormatKindSigned, - cudaChannelFormatKindUnsigned, - cudaChannelFormatKindFloat -}; - -struct cudaChannelFormatDesc { - int x; - int y; - int z; - int w; - enum cudaChannelFormatKind f; -}; +#include "builtin_types.h" struct cudaArray { void *devPtr; @@ -475,28 +464,6 @@ struct cudaArray { unsigned dimensions; }; -enum cudaTextureAddressMode { - cudaAddressModeWrap, - cudaAddressModeClamp -}; - -enum cudaTextureFilterMode { - cudaFilterModePoint, - cudaFilterModeLinear -}; - -enum cudaTextureReadMode { - cudaReadModeElementType, - cudaReadModeNormalizedFloat -}; - -struct textureReference { - int normalized; - enum cudaTextureFilterMode filterMode; - enum cudaTextureAddressMode addressMode[3]; - struct cudaChannelFormatDesc channelDesc; -}; - #endif // Struct that record other attributes in the textureReference declaration @@ -571,6 +538,12 @@ public: int resume_CTA; int checkpoint_CTA_t; int checkpoint_insn_Y; + + //Move some cycle core stats here instead of being global + unsigned long long gpu_sim_cycle; + unsigned long long gpu_tot_sim_cycle; + + void* gpu_malloc( size_t size ); void* gpu_mallocarray( size_t count ); void gpu_memset( size_t dst_start_addr, int c, size_t count ); @@ -835,8 +808,8 @@ public: class mem_fetch_allocator { public: - virtual mem_fetch *alloc( new_addr_type addr, mem_access_type type, unsigned size, bool wr ) const = 0; - virtual mem_fetch *alloc( const class warp_inst_t &inst, const mem_access_t &access ) const = 0; + virtual mem_fetch *alloc( new_addr_type addr, mem_access_type type, unsigned size, bool wr, unsigned long long cycle ) const = 0; + virtual mem_fetch *alloc( const class warp_inst_t &inst, const mem_access_t &access, unsigned long long cycle ) const = 0; }; // the maximum number of destination, source, or address uarch operands in a instruction diff --git a/src/cuda-sim/Makefile b/src/cuda-sim/Makefile index 999dad7..85d1c8c 100644 --- a/src/cuda-sim/Makefile +++ b/src/cuda-sim/Makefile @@ -79,16 +79,16 @@ libgpgpu_ptx_sim.a: $(OBJS) ar rcs $(OUTPUT_DIR)/libgpgpu_ptx_sim.a $(OUTPUT_DIR)/ptx.tab.o $(OUTPUT_DIR)/lex.ptx_.o $(OUTPUT_DIR)/ptxinfo.tab.o $(OUTPUT_DIR)/lex.ptxinfo_.o $(OBJS) $(OUTPUT_DIR)/ptx.tab.o: $(OUTPUT_DIR)/ptx.tab.c - $(CPP) -c $(OPT) -DYYDEBUG $(OUTPUT_DIR)/ptx.tab.c -o $(OUTPUT_DIR)/ptx.tab.o + $(CPP) -c $(CXX_OPT) -DYYDEBUG $(OUTPUT_DIR)/ptx.tab.c -o $(OUTPUT_DIR)/ptx.tab.o $(OUTPUT_DIR)/lex.ptx_.o: $(OUTPUT_DIR)/lex.ptx_.c - $(CPP) -c $(OPT) $(OUTPUT_DIR)/lex.ptx_.c -o $(OUTPUT_DIR)/lex.ptx_.o + $(CPP) -c $(CXX_OPT) $(OUTPUT_DIR)/lex.ptx_.c -o $(OUTPUT_DIR)/lex.ptx_.o $(OUTPUT_DIR)/ptxinfo.tab.o: $(OUTPUT_DIR)/ptxinfo.tab.c - $(CPP) -c $(OPT) -DYYDEBUG $(OUTPUT_DIR)/ptxinfo.tab.c -o $(OUTPUT_DIR)/ptxinfo.tab.o + $(CPP) -c $(CXX_OPT) -DYYDEBUG $(OUTPUT_DIR)/ptxinfo.tab.c -o $(OUTPUT_DIR)/ptxinfo.tab.o $(OUTPUT_DIR)/lex.ptxinfo_.o: $(OUTPUT_DIR)/lex.ptxinfo_.c $(OUTPUT_DIR)/ptxinfo.tab.c - $(CPP) -c $(OPT) $(OUTPUT_DIR)/lex.ptxinfo_.c -o $(OUTPUT_DIR)/lex.ptxinfo_.o + $(CPP) -c $(CXX_OPT) $(OUTPUT_DIR)/lex.ptxinfo_.c -o $(OUTPUT_DIR)/lex.ptxinfo_.o $(OUTPUT_DIR)/ptx.tab.c: ptx.y bison --name-prefix=ptx_ -v -d ptx.y --file-prefix=$(OUTPUT_DIR)/ptx diff --git a/src/cuda-sim/cuda-math.h b/src/cuda-sim/cuda-math.h index a5db337..9a5468c 100644 --- a/src/cuda-sim/cuda-math.h +++ b/src/cuda-sim/cuda-math.h @@ -277,10 +277,10 @@ int float2int(float a, enum cudaRoundMode mode) { int tmp; switch (mode) { - case cuda_math::cudaRoundZero: tmp = truncf(a); break; - case cuda_math::cudaRoundNearest: tmp = nearbyintf(a); break; - case cuda_math::cudaRoundMinInf: tmp = floorf(a); break; - case cuda_math::cudaRoundPosInf: tmp = ceilf(a); break; + case cudaRoundZero: tmp = truncf(a); break; + case cudaRoundNearest: tmp = nearbyintf(a); break; + case cudaRoundMinInf: tmp = floorf(a); break; + case cudaRoundPosInf: tmp = ceilf(a); break; default: abort(); } return tmp; @@ -296,10 +296,10 @@ unsigned int float2uint(float a, enum cudaRoundMode mode) { unsigned int tmp; switch (mode) { - case cuda_math::cudaRoundZero: tmp = truncf(a); break; - case cuda_math::cudaRoundNearest: tmp = nearbyintf(a); break; - case cuda_math::cudaRoundMinInf: tmp = floorf(a); break; - case cuda_math::cudaRoundPosInf: tmp = ceilf(a); break; + case cudaRoundZero: tmp = truncf(a); break; + case cudaRoundNearest: tmp = nearbyintf(a); break; + case cudaRoundMinInf: tmp = floorf(a); break; + case cudaRoundPosInf: tmp = ceilf(a); break; default: abort(); } return tmp; diff --git a/src/cuda-sim/cuda-sim.cc b/src/cuda-sim/cuda-sim.cc index f7bb9cc..261d605 100644 --- a/src/cuda-sim/cuda-sim.cc +++ b/src/cuda-sim/cuda-sim.cc @@ -30,6 +30,8 @@ #include "instructions.h" #include "ptx_ir.h" +class ptx_recognizer; +typedef void * yyscan_t; #include "ptx.tab.h" #include "ptx_sim.h" #include <stdio.h> @@ -446,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); @@ -465,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); @@ -1268,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++ ) { @@ -2148,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); @@ -2163,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); @@ -2171,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 @@ -2187,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); @@ -2209,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"); } @@ -2219,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******* @@ -2235,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 917e7a8..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) @@ -200,7 +201,7 @@ void gpgpusim_cuda_launchDeviceV2(const ptx_instruction * pI, ptx_thread_info * //create child kernel_info_t and index it with parameter_buffer address gpgpu_t* gpu=thread->get_gpu(); device_grid = new kernel_info_t(config.grid_dim, config.block_dim, device_kernel_entry, gpu->getNameArrayMapping(), gpu->getNameInfoMapping()); - device_grid->launch_cycle = gpu_sim_cycle + gpu_tot_sim_cycle; + device_grid->launch_cycle = gpu->gpu_sim_cycle + gpu->gpu_tot_sim_cycle; kernel_info_t & parent_grid = thread->get_kernel(); DEV_RUNTIME_REPORT("child kernel launched by " << parent_grid.name() << ", cta (" << thread->get_ctaid().x << ", " << thread->get_ctaid().y << ", " << thread->get_ctaid().z << @@ -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/cuda-sim/instructions.cc b/src/cuda-sim/instructions.cc index 11001d7..186bb1e 100644 --- a/src/cuda-sim/instructions.cc +++ b/src/cuda-sim/instructions.cc @@ -31,6 +31,8 @@ #include "ptx_ir.h" #include "opcodes.h" #include "ptx_sim.h" +typedef void * yyscan_t; +class ptx_recognizer; #include "ptx.tab.h" #include <stdlib.h> #include <math.h> @@ -2300,12 +2302,12 @@ ptx_reg_t f2x( ptx_reg_t x, unsigned from_width, unsigned to_width, int to_sign, half_float::half tmp_h; //assert( from_width == 32); - enum cuda_math::cudaRoundMode mode = cuda_math::cudaRoundZero; + enum cudaRoundMode mode = cudaRoundZero; switch (rounding_mode) { - case RZI_OPTION: mode = cuda_math::cudaRoundZero; break; - case RNI_OPTION: mode = cuda_math::cudaRoundNearest; break; - case RMI_OPTION: mode = cuda_math::cudaRoundMinInf; break; - case RPI_OPTION: mode = cuda_math::cudaRoundPosInf; break; + case RZI_OPTION: mode = cudaRoundZero; break; + case RNI_OPTION: mode = cudaRoundNearest; break; + case RMI_OPTION: mode = cudaRoundMinInf; break; + case RPI_OPTION: mode = cudaRoundPosInf; break; default: break; } diff --git a/src/cuda-sim/ptx.l b/src/cuda-sim/ptx.l index 3232361..18952a9 100644 --- a/src/cuda-sim/ptx.l +++ b/src/cuda-sim/ptx.l @@ -31,21 +31,26 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. %option noyywrap %option yylineno %option prefix="ptx_" + +%option bison-bridge +%option reentrant + %{ #include "opcodes.h" +#include "ptx_parser.h" #include "ptx.tab.h" #include <string.h> -#define LINEBUF_SIZE (64*1024) -char linebuf[LINEBUF_SIZE]; -unsigned col = 0; -#define TC col+=strlen(ptx_text); +#define LINEBUF_SIZE (4*1024) +#define TC recognizer->col+=strlen(yytext); #define CHECK_UNSIGNED \ if( yytext[strlen(yytext)-1]=='U' ) { \ printf("GPGPU-Sim: ERROR ** U modifier not implemented\n"); \ abort(); \ } -int ptx_error( const char *s ); +#define YY_DECL int ptx_lex \ + (YYSTYPE * yylval_param , yyscan_t yyscanner, ptx_recognizer* recognizer) +int ptx_error( yyscan_t yyscanner, ptx_recognizer* recognizer, const char *s ); %} %s IN_STRING @@ -54,121 +59,121 @@ int ptx_error( const char *s ); %x NOT_OPCODE %% -abs TC; ptx_lval.int_value = ABS_OP; return OPCODE; -add TC; ptx_lval.int_value = ADD_OP; return OPCODE; -addp TC; ptx_lval.int_value = ADDP_OP; return OPCODE; -addc TC; ptx_lval.int_value = ADDC_OP; return OPCODE; -and TC; ptx_lval.int_value = AND_OP; return OPCODE; -andn TC; ptx_lval.int_value = ANDN_OP; return OPCODE; -atom TC; ptx_lval.int_value = ATOM_OP; return OPCODE; -bar.warp TC; ptx_lval.int_value = NOP_OP; return OPCODE; -bar TC; ptx_lval.int_value = BAR_OP; return OPCODE; -bfe TC; ptx_lval.int_value = BFE_OP; return OPCODE; -bfi TC; ptx_lval.int_value = BFI_OP; return OPCODE; -bfind TC; ptx_lval.int_value = BFIND_OP; return OPCODE; -bra TC; ptx_lval.int_value = BRA_OP; return OPCODE; -brx TC; ptx_lval.int_value = BRX_OP; return OPCODE; -brev TC; ptx_lval.int_value = BREV_OP; return OPCODE; -brkpt TC; ptx_lval.int_value = BRKPT_OP; return OPCODE; +abs TC; yylval->int_value = ABS_OP; return OPCODE; +add TC; yylval->int_value = ADD_OP; return OPCODE; +addp TC; yylval->int_value = ADDP_OP; return OPCODE; +addc TC; yylval->int_value = ADDC_OP; return OPCODE; +and TC; yylval->int_value = AND_OP; return OPCODE; +andn TC; yylval->int_value = ANDN_OP; return OPCODE; +atom TC; yylval->int_value = ATOM_OP; return OPCODE; +bar.warp TC; yylval->int_value = NOP_OP; return OPCODE; +bar TC; yylval->int_value = BAR_OP; return OPCODE; +bfe TC; yylval->int_value = BFE_OP; return OPCODE; +bfi TC; yylval->int_value = BFI_OP; return OPCODE; +bfind TC; yylval->int_value = BFIND_OP; return OPCODE; +bra TC; yylval->int_value = BRA_OP; return OPCODE; +brx TC; yylval->int_value = BRX_OP; return OPCODE; +brev TC; yylval->int_value = BREV_OP; return OPCODE; +brkpt TC; yylval->int_value = BRKPT_OP; return OPCODE; -wmma TC; ptx_lval.int_value = MMA_OP; return OPCODE; -wmma\.load TC; ptx_lval.int_value = MMA_LD_OP; return OPCODE; -wmma\.store TC; ptx_lval.int_value = MMA_ST_OP; return OPCODE; +wmma TC; yylval->int_value = MMA_OP; return OPCODE; +wmma\.load TC; yylval->int_value = MMA_LD_OP; return OPCODE; +wmma\.store TC; yylval->int_value = MMA_ST_OP; return OPCODE; -call TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = CALL_OP; return OPCODE; // blocking opcode token in case the callee has the same name as an opcode -callp TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = CALLP_OP; return OPCODE; -clz TC; ptx_lval.int_value = CLZ_OP; return OPCODE; -cnot TC; ptx_lval.int_value = CNOT_OP; return OPCODE; -cos TC; ptx_lval.int_value = COS_OP; return OPCODE; -cvt TC; ptx_lval.int_value = CVT_OP; return OPCODE; -cvta TC; ptx_lval.int_value = CVTA_OP; return OPCODE; -div TC; ptx_lval.int_value = DIV_OP; return OPCODE; -dp4a TC; ptx_lval.int_value = DP4A_OP; return OPCODE; -ex2 TC; ptx_lval.int_value = EX2_OP; return OPCODE; -exit TC; ptx_lval.int_value = EXIT_OP; return OPCODE; -fma TC; ptx_lval.int_value = FMA_OP; return OPCODE; -isspacep TC; ptx_lval.int_value = ISSPACEP_OP; return OPCODE; -ld TC; ptx_lval.int_value = LD_OP; return OPCODE; -ld.volatile TC; ptx_lval.int_value = LD_OP; return OPCODE; -ldu TC; ptx_lval.int_value = LDU_OP; return OPCODE; -lg2 TC; ptx_lval.int_value = LG2_OP; return OPCODE; -mad24 TC; ptx_lval.int_value = MAD24_OP; return OPCODE; -mad TC; ptx_lval.int_value = MAD_OP; return OPCODE; -madc TC; ptx_lval.int_value = MADC_OP; return OPCODE; -madp TC; ptx_lval.int_value = MADP_OP; return OPCODE; -max TC; ptx_lval.int_value = MAX_OP; return OPCODE; -membar TC; ptx_lval.int_value = MEMBAR_OP; return OPCODE; -min TC; ptx_lval.int_value = MIN_OP; return OPCODE; -mov TC; ptx_lval.int_value = MOV_OP; return OPCODE; -mul24 TC; ptx_lval.int_value = MUL24_OP; return OPCODE; -mul TC; ptx_lval.int_value = MUL_OP; return OPCODE; -neg TC; ptx_lval.int_value = NEG_OP; return OPCODE; -nandn TC; ptx_lval.int_value = NANDN_OP; return OPCODE; -norn TC; ptx_lval.int_value = NORN_OP; return OPCODE; -not TC; ptx_lval.int_value = NOT_OP; return OPCODE; -or TC; ptx_lval.int_value = OR_OP; return OPCODE; -orn TC; ptx_lval.int_value = ORN_OP; return OPCODE; -pmevent TC; ptx_lval.int_value = PMEVENT_OP; return OPCODE; -popc TC; ptx_lval.int_value = POPC_OP; return OPCODE; -prefetch TC; ptx_lval.int_value = PREFETCH_OP; return OPCODE; -prefetchu TC; ptx_lval.int_value = PREFETCHU_OP; return OPCODE; -prmt TC; ptx_lval.int_value = PRMT_OP; return OPCODE; -rcp TC; ptx_lval.int_value = RCP_OP; return OPCODE; -red TC; ptx_lval.int_value = RED_OP; return OPCODE; -rem TC; ptx_lval.int_value = REM_OP; return OPCODE; -ret TC; ptx_lval.int_value = RET_OP; return OPCODE; -retp TC; ptx_lval.int_value = RETP_OP; return OPCODE; -rsqrt TC; ptx_lval.int_value = RSQRT_OP; return OPCODE; -sad TC; ptx_lval.int_value = SAD_OP; return OPCODE; -selp TC; ptx_lval.int_value = SELP_OP; return OPCODE; -setp TC; ptx_lval.int_value = SETP_OP; return OPCODE; -set TC; ptx_lval.int_value = SET_OP; return OPCODE; -shfl TC; ptx_lval.int_value = SHFL_OP; return OPCODE; -shl TC; ptx_lval.int_value = SHL_OP; return OPCODE; -shr TC; ptx_lval.int_value = SHR_OP; return OPCODE; -sin TC; ptx_lval.int_value = SIN_OP; return OPCODE; -slct TC; ptx_lval.int_value = SLCT_OP; return OPCODE; -sqrt TC; ptx_lval.int_value = SQRT_OP; return OPCODE; -sst TC; ptx_lval.int_value = SST_OP; return OPCODE; -ssy TC; ptx_lval.int_value = SSY_OP; return OPCODE; -st TC; ptx_lval.int_value = ST_OP; return OPCODE; -st.volatile TC; ptx_lval.int_value = ST_OP; return OPCODE; -sub TC; ptx_lval.int_value = SUB_OP; return OPCODE; -subc TC; ptx_lval.int_value = SUBC_OP; return OPCODE; -suld TC; ptx_lval.int_value = SULD_OP; return OPCODE; -sured TC; ptx_lval.int_value = SURED_OP; return OPCODE; -surst TC; ptx_lval.int_value = SUST_OP; return OPCODE; -suq TC; ptx_lval.int_value = SUQ_OP; return OPCODE; -tex TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = TEX_OP; return OPCODE; -txq TC; ptx_lval.int_value = TEX_OP; return OPCODE; -trap TC; ptx_lval.int_value = TRAP_OP; return OPCODE; -vabsdiff TC; ptx_lval.int_value = VABSDIFF_OP; return OPCODE; -vadd TC; ptx_lval.int_value = VADD_OP; return OPCODE; -vmad TC; ptx_lval.int_value = VMAD_OP; return OPCODE; -vmax TC; ptx_lval.int_value = VMAX_OP; return OPCODE; -vmin TC; ptx_lval.int_value = VMIN_OP; return OPCODE; -vset TC; ptx_lval.int_value = VSET_OP; return OPCODE; -vshl TC; ptx_lval.int_value = VSHL_OP; return OPCODE; -vshr TC; ptx_lval.int_value = VSHR_OP; return OPCODE; -vsub TC; ptx_lval.int_value = VSUB_OP; return OPCODE; -vote TC; ptx_lval.int_value = VOTE_OP; return OPCODE; -xor TC; ptx_lval.int_value = XOR_OP; return OPCODE; -nop TC; ptx_lval.int_value = NOP_OP; return OPCODE; -break TC; ptx_lval.int_value = BREAK_OP; return OPCODE; -breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; +call TC; BEGIN(NOT_OPCODE); yylval->int_value = CALL_OP; return OPCODE; // blocking opcode token in case the callee has the same name as an opcode +callp TC; BEGIN(NOT_OPCODE); yylval->int_value = CALLP_OP; return OPCODE; +clz TC; yylval->int_value = CLZ_OP; return OPCODE; +cnot TC; yylval->int_value = CNOT_OP; return OPCODE; +cos TC; yylval->int_value = COS_OP; return OPCODE; +cvt TC; yylval->int_value = CVT_OP; return OPCODE; +cvta TC; yylval->int_value = CVTA_OP; return OPCODE; +div TC; yylval->int_value = DIV_OP; return OPCODE; +dp4a TC; yylval->int_value = DP4A_OP; return OPCODE; +ex2 TC; yylval->int_value = EX2_OP; return OPCODE; +exit TC; yylval->int_value = EXIT_OP; return OPCODE; +fma TC; yylval->int_value = FMA_OP; return OPCODE; +isspacep TC; yylval->int_value = ISSPACEP_OP; return OPCODE; +ld TC; yylval->int_value = LD_OP; return OPCODE; +ld.volatile TC; yylval->int_value = LD_OP; return OPCODE; +ldu TC; yylval->int_value = LDU_OP; return OPCODE; +lg2 TC; yylval->int_value = LG2_OP; return OPCODE; +mad24 TC; yylval->int_value = MAD24_OP; return OPCODE; +mad TC; yylval->int_value = MAD_OP; return OPCODE; +madc TC; yylval->int_value = MADC_OP; return OPCODE; +madp TC; yylval->int_value = MADP_OP; return OPCODE; +max TC; yylval->int_value = MAX_OP; return OPCODE; +membar TC; yylval->int_value = MEMBAR_OP; return OPCODE; +min TC; yylval->int_value = MIN_OP; return OPCODE; +mov TC; yylval->int_value = MOV_OP; return OPCODE; +mul24 TC; yylval->int_value = MUL24_OP; return OPCODE; +mul TC; yylval->int_value = MUL_OP; return OPCODE; +neg TC; yylval->int_value = NEG_OP; return OPCODE; +nandn TC; yylval->int_value = NANDN_OP; return OPCODE; +norn TC; yylval->int_value = NORN_OP; return OPCODE; +not TC; yylval->int_value = NOT_OP; return OPCODE; +or TC; yylval->int_value = OR_OP; return OPCODE; +orn TC; yylval->int_value = ORN_OP; return OPCODE; +pmevent TC; yylval->int_value = PMEVENT_OP; return OPCODE; +popc TC; yylval->int_value = POPC_OP; return OPCODE; +prefetch TC; yylval->int_value = PREFETCH_OP; return OPCODE; +prefetchu TC; yylval->int_value = PREFETCHU_OP; return OPCODE; +prmt TC; yylval->int_value = PRMT_OP; return OPCODE; +rcp TC; yylval->int_value = RCP_OP; return OPCODE; +red TC; yylval->int_value = RED_OP; return OPCODE; +rem TC; yylval->int_value = REM_OP; return OPCODE; +ret TC; yylval->int_value = RET_OP; return OPCODE; +retp TC; yylval->int_value = RETP_OP; return OPCODE; +rsqrt TC; yylval->int_value = RSQRT_OP; return OPCODE; +sad TC; yylval->int_value = SAD_OP; return OPCODE; +selp TC; yylval->int_value = SELP_OP; return OPCODE; +setp TC; yylval->int_value = SETP_OP; return OPCODE; +set TC; yylval->int_value = SET_OP; return OPCODE; +shfl TC; yylval->int_value = SHFL_OP; return OPCODE; +shl TC; yylval->int_value = SHL_OP; return OPCODE; +shr TC; yylval->int_value = SHR_OP; return OPCODE; +sin TC; yylval->int_value = SIN_OP; return OPCODE; +slct TC; yylval->int_value = SLCT_OP; return OPCODE; +sqrt TC; yylval->int_value = SQRT_OP; return OPCODE; +sst TC; yylval->int_value = SST_OP; return OPCODE; +ssy TC; yylval->int_value = SSY_OP; return OPCODE; +st TC; yylval->int_value = ST_OP; return OPCODE; +st.volatile TC; yylval->int_value = ST_OP; return OPCODE; +sub TC; yylval->int_value = SUB_OP; return OPCODE; +subc TC; yylval->int_value = SUBC_OP; return OPCODE; +suld TC; yylval->int_value = SULD_OP; return OPCODE; +sured TC; yylval->int_value = SURED_OP; return OPCODE; +surst TC; yylval->int_value = SUST_OP; return OPCODE; +suq TC; yylval->int_value = SUQ_OP; return OPCODE; +tex TC; BEGIN(NOT_OPCODE); yylval->int_value = TEX_OP; return OPCODE; +txq TC; yylval->int_value = TEX_OP; return OPCODE; +trap TC; yylval->int_value = TRAP_OP; return OPCODE; +vabsdiff TC; yylval->int_value = VABSDIFF_OP; return OPCODE; +vadd TC; yylval->int_value = VADD_OP; return OPCODE; +vmad TC; yylval->int_value = VMAD_OP; return OPCODE; +vmax TC; yylval->int_value = VMAX_OP; return OPCODE; +vmin TC; yylval->int_value = VMIN_OP; return OPCODE; +vset TC; yylval->int_value = VSET_OP; return OPCODE; +vshl TC; yylval->int_value = VSHL_OP; return OPCODE; +vshr TC; yylval->int_value = VSHR_OP; return OPCODE; +vsub TC; yylval->int_value = VSUB_OP; return OPCODE; +vote TC; yylval->int_value = VOTE_OP; return OPCODE; +xor TC; yylval->int_value = XOR_OP; return OPCODE; +nop TC; yylval->int_value = NOP_OP; return OPCODE; +break TC; yylval->int_value = BREAK_OP; return OPCODE; +breakaddr TC; yylval->int_value = BREAKADDR_OP; return OPCODE; "CPTX_END" printf("ENDING CUSTOM PTX.\n"); BEGIN(IN_COMMENT); <INITIAL,NOT_OPCODE,IN_INST,IN_FUNC_DECL>{ -\.a\.sync TC; ptx_lval.int_value = LOAD_A; return WMMA_DIRECTIVE; -\.b\.sync TC; ptx_lval.int_value = LOAD_B; return WMMA_DIRECTIVE; -\.c\.sync TC; ptx_lval.int_value = LOAD_C; return WMMA_DIRECTIVE; -\.d\.sync TC; ptx_lval.int_value = STORE_D; return WMMA_DIRECTIVE; -\.mma\.sync TC;ptx_lval.int_value=MMA; return WMMA_DIRECTIVE; +\.a\.sync TC; yylval->int_value = LOAD_A; return WMMA_DIRECTIVE; +\.b\.sync TC; yylval->int_value = LOAD_B; return WMMA_DIRECTIVE; +\.c\.sync TC; yylval->int_value = LOAD_C; return WMMA_DIRECTIVE; +\.d\.sync TC; yylval->int_value = STORE_D; return WMMA_DIRECTIVE; +\.mma\.sync TC;yylval->int_value=MMA; return WMMA_DIRECTIVE; -\.row TC; ptx_lval.int_value = ROW; return LAYOUT; -\.col TC; ptx_lval.int_value = COL; return LAYOUT; -\.m16n16k16 TC; ptx_lval.int_value = M16N16K16; return CONFIGURATION; +\.row TC; yylval->int_value = ROW; return LAYOUT; +\.col TC; yylval->int_value = COL; return LAYOUT; +\.m16n16k16 TC; yylval->int_value = M16N16K16; return CONFIGURATION; \.f4e TC; return PRMT_F4E_MODE; \.b4e TC; return PRMT_B4E_MODE; \.rc8 TC; return PRMT_RC8_MODE; @@ -181,8 +186,8 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; \.byte TC; return BYTE_DIRECTIVE; /* not in PTX 2.1 */ \.callprototype TC; return CALLPROTOTYPE_DIRECTIVE; \.calltargets TC; return CALLTARGETS_DIRECTIVE; -\.const\[[0-9]+\] TC; ptx_lval.int_value = atoi(yytext+7); return CONST_DIRECTIVE; -\.const TC; ptx_lval.int_value = 0; return CONST_DIRECTIVE; +\.const\[[0-9]+\] TC; yylval->int_value = atoi(yytext+7); return CONST_DIRECTIVE; +\.const TC; yylval->int_value = 0; return CONST_DIRECTIVE; \.entry TC; return ENTRY_DIRECTIVE; \.extern TC; return EXTERN_DIRECTIVE; \.file TC; BEGIN(INITIAL); return FILE_DIRECTIVE; @@ -217,40 +222,40 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; \.constptr TC; return CONSTPTR_DIRECTIVE; /* Ptx plus directive for pointer to constant memory */ \.ptr TC; return PTR_DIRECTIVE; /* Added for new OpenCL genrated code */ -"%clock" TC; ptx_lval.int_value = CLOCK_REG; return SPECIAL_REGISTER; -"%halfclock" TC; ptx_lval.int_value = HALFCLOCK_ID; return SPECIAL_REGISTER; -"%clock64" TC; ptx_lval.int_value = CLOCK64_REG; return SPECIAL_REGISTER; -"%ctaid" TC; ptx_lval.int_value = CTAID_REG; return SPECIAL_REGISTER; -"%envreg"[0-9]+ TC; sscanf(yytext+7,"%u",&ptx_lval.int_value); ptx_lval.int_value<<=16; ptx_lval.int_value += ENVREG_REG; return SPECIAL_REGISTER; -"%gridid" TC; ptx_lval.int_value = GRIDID_REG; return SPECIAL_REGISTER; -"%laneid" TC; ptx_lval.int_value = LANEID_REG; return SPECIAL_REGISTER; -"%lanemask_eq" TC; ptx_lval.int_value = LANEMASK_EQ_REG; return SPECIAL_REGISTER; -"%lanemask_le" TC; ptx_lval.int_value = LANEMASK_LE_REG; return SPECIAL_REGISTER; -"%lanemask_lt" TC; ptx_lval.int_value = LANEMASK_LT_REG; return SPECIAL_REGISTER; -"%lanemask_ge" TC; ptx_lval.int_value = LANEMASK_GE_REG; return SPECIAL_REGISTER; -"%lanemask_gt" TC; ptx_lval.int_value = LANEMASK_GT_REG; return SPECIAL_REGISTER; -"%nctaid" TC; ptx_lval.int_value = NCTAID_REG; return SPECIAL_REGISTER; -"%ntid" TC; ptx_lval.int_value = NTID_REG; return SPECIAL_REGISTER; -"%nsmid" TC; ptx_lval.int_value = NSMID_REG; return SPECIAL_REGISTER; -"%nwarpid" TC; ptx_lval.int_value = NWARPID_REG; return SPECIAL_REGISTER; -"%pm"[0-3] TC; sscanf(yytext+3,"%u",&ptx_lval.int_value); ptx_lval.int_value<<=16; ptx_lval.int_value += PM_REG; return SPECIAL_REGISTER; -"%smid" TC; ptx_lval.int_value = SMID_REG; return SPECIAL_REGISTER; -"%tid" TC; ptx_lval.int_value = TID_REG; return SPECIAL_REGISTER; -"%warpid" TC; ptx_lval.int_value = WARPID_REG; return SPECIAL_REGISTER; -"WARP_SZ" TC; ptx_lval.int_value = WARPSZ_REG; return SPECIAL_REGISTER; +"%clock" TC; yylval->int_value = CLOCK_REG; return SPECIAL_REGISTER; +"%halfclock" TC; yylval->int_value = HALFCLOCK_ID; return SPECIAL_REGISTER; +"%clock64" TC; yylval->int_value = CLOCK64_REG; return SPECIAL_REGISTER; +"%ctaid" TC; yylval->int_value = CTAID_REG; return SPECIAL_REGISTER; +"%envreg"[0-9]+ TC; sscanf(yytext+7,"%u",&yylval->int_value); yylval->int_value<<=16; yylval->int_value += ENVREG_REG; return SPECIAL_REGISTER; +"%gridid" TC; yylval->int_value = GRIDID_REG; return SPECIAL_REGISTER; +"%laneid" TC; yylval->int_value = LANEID_REG; return SPECIAL_REGISTER; +"%lanemask_eq" TC; yylval->int_value = LANEMASK_EQ_REG; return SPECIAL_REGISTER; +"%lanemask_le" TC; yylval->int_value = LANEMASK_LE_REG; return SPECIAL_REGISTER; +"%lanemask_lt" TC; yylval->int_value = LANEMASK_LT_REG; return SPECIAL_REGISTER; +"%lanemask_ge" TC; yylval->int_value = LANEMASK_GE_REG; return SPECIAL_REGISTER; +"%lanemask_gt" TC; yylval->int_value = LANEMASK_GT_REG; return SPECIAL_REGISTER; +"%nctaid" TC; yylval->int_value = NCTAID_REG; return SPECIAL_REGISTER; +"%ntid" TC; yylval->int_value = NTID_REG; return SPECIAL_REGISTER; +"%nsmid" TC; yylval->int_value = NSMID_REG; return SPECIAL_REGISTER; +"%nwarpid" TC; yylval->int_value = NWARPID_REG; return SPECIAL_REGISTER; +"%pm"[0-3] TC; sscanf(yytext+3,"%u",&yylval->int_value); yylval->int_value<<=16; yylval->int_value += PM_REG; return SPECIAL_REGISTER; +"%smid" TC; yylval->int_value = SMID_REG; return SPECIAL_REGISTER; +"%tid" TC; yylval->int_value = TID_REG; return SPECIAL_REGISTER; +"%warpid" TC; yylval->int_value = WARPID_REG; return SPECIAL_REGISTER; +"WARP_SZ" TC; yylval->int_value = WARPSZ_REG; return SPECIAL_REGISTER; -[a-zA-Z_][a-zA-Z0-9_$]* TC; ptx_lval.string_value = strdup(yytext); return IDENTIFIER; -[$%][a-zA-Z0-9_$]+ TC; ptx_lval.string_value = strdup(yytext); return IDENTIFIER; +[a-zA-Z_][a-zA-Z0-9_$]* TC; yylval->string_value = strdup(yytext); return IDENTIFIER; +[$%][a-zA-Z0-9_$]+ TC; yylval->string_value = strdup(yytext); return IDENTIFIER; -[0-9]+\.[0-9]+ TC; sscanf(yytext,"%lf", &ptx_lval.double_value); return DOUBLE_OPERAND; +[0-9]+\.[0-9]+ TC; sscanf(yytext,"%lf", &yylval->double_value); return DOUBLE_OPERAND; -0[xX][0-9a-fA-F]+U? TC; CHECK_UNSIGNED; sscanf(yytext,"%x", &ptx_lval.int_value); return INT_OPERAND; +0[xX][0-9a-fA-F]+U? TC; CHECK_UNSIGNED; sscanf(yytext,"%x", &yylval->int_value); return INT_OPERAND; 0[0-7]+U? TC; printf("GPGPU-Sim: ERROR ** parsing octal not (yet) implemented\n"); abort(); return INT_OPERAND; 0[bB][01]+U? TC; printf("GPGPU-Sim: ERROR ** parsing binary not (yet) implemented\n"); abort(); return INT_OPERAND; -[-]?[0-9]+U? TC; CHECK_UNSIGNED; ptx_lval.int_value = atoi(yytext); return INT_OPERAND; +[-]?[0-9]+U? TC; CHECK_UNSIGNED; yylval->int_value = atoi(yytext); return INT_OPERAND; -0[fF][0-9a-fA-F]{8} TC; sscanf(yytext+2,"%x", (unsigned*)(void*)&ptx_lval.float_value); return FLOAT_OPERAND; -0[dD][0-9a-fA-F]{16} TC; sscanf(yytext+2,"%Lx", (unsigned long long*)(void*)&ptx_lval.double_value); return DOUBLE_OPERAND; +0[fF][0-9a-fA-F]{8} TC; sscanf(yytext+2,"%x", (unsigned*)(void*)&yylval->float_value); return FLOAT_OPERAND; +0[dD][0-9a-fA-F]{16} TC; sscanf(yytext+2,"%Lx", (unsigned long long*)(void*)&yylval->double_value); return DOUBLE_OPERAND; \.s8 TC; return S8_TYPE; \.s16 TC; return S16_TYPE; @@ -383,12 +388,12 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; \.2d TC; return GEOM_MODIFIER_2D; \.3d TC; return GEOM_MODIFIER_3D; -\.0 TC; ptx_lval.int_value = 0; return DIMENSION_MODIFIER; -\.1 TC; ptx_lval.int_value = 1; return DIMENSION_MODIFIER; -\.2 TC; ptx_lval.int_value = 2; return DIMENSION_MODIFIER; -\.x TC; ptx_lval.int_value = 0; return DIMENSION_MODIFIER; -\.y TC; ptx_lval.int_value = 1; return DIMENSION_MODIFIER; -\.z TC; ptx_lval.int_value = 2; return DIMENSION_MODIFIER; +\.0 TC; yylval->int_value = 0; return DIMENSION_MODIFIER; +\.1 TC; yylval->int_value = 1; return DIMENSION_MODIFIER; +\.2 TC; yylval->int_value = 2; return DIMENSION_MODIFIER; +\.x TC; yylval->int_value = 0; return DIMENSION_MODIFIER; +\.y TC; yylval->int_value = 1; return DIMENSION_MODIFIER; +\.z TC; yylval->int_value = 2; return DIMENSION_MODIFIER; "-" TC; return MINUS; "+" TC; return PLUS; @@ -411,7 +416,7 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; "//"[^\n]* TC; // eat single -\n.* col=0; strncpy(linebuf, yytext + 1, LINEBUF_SIZE); yyless( 1 ); +\n.* recognizer->col=0; strncpy(recognizer->linebuf, yytext + 1, LINEBUF_SIZE); yyless( 1 ); " " TC; "\t" TC; @@ -439,28 +444,28 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; } <IN_STRING>{ "\"" TC; BEGIN(INITIAL); return STRING; -[^\"]* TC; ptx_lval.string_value = strdup(yytext); +[^\"]* TC; yylval->string_value = strdup(yytext); } <*>\t@@DWARF.*\n -<INITIAL,NOT_OPCODE,IN_FUNC_DECL>. TC; ptx_error((const char*)NULL); +<INITIAL,NOT_OPCODE,IN_FUNC_DECL>. TC; ptx_error(yyscanner, recognizer, (const char*)NULL); %% -extern int g_error_detected; extern const char *g_filename; -int ptx_error( const char *s ) +int ptx_error( yyscan_t yyscanner, ptx_recognizer* recognizer, const char *s ) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; int i; - g_error_detected = 1; + recognizer->g_error_detected = 1; fflush(stdout); if( s != NULL ) - printf("%s:%u: Syntax error:\n\n", g_filename, ptx_lineno ); - printf(" %s\n", linebuf ); + printf("%s:%u Syntax error:\n\n", g_filename, yylineno ); + printf(" %s\n", recognizer->linebuf ); printf(" "); - for( i=0; i < col-1; i++ ) { - if( linebuf[i] == '\t' ) printf("\t"); + for( i=0; i < recognizer->col-1; i++ ) { + if( recognizer->linebuf[i] == '\t' ) printf("\t"); else printf(" "); } diff --git a/src/cuda-sim/ptx.y b/src/cuda-sim/ptx.y index 45392fb..837fbe9 100644 --- a/src/cuda-sim/ptx.y +++ b/src/cuda-sim/ptx.y @@ -27,6 +27,17 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +%{ +typedef void * yyscan_t; +class ptx_recognizer; +%} + +%define api.pure full +%parse-param {yyscan_t scanner} +%parse-param {ptx_recognizer* recognizer} +%lex-param {yyscan_t scanner} +%lex-param {ptx_recognizer* recognizer} + %union { double double_value; float float_value; @@ -217,10 +228,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include <stdlib.h> #include <string.h> #include <math.h> - void syntax_not_implemented(); - extern int g_func_decl; - int ptx_lex(void); - int ptx_error(const char *); + void syntax_not_implemented(yyscan_t yyscanner, ptx_recognizer* recognizer); + int ptx_lex(YYSTYPE * yylval_param, yyscan_t yyscanner, ptx_recognizer* recognizer); + int ptx_error( yyscan_t yyscanner, ptx_recognizer* recognizer, const char *s ); %} %% @@ -231,96 +241,96 @@ input: /* empty */ | input function_decl ; -function_defn: function_decl { set_symtab($1); func_header(".skip"); } statement_block { end_function(); } - | function_decl { set_symtab($1); } block_spec_list { func_header(".skip"); } statement_block { end_function(); } +function_defn: function_decl { recognizer->set_symtab($1); recognizer->func_header(".skip"); } statement_block { recognizer->end_function(); } + | function_decl { recognizer->set_symtab($1); } block_spec_list { recognizer->func_header(".skip"); } statement_block { recognizer->end_function(); } ; -block_spec: MAXNTID_DIRECTIVE INT_OPERAND COMMA INT_OPERAND COMMA INT_OPERAND {func_header_info_int(".maxntid", $2); - func_header_info_int(",", $4); - func_header_info_int(",", $6); - maxnt_id($2, $4, $6);} - | MINNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".minnctapersm", $2); printf("GPGPU-Sim: Warning: .minnctapersm ignored. \n"); } - | MAXNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".maxnctapersm", $2); printf("GPGPU-Sim: Warning: .maxnctapersm ignored. \n"); } +block_spec: MAXNTID_DIRECTIVE INT_OPERAND COMMA INT_OPERAND COMMA INT_OPERAND {recognizer->func_header_info_int(".maxntid", $2); + recognizer->func_header_info_int(",", $4); + recognizer->func_header_info_int(",", $6); + recognizer->maxnt_id($2, $4, $6);} + | MINNCTAPERSM_DIRECTIVE INT_OPERAND { recognizer->func_header_info_int(".minnctapersm", $2); printf("GPGPU-Sim: Warning: .minnctapersm ignored. \n"); } + | MAXNCTAPERSM_DIRECTIVE INT_OPERAND { recognizer->func_header_info_int(".maxnctapersm", $2); printf("GPGPU-Sim: Warning: .maxnctapersm ignored. \n"); } ; block_spec_list: block_spec | block_spec_list block_spec ; -function_decl: function_decl_header LEFT_PAREN { start_function($1); func_header_info("(");} param_entry RIGHT_PAREN {func_header_info(")");} function_ident_param { $$ = reset_symtab(); } - | function_decl_header { start_function($1); } function_ident_param { $$ = reset_symtab(); } - | function_decl_header { start_function($1); add_function_name(""); g_func_decl=0; $$ = reset_symtab(); } +function_decl: function_decl_header LEFT_PAREN { recognizer->start_function($1); recognizer->func_header_info("(");} param_entry RIGHT_PAREN {recognizer->func_header_info(")");} function_ident_param { $$ = recognizer->reset_symtab(); } + | function_decl_header { recognizer->start_function($1); } function_ident_param { $$ = recognizer->reset_symtab(); } + | function_decl_header { recognizer->start_function($1); recognizer->add_function_name(""); recognizer->g_func_decl=0; $$ = recognizer->reset_symtab(); } ; -function_ident_param: IDENTIFIER { add_function_name($1); } LEFT_PAREN {func_header_info("(");} param_list RIGHT_PAREN { g_func_decl=0; func_header_info(")"); } - | IDENTIFIER { add_function_name($1); g_func_decl=0; } +function_ident_param: IDENTIFIER { recognizer->add_function_name($1); } LEFT_PAREN {recognizer->func_header_info("(");} param_list RIGHT_PAREN { recognizer->g_func_decl=0; recognizer->func_header_info(")"); } + | IDENTIFIER { recognizer->add_function_name($1); recognizer->g_func_decl=0; } ; -function_decl_header: ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); } - | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); } - | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); } - | FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); } - | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); } - | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); } - | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; g_func_decl=1; func_header(".func"); } - | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); } +function_decl_header: ENTRY_DIRECTIVE { $$ = 1; recognizer->g_func_decl=1; recognizer->func_header(".entry"); } + | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; recognizer->g_func_decl=1; recognizer->func_header(".entry"); } + | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; recognizer->g_func_decl=1; recognizer->func_header(".entry"); } + | FUNC_DIRECTIVE { $$ = 0; recognizer->g_func_decl=1; recognizer->func_header(".func"); } + | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; recognizer->g_func_decl=1; recognizer->func_header(".func"); } + | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; recognizer->g_func_decl=1; recognizer->func_header(".func"); } + | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; recognizer->g_func_decl=1; recognizer->func_header(".func"); } + | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; recognizer->g_func_decl=1; recognizer->func_header(".func"); } ; param_list: /*empty*/ - | param_entry { add_directive(); } - | param_list COMMA {func_header_info(",");} param_entry { add_directive(); } + | param_entry { recognizer->add_directive(); } + | param_list COMMA {recognizer->func_header_info(",");} param_entry { recognizer->add_directive(); } -param_entry: PARAM_DIRECTIVE { add_space_spec(param_space_unclassified,0); } variable_spec ptr_spec identifier_spec { add_function_arg(); } - | REG_DIRECTIVE { add_space_spec(reg_space,0); } variable_spec identifier_spec { add_function_arg(); } +param_entry: PARAM_DIRECTIVE { recognizer->add_space_spec(param_space_unclassified,0); } variable_spec ptr_spec identifier_spec { recognizer->add_function_arg(); } + | REG_DIRECTIVE { recognizer->add_space_spec(reg_space,0); } variable_spec identifier_spec { recognizer->add_function_arg(); } ptr_spec: /*empty*/ | PTR_DIRECTIVE ptr_space_spec ptr_align_spec | PTR_DIRECTIVE ptr_align_spec -ptr_space_spec: GLOBAL_DIRECTIVE { add_ptr_spec(global_space); } - | LOCAL_DIRECTIVE { add_ptr_spec(local_space); } - | SHARED_DIRECTIVE { add_ptr_spec(shared_space); } - | CONST_DIRECTIVE { add_ptr_spec(global_space); } +ptr_space_spec: GLOBAL_DIRECTIVE { recognizer->add_ptr_spec(global_space); } + | LOCAL_DIRECTIVE { recognizer->add_ptr_spec(local_space); } + | SHARED_DIRECTIVE { recognizer->add_ptr_spec(shared_space); } + | CONST_DIRECTIVE { recognizer->add_ptr_spec(global_space); } ptr_align_spec: ALIGN_DIRECTIVE INT_OPERAND statement_block: LEFT_BRACE statement_list RIGHT_BRACE -statement_list: directive_statement { add_directive(); } - | instruction_statement { add_instruction(); } - | statement_list directive_statement { add_directive(); } - | statement_list instruction_statement { add_instruction(); } - | statement_list {start_inst_group();} statement_block {end_inst_group();} - | {start_inst_group();} statement_block {end_inst_group();} +statement_list: directive_statement { recognizer->add_directive(); } + | instruction_statement { recognizer->add_instruction(); } + | statement_list directive_statement { recognizer->add_directive(); } + | statement_list instruction_statement { recognizer->add_instruction(); } + | statement_list {recognizer->start_inst_group();} statement_block {recognizer->end_inst_group();} + | {recognizer->start_inst_group();} statement_block {recognizer->end_inst_group();} ; directive_statement: variable_declaration SEMI_COLON - | VERSION_DIRECTIVE DOUBLE_OPERAND { add_version_info($2, 0); } - | VERSION_DIRECTIVE DOUBLE_OPERAND PLUS { add_version_info($2,1); } + | VERSION_DIRECTIVE DOUBLE_OPERAND { recognizer->add_version_info($2, 0); } + | VERSION_DIRECTIVE DOUBLE_OPERAND PLUS { recognizer->add_version_info($2,1); } | ADDRESS_SIZE_DIRECTIVE INT_OPERAND {/*Do nothing*/} - | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER { target_header2($2,$4); } - | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER { target_header3($2,$4,$6); } - | TARGET_DIRECTIVE IDENTIFIER { target_header($2); } - | FILE_DIRECTIVE INT_OPERAND STRING { add_file($2,$3); } - | FILE_DIRECTIVE INT_OPERAND STRING COMMA INT_OPERAND COMMA INT_OPERAND { add_file($2,$3); } + | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER { recognizer->target_header2($2,$4); } + | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER { recognizer->target_header3($2,$4,$6); } + | TARGET_DIRECTIVE IDENTIFIER { recognizer->target_header($2); } + | FILE_DIRECTIVE INT_OPERAND STRING { recognizer->add_file($2,$3); } + | FILE_DIRECTIVE INT_OPERAND STRING COMMA INT_OPERAND COMMA INT_OPERAND { recognizer->add_file($2,$3); } | LOC_DIRECTIVE INT_OPERAND INT_OPERAND INT_OPERAND - | PRAGMA_DIRECTIVE STRING SEMI_COLON { add_pragma($2); } + | PRAGMA_DIRECTIVE STRING SEMI_COLON { recognizer->add_pragma($2); } | function_decl SEMI_COLON {/*Do nothing*/} ; -variable_declaration: variable_spec identifier_list { add_variables(); } - | variable_spec identifier_spec EQUALS initializer_list { add_variables(); } - | variable_spec identifier_spec EQUALS literal_operand { add_variables(); } - | CONSTPTR_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA INT_OPERAND { add_constptr($2, $4, $6); } +variable_declaration: variable_spec identifier_list { recognizer->add_variables(); } + | variable_spec identifier_spec EQUALS initializer_list { recognizer->add_variables(); } + | variable_spec identifier_spec EQUALS literal_operand { recognizer->add_variables(); } + | CONSTPTR_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA INT_OPERAND { recognizer->add_constptr($2, $4, $6); } ; -variable_spec: var_spec_list { set_variable_type(); } +variable_spec: var_spec_list { recognizer->set_variable_type(); } identifier_list: identifier_spec | identifier_list COMMA identifier_spec; -identifier_spec: IDENTIFIER { add_identifier($1,0,NON_ARRAY_IDENTIFIER); func_header_info($1);} - | IDENTIFIER LEFT_ANGLE_BRACKET INT_OPERAND RIGHT_ANGLE_BRACKET { func_header_info($1); func_header_info_int("<", $3); func_header_info(">"); +identifier_spec: IDENTIFIER { recognizer->add_identifier($1,0,NON_ARRAY_IDENTIFIER); recognizer->func_header_info($1);} + | IDENTIFIER LEFT_ANGLE_BRACKET INT_OPERAND RIGHT_ANGLE_BRACKET { recognizer->func_header_info($1); recognizer->func_header_info_int("<", $3); recognizer->func_header_info(">"); int i,lbase,l; char *id = NULL; lbase = strlen($1); @@ -328,12 +338,12 @@ identifier_spec: IDENTIFIER { add_identifier($1,0,NON_ARRAY_IDENTIFIER); func_he l = lbase + (int)log10(i+1)+10; id = (char*) malloc(l); snprintf(id,l,"%s%u",$1,i); - add_identifier(id,0,NON_ARRAY_IDENTIFIER); + recognizer->add_identifier(id,0,NON_ARRAY_IDENTIFIER); } free($1); } - | IDENTIFIER LEFT_SQUARE_BRACKET RIGHT_SQUARE_BRACKET { add_identifier($1,0,ARRAY_IDENTIFIER_NO_DIM); func_header_info($1); func_header_info("["); func_header_info("]");} - | IDENTIFIER LEFT_SQUARE_BRACKET INT_OPERAND RIGHT_SQUARE_BRACKET { add_identifier($1,$3,ARRAY_IDENTIFIER); func_header_info($1); func_header_info_int("[",$3); func_header_info("]");} + | IDENTIFIER LEFT_SQUARE_BRACKET RIGHT_SQUARE_BRACKET { recognizer->add_identifier($1,0,ARRAY_IDENTIFIER_NO_DIM); recognizer->func_header_info($1); recognizer->func_header_info("["); recognizer->func_header_info("]");} + | IDENTIFIER LEFT_SQUARE_BRACKET INT_OPERAND RIGHT_SQUARE_BRACKET { recognizer->add_identifier($1,$3,ARRAY_IDENTIFIER); recognizer->func_header_info($1); recognizer->func_header_info_int("[",$3); recognizer->func_header_info("]");} ; var_spec_list: var_spec @@ -343,93 +353,93 @@ var_spec: space_spec | type_spec | align_spec | VISIBLE_DIRECTIVE - | EXTERN_DIRECTIVE { add_extern_spec(); } + | EXTERN_DIRECTIVE { recognizer->add_extern_spec(); } | WEAK_DIRECTIVE ; -align_spec: ALIGN_DIRECTIVE INT_OPERAND { add_alignment_spec($2); } +align_spec: ALIGN_DIRECTIVE INT_OPERAND { recognizer->add_alignment_spec($2); } -space_spec: REG_DIRECTIVE { add_space_spec(reg_space,0); } - | SREG_DIRECTIVE { add_space_spec(reg_space,0); } +space_spec: REG_DIRECTIVE { recognizer->add_space_spec(reg_space,0); } + | SREG_DIRECTIVE { recognizer->add_space_spec(reg_space,0); } | addressable_spec ; -addressable_spec: CONST_DIRECTIVE { add_space_spec(const_space,$1); } - | GLOBAL_DIRECTIVE { add_space_spec(global_space,0); } - | LOCAL_DIRECTIVE { add_space_spec(local_space,0); } - | PARAM_DIRECTIVE { add_space_spec(param_space_unclassified,0); } - | SHARED_DIRECTIVE { add_space_spec(shared_space,0); } - | SSTARR_DIRECTIVE { add_space_spec(sstarr_space,0); } - | SURF_DIRECTIVE { add_space_spec(surf_space,0); } - | TEX_DIRECTIVE { add_space_spec(tex_space,0); } +addressable_spec: CONST_DIRECTIVE { recognizer->add_space_spec(const_space,$1); } + | GLOBAL_DIRECTIVE { recognizer->add_space_spec(global_space,0); } + | LOCAL_DIRECTIVE { recognizer->add_space_spec(local_space,0); } + | PARAM_DIRECTIVE { recognizer->add_space_spec(param_space_unclassified,0); } + | SHARED_DIRECTIVE { recognizer->add_space_spec(shared_space,0); } + | SSTARR_DIRECTIVE { recognizer->add_space_spec(sstarr_space,0); } + | SURF_DIRECTIVE { recognizer->add_space_spec(surf_space,0); } + | TEX_DIRECTIVE { recognizer->add_space_spec(tex_space,0); } ; type_spec: scalar_type | vector_spec scalar_type ; -vector_spec: V2_TYPE { add_option(V2_TYPE); func_header_info(".v2");} - | V3_TYPE { add_option(V3_TYPE); func_header_info(".v3");} - | V4_TYPE { add_option(V4_TYPE); func_header_info(".v4");} +vector_spec: V2_TYPE { recognizer->add_option(V2_TYPE); recognizer->func_header_info(".v2");} + | V3_TYPE { recognizer->add_option(V3_TYPE); recognizer->func_header_info(".v3");} + | V4_TYPE { recognizer->add_option(V4_TYPE); recognizer->func_header_info(".v4");} ; -scalar_type: S8_TYPE { add_scalar_type_spec( S8_TYPE ); } - | S16_TYPE { add_scalar_type_spec( S16_TYPE ); } - | S32_TYPE { add_scalar_type_spec( S32_TYPE ); } - | S64_TYPE { add_scalar_type_spec( S64_TYPE ); } - | U8_TYPE { add_scalar_type_spec( U8_TYPE ); } - | U16_TYPE { add_scalar_type_spec( U16_TYPE ); } - | U32_TYPE { add_scalar_type_spec( U32_TYPE ); } - | U64_TYPE { add_scalar_type_spec( U64_TYPE ); } - | F16_TYPE { add_scalar_type_spec( F16_TYPE ); } - | F32_TYPE { add_scalar_type_spec( F32_TYPE ); } - | F64_TYPE { add_scalar_type_spec( F64_TYPE ); } - | FF64_TYPE { add_scalar_type_spec( FF64_TYPE ); } - | B8_TYPE { add_scalar_type_spec( B8_TYPE ); } - | B16_TYPE { add_scalar_type_spec( B16_TYPE ); } - | B32_TYPE { add_scalar_type_spec( B32_TYPE ); } - | B64_TYPE { add_scalar_type_spec( B64_TYPE ); } - | BB64_TYPE { add_scalar_type_spec( BB64_TYPE ); } - | BB128_TYPE { add_scalar_type_spec( BB128_TYPE ); } - | PRED_TYPE { add_scalar_type_spec( PRED_TYPE ); } - | TEXREF_TYPE { add_scalar_type_spec( TEXREF_TYPE ); } - | SAMPLERREF_TYPE { add_scalar_type_spec( SAMPLERREF_TYPE ); } - | SURFREF_TYPE { add_scalar_type_spec( SURFREF_TYPE ); } +scalar_type: S8_TYPE { recognizer->add_scalar_type_spec( S8_TYPE ); } + | S16_TYPE { recognizer->add_scalar_type_spec( S16_TYPE ); } + | S32_TYPE { recognizer->add_scalar_type_spec( S32_TYPE ); } + | S64_TYPE { recognizer->add_scalar_type_spec( S64_TYPE ); } + | U8_TYPE { recognizer->add_scalar_type_spec( U8_TYPE ); } + | U16_TYPE { recognizer->add_scalar_type_spec( U16_TYPE ); } + | U32_TYPE { recognizer->add_scalar_type_spec( U32_TYPE ); } + | U64_TYPE { recognizer->add_scalar_type_spec( U64_TYPE ); } + | F16_TYPE { recognizer->add_scalar_type_spec( F16_TYPE ); } + | F32_TYPE { recognizer->add_scalar_type_spec( F32_TYPE ); } + | F64_TYPE { recognizer->add_scalar_type_spec( F64_TYPE ); } + | FF64_TYPE { recognizer->add_scalar_type_spec( FF64_TYPE ); } + | B8_TYPE { recognizer->add_scalar_type_spec( B8_TYPE ); } + | B16_TYPE { recognizer->add_scalar_type_spec( B16_TYPE ); } + | B32_TYPE { recognizer->add_scalar_type_spec( B32_TYPE ); } + | B64_TYPE { recognizer->add_scalar_type_spec( B64_TYPE ); } + | BB64_TYPE { recognizer->add_scalar_type_spec( BB64_TYPE ); } + | BB128_TYPE { recognizer->add_scalar_type_spec( BB128_TYPE ); } + | PRED_TYPE { recognizer->add_scalar_type_spec( PRED_TYPE ); } + | TEXREF_TYPE { recognizer->add_scalar_type_spec( TEXREF_TYPE ); } + | SAMPLERREF_TYPE { recognizer->add_scalar_type_spec( SAMPLERREF_TYPE ); } + | SURFREF_TYPE { recognizer->add_scalar_type_spec( SURFREF_TYPE ); } ; -initializer_list: LEFT_BRACE literal_list RIGHT_BRACE { add_array_initializer(); } - | LEFT_BRACE initializer_list RIGHT_BRACE { syntax_not_implemented(); } +initializer_list: LEFT_BRACE literal_list RIGHT_BRACE { recognizer->add_array_initializer(); } + | LEFT_BRACE initializer_list RIGHT_BRACE { syntax_not_implemented(scanner, recognizer); } literal_list: literal_operand | literal_list COMMA literal_operand; instruction_statement: instruction SEMI_COLON - | IDENTIFIER COLON { add_label($1); } + | IDENTIFIER COLON { recognizer->add_label($1); } | pred_spec instruction SEMI_COLON; -instruction: opcode_spec LEFT_PAREN operand RIGHT_PAREN { set_return(); } COMMA operand COMMA LEFT_PAREN operand_list RIGHT_PAREN +instruction: opcode_spec LEFT_PAREN operand RIGHT_PAREN { recognizer->set_return(); } COMMA operand COMMA LEFT_PAREN operand_list RIGHT_PAREN | opcode_spec operand COMMA LEFT_PAREN operand_list RIGHT_PAREN | opcode_spec operand COMMA LEFT_PAREN RIGHT_PAREN | opcode_spec operand_list | opcode_spec ; -opcode_spec: OPCODE { add_opcode($1); } option_list - | OPCODE { add_opcode($1); } +opcode_spec: OPCODE { recognizer->add_opcode($1); } option_list + | OPCODE { recognizer->add_opcode($1); } -pred_spec: PRED IDENTIFIER { add_pred($2,0, -1); } - | PRED EXCLAMATION IDENTIFIER { add_pred($3,1, -1); } - | PRED IDENTIFIER LT_OPTION { add_pred($2,0,1); } - | PRED IDENTIFIER EQ_OPTION { add_pred($2,0,2); } - | PRED IDENTIFIER LE_OPTION { add_pred($2,0,3); } - | PRED IDENTIFIER NE_OPTION { add_pred($2,0,5); } - | PRED IDENTIFIER GE_OPTION { add_pred($2,0,6); } - | PRED IDENTIFIER EQU_OPTION { add_pred($2,0,10); } - | PRED IDENTIFIER GTU_OPTION { add_pred($2,0,12); } - | PRED IDENTIFIER NEU_OPTION { add_pred($2,0,13); } - | PRED IDENTIFIER CF_OPTION { add_pred($2,0,17); } - | PRED IDENTIFIER SF_OPTION { add_pred($2,0,19); } - | PRED IDENTIFIER NSF_OPTION { add_pred($2,0,28); } +pred_spec: PRED IDENTIFIER { recognizer->add_pred($2,0, -1); } + | PRED EXCLAMATION IDENTIFIER { recognizer->add_pred($3,1, -1); } + | PRED IDENTIFIER LT_OPTION { recognizer->add_pred($2,0,1); } + | PRED IDENTIFIER EQ_OPTION { recognizer->add_pred($2,0,2); } + | PRED IDENTIFIER LE_OPTION { recognizer->add_pred($2,0,3); } + | PRED IDENTIFIER NE_OPTION { recognizer->add_pred($2,0,5); } + | PRED IDENTIFIER GE_OPTION { recognizer->add_pred($2,0,6); } + | PRED IDENTIFIER EQU_OPTION { recognizer->add_pred($2,0,10); } + | PRED IDENTIFIER GTU_OPTION { recognizer->add_pred($2,0,12); } + | PRED IDENTIFIER NEU_OPTION { recognizer->add_pred($2,0,13); } + | PRED IDENTIFIER CF_OPTION { recognizer->add_pred($2,0,17); } + | PRED IDENTIFIER SF_OPTION { recognizer->add_pred($2,0,19); } + | PRED IDENTIFIER NSF_OPTION { recognizer->add_pred($2,0,28); } ; option_list: option @@ -441,108 +451,108 @@ option: type_spec | rounding_mode | wmma_spec | prmt_spec - | SYNC_OPTION { add_option(SYNC_OPTION); } - | ARRIVE_OPTION { add_option(ARRIVE_OPTION); } - | RED_OPTION { add_option(RED_OPTION); } - | UNI_OPTION { add_option(UNI_OPTION); } - | WIDE_OPTION { add_option(WIDE_OPTION); } - | ANY_OPTION { add_option(ANY_OPTION); } - | ALL_OPTION { add_option(ALL_OPTION); } - | BALLOT_OPTION { add_option(BALLOT_OPTION); } - | GLOBAL_OPTION { add_option(GLOBAL_OPTION); } - | CTA_OPTION { add_option(CTA_OPTION); } - | SYS_OPTION { add_option(SYS_OPTION); } - | GEOM_MODIFIER_1D { add_option(GEOM_MODIFIER_1D); } - | GEOM_MODIFIER_2D { add_option(GEOM_MODIFIER_2D); } - | GEOM_MODIFIER_3D { add_option(GEOM_MODIFIER_3D); } - | SAT_OPTION { add_option(SAT_OPTION); } - | FTZ_OPTION { add_option(FTZ_OPTION); } - | NEG_OPTION { add_option(NEG_OPTION); } - | APPROX_OPTION { add_option(APPROX_OPTION); } - | FULL_OPTION { add_option(FULL_OPTION); } - | EXIT_OPTION { add_option(EXIT_OPTION); } - | ABS_OPTION { add_option(ABS_OPTION); } + | SYNC_OPTION { recognizer->add_option(SYNC_OPTION); } + | ARRIVE_OPTION { recognizer->add_option(ARRIVE_OPTION); } + | RED_OPTION { recognizer->add_option(RED_OPTION); } + | UNI_OPTION { recognizer->add_option(UNI_OPTION); } + | WIDE_OPTION { recognizer->add_option(WIDE_OPTION); } + | ANY_OPTION { recognizer->add_option(ANY_OPTION); } + | ALL_OPTION { recognizer->add_option(ALL_OPTION); } + | BALLOT_OPTION { recognizer->add_option(BALLOT_OPTION); } + | GLOBAL_OPTION { recognizer->add_option(GLOBAL_OPTION); } + | CTA_OPTION { recognizer->add_option(CTA_OPTION); } + | SYS_OPTION { recognizer->add_option(SYS_OPTION); } + | GEOM_MODIFIER_1D { recognizer->add_option(GEOM_MODIFIER_1D); } + | GEOM_MODIFIER_2D { recognizer->add_option(GEOM_MODIFIER_2D); } + | GEOM_MODIFIER_3D { recognizer->add_option(GEOM_MODIFIER_3D); } + | SAT_OPTION { recognizer->add_option(SAT_OPTION); } + | FTZ_OPTION { recognizer->add_option(FTZ_OPTION); } + | NEG_OPTION { recognizer->add_option(NEG_OPTION); } + | APPROX_OPTION { recognizer->add_option(APPROX_OPTION); } + | FULL_OPTION { recognizer->add_option(FULL_OPTION); } + | EXIT_OPTION { recognizer->add_option(EXIT_OPTION); } + | ABS_OPTION { recognizer->add_option(ABS_OPTION); } | atomic_operation_spec ; - | TO_OPTION { add_option(TO_OPTION); } - | HALF_OPTION { add_option(HALF_OPTION); } - | EXTP_OPTION { add_option(EXTP_OPTION); } - | CA_OPTION { add_option(CA_OPTION); } - | CG_OPTION { add_option(CG_OPTION); } - | CS_OPTION { add_option(CS_OPTION); } - | LU_OPTION { add_option(LU_OPTION); } - | CV_OPTION { add_option(CV_OPTION); } - | WB_OPTION { add_option(WB_OPTION); } - | WT_OPTION { add_option(WT_OPTION); } - | NC_OPTION { add_option(NC_OPTION); } - | UP_OPTION { add_option(UP_OPTION); } - | DOWN_OPTION { add_option(DOWN_OPTION); } - | BFLY_OPTION { add_option(BFLY_OPTION); } - | IDX_OPTION { add_option(IDX_OPTION); } + | TO_OPTION { recognizer->add_option(TO_OPTION); } + | HALF_OPTION { recognizer->add_option(HALF_OPTION); } + | EXTP_OPTION { recognizer->add_option(EXTP_OPTION); } + | CA_OPTION { recognizer->add_option(CA_OPTION); } + | CG_OPTION { recognizer->add_option(CG_OPTION); } + | CS_OPTION { recognizer->add_option(CS_OPTION); } + | LU_OPTION { recognizer->add_option(LU_OPTION); } + | CV_OPTION { recognizer->add_option(CV_OPTION); } + | WB_OPTION { recognizer->add_option(WB_OPTION); } + | WT_OPTION { recognizer->add_option(WT_OPTION); } + | NC_OPTION { recognizer->add_option(NC_OPTION); } + | UP_OPTION { recognizer->add_option(UP_OPTION); } + | DOWN_OPTION { recognizer->add_option(DOWN_OPTION); } + | BFLY_OPTION { recognizer->add_option(BFLY_OPTION); } + | IDX_OPTION { recognizer->add_option(IDX_OPTION); } ; -atomic_operation_spec: ATOMIC_AND { add_option(ATOMIC_AND); } - | ATOMIC_POPC { add_option(ATOMIC_POPC); } - | ATOMIC_OR { add_option(ATOMIC_OR); } - | ATOMIC_XOR { add_option(ATOMIC_XOR); } - | ATOMIC_CAS { add_option(ATOMIC_CAS); } - | ATOMIC_EXCH { add_option(ATOMIC_EXCH); } - | ATOMIC_ADD { add_option(ATOMIC_ADD); } - | ATOMIC_INC { add_option(ATOMIC_INC); } - | ATOMIC_DEC { add_option(ATOMIC_DEC); } - | ATOMIC_MIN { add_option(ATOMIC_MIN); } - | ATOMIC_MAX { add_option(ATOMIC_MAX); } +atomic_operation_spec: ATOMIC_AND { recognizer->add_option(ATOMIC_AND); } + | ATOMIC_POPC { recognizer->add_option(ATOMIC_POPC); } + | ATOMIC_OR { recognizer->add_option(ATOMIC_OR); } + | ATOMIC_XOR { recognizer->add_option(ATOMIC_XOR); } + | ATOMIC_CAS { recognizer->add_option(ATOMIC_CAS); } + | ATOMIC_EXCH { recognizer->add_option(ATOMIC_EXCH); } + | ATOMIC_ADD { recognizer->add_option(ATOMIC_ADD); } + | ATOMIC_INC { recognizer->add_option(ATOMIC_INC); } + | ATOMIC_DEC { recognizer->add_option(ATOMIC_DEC); } + | ATOMIC_MIN { recognizer->add_option(ATOMIC_MIN); } + | ATOMIC_MAX { recognizer->add_option(ATOMIC_MAX); } ; rounding_mode: floating_point_rounding_mode | integer_rounding_mode; -floating_point_rounding_mode: RN_OPTION { add_option(RN_OPTION); } - | RZ_OPTION { add_option(RZ_OPTION); } - | RM_OPTION { add_option(RM_OPTION); } - | RP_OPTION { add_option(RP_OPTION); } +floating_point_rounding_mode: RN_OPTION { recognizer->add_option(RN_OPTION); } + | RZ_OPTION { recognizer->add_option(RZ_OPTION); } + | RM_OPTION { recognizer->add_option(RM_OPTION); } + | RP_OPTION { recognizer->add_option(RP_OPTION); } ; -integer_rounding_mode: RNI_OPTION { add_option(RNI_OPTION); } - | RZI_OPTION { add_option(RZI_OPTION); } - | RMI_OPTION { add_option(RMI_OPTION); } - | RPI_OPTION { add_option(RPI_OPTION); } +integer_rounding_mode: RNI_OPTION { recognizer->add_option(RNI_OPTION); } + | RZI_OPTION { recognizer->add_option(RZI_OPTION); } + | RMI_OPTION { recognizer->add_option(RMI_OPTION); } + | RPI_OPTION { recognizer->add_option(RPI_OPTION); } ; -compare_spec:EQ_OPTION { add_option(EQ_OPTION); } - | NE_OPTION { add_option(NE_OPTION); } - | LT_OPTION { add_option(LT_OPTION); } - | LE_OPTION { add_option(LE_OPTION); } - | GT_OPTION { add_option(GT_OPTION); } - | GE_OPTION { add_option(GE_OPTION); } - | LO_OPTION { add_option(LO_OPTION); } - | LS_OPTION { add_option(LS_OPTION); } - | HI_OPTION { add_option(HI_OPTION); } - | HS_OPTION { add_option(HS_OPTION); } - | EQU_OPTION { add_option(EQU_OPTION); } - | NEU_OPTION { add_option(NEU_OPTION); } - | LTU_OPTION { add_option(LTU_OPTION); } - | LEU_OPTION { add_option(LEU_OPTION); } - | GTU_OPTION { add_option(GTU_OPTION); } - | GEU_OPTION { add_option(GEU_OPTION); } - | NUM_OPTION { add_option(NUM_OPTION); } - | NAN_OPTION { add_option(NAN_OPTION); } +compare_spec:EQ_OPTION { recognizer->add_option(EQ_OPTION); } + | NE_OPTION { recognizer->add_option(NE_OPTION); } + | LT_OPTION { recognizer->add_option(LT_OPTION); } + | LE_OPTION { recognizer->add_option(LE_OPTION); } + | GT_OPTION { recognizer->add_option(GT_OPTION); } + | GE_OPTION { recognizer->add_option(GE_OPTION); } + | LO_OPTION { recognizer->add_option(LO_OPTION); } + | LS_OPTION { recognizer->add_option(LS_OPTION); } + | HI_OPTION { recognizer->add_option(HI_OPTION); } + | HS_OPTION { recognizer->add_option(HS_OPTION); } + | EQU_OPTION { recognizer->add_option(EQU_OPTION); } + | NEU_OPTION { recognizer->add_option(NEU_OPTION); } + | LTU_OPTION { recognizer->add_option(LTU_OPTION); } + | LEU_OPTION { recognizer->add_option(LEU_OPTION); } + | GTU_OPTION { recognizer->add_option(GTU_OPTION); } + | GEU_OPTION { recognizer->add_option(GEU_OPTION); } + | NUM_OPTION { recognizer->add_option(NUM_OPTION); } + | NAN_OPTION { recognizer->add_option(NAN_OPTION); } ; -prmt_spec: PRMT_F4E_MODE { add_option( PRMT_F4E_MODE); } - | PRMT_B4E_MODE { add_option( PRMT_B4E_MODE); } - | PRMT_RC8_MODE { add_option( PRMT_RC8_MODE); } - | PRMT_RC16_MODE{ add_option( PRMT_RC16_MODE);} - | PRMT_ECL_MODE { add_option( PRMT_ECL_MODE); } - | PRMT_ECR_MODE { add_option( PRMT_ECR_MODE); } +prmt_spec: PRMT_F4E_MODE { recognizer->add_option( PRMT_F4E_MODE); } + | PRMT_B4E_MODE { recognizer->add_option( PRMT_B4E_MODE); } + | PRMT_RC8_MODE { recognizer->add_option( PRMT_RC8_MODE); } + | PRMT_RC16_MODE{ recognizer->add_option( PRMT_RC16_MODE);} + | PRMT_ECL_MODE { recognizer->add_option( PRMT_ECL_MODE); } + | PRMT_ECR_MODE { recognizer->add_option( PRMT_ECR_MODE); } ; -wmma_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ptr_spec(global_space); add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);} - | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);add_wmma_option($4);} +wmma_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{recognizer->add_space_spec(global_space,0);recognizer->add_ptr_spec(global_space); recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);} + | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);recognizer->add_wmma_option($4);} ; -vp_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ptr_spec(global_space);add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);} - | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);add_wmma_option($4);} +vp_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{recognizer->add_space_spec(global_space,0);recognizer->add_ptr_spec(global_space);recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);} + | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);recognizer->add_wmma_option($4);} ; @@ -550,80 +560,79 @@ vp_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ operand_list: operand | operand COMMA operand_list; -operand: IDENTIFIER { add_scalar_operand( $1 ); } - | EXCLAMATION IDENTIFIER { add_neg_pred_operand( $2 ); } - | MINUS IDENTIFIER { add_scalar_operand( $2 ); change_operand_neg(); } +operand: IDENTIFIER { recognizer->add_scalar_operand( $1 ); } + | EXCLAMATION IDENTIFIER { recognizer->add_neg_pred_operand( $2 ); } + | MINUS IDENTIFIER { recognizer->add_scalar_operand( $2 ); recognizer->change_operand_neg(); } | memory_operand | literal_operand | builtin_operand | vector_operand - | MINUS vector_operand { change_operand_neg(); } + | MINUS vector_operand { recognizer->change_operand_neg(); } | tex_operand - | IDENTIFIER PLUS INT_OPERAND { add_address_operand($1,$3); } - | IDENTIFIER LO_OPTION { add_scalar_operand( $1 ); change_operand_lohi(1);} - | MINUS IDENTIFIER LO_OPTION { add_scalar_operand( $2 ); change_operand_lohi(1); change_operand_neg();} - | IDENTIFIER HI_OPTION { add_scalar_operand( $1 ); change_operand_lohi(2);} - | MINUS IDENTIFIER HI_OPTION { add_scalar_operand( $2 ); change_operand_lohi(2); change_operand_neg();} - | IDENTIFIER PIPE IDENTIFIER { add_2vector_operand($1,$3); change_double_operand_type(-1);} - | IDENTIFIER PIPE IDENTIFIER LO_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-1); change_operand_lohi(1);} - | IDENTIFIER PIPE IDENTIFIER HI_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-1); change_operand_lohi(2);} - | IDENTIFIER BACKSLASH IDENTIFIER { add_2vector_operand($1,$3); change_double_operand_type(-3);} - | IDENTIFIER BACKSLASH IDENTIFIER LO_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-3); change_operand_lohi(1);} - | IDENTIFIER BACKSLASH IDENTIFIER HI_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-3); change_operand_lohi(2);} + | IDENTIFIER PLUS INT_OPERAND { recognizer->add_address_operand($1,$3); } + | IDENTIFIER LO_OPTION { recognizer->add_scalar_operand( $1 ); recognizer->change_operand_lohi(1);} + | MINUS IDENTIFIER LO_OPTION { recognizer->add_scalar_operand( $2 ); recognizer->change_operand_lohi(1); recognizer->change_operand_neg();} + | IDENTIFIER HI_OPTION { recognizer->add_scalar_operand( $1 ); recognizer->change_operand_lohi(2);} + | MINUS IDENTIFIER HI_OPTION { recognizer->add_scalar_operand( $2 ); recognizer->change_operand_lohi(2); recognizer->change_operand_neg();} + | IDENTIFIER PIPE IDENTIFIER { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-1);} + | IDENTIFIER PIPE IDENTIFIER LO_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-1); recognizer->change_operand_lohi(1);} + | IDENTIFIER PIPE IDENTIFIER HI_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-1); recognizer->change_operand_lohi(2);} + | IDENTIFIER BACKSLASH IDENTIFIER { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-3);} + | IDENTIFIER BACKSLASH IDENTIFIER LO_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-3); recognizer->change_operand_lohi(1);} + | IDENTIFIER BACKSLASH IDENTIFIER HI_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-3); recognizer->change_operand_lohi(2);} ; -vector_operand: LEFT_BRACE IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_2vector_operand($2,$4); } - | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_3vector_operand($2,$4,$6); } - | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_4vector_operand($2,$4,$6,$8); } - | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_8vector_operand($2,$4,$6,$8,$10,$12,$14,$16); } - | LEFT_BRACE IDENTIFIER RIGHT_BRACE { add_1vector_operand($2); } +vector_operand: LEFT_BRACE IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { recognizer->add_2vector_operand($2,$4); } + | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { recognizer->add_3vector_operand($2,$4,$6); } + | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { recognizer->add_4vector_operand($2,$4,$6,$8); } + | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { recognizer->add_8vector_operand($2,$4,$6,$8,$10,$12,$14,$16); } + | LEFT_BRACE IDENTIFIER RIGHT_BRACE { recognizer->add_1vector_operand($2); } ; -tex_operand: LEFT_SQUARE_BRACKET IDENTIFIER COMMA { add_scalar_operand($2); } +tex_operand: LEFT_SQUARE_BRACKET IDENTIFIER COMMA { recognizer->add_scalar_operand($2); } vector_operand RIGHT_SQUARE_BRACKET ; -builtin_operand: SPECIAL_REGISTER DIMENSION_MODIFIER { add_builtin_operand($1,$2); } - | SPECIAL_REGISTER { add_builtin_operand($1,-1); } +builtin_operand: SPECIAL_REGISTER DIMENSION_MODIFIER { recognizer->add_builtin_operand($1,$2); } + | SPECIAL_REGISTER { recognizer->add_builtin_operand($1,-1); } ; -memory_operand : LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { add_memory_operand(); } - | IDENTIFIER LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { add_memory_operand(); change_memory_addr_space($1); } - | IDENTIFIER LEFT_SQUARE_BRACKET literal_operand RIGHT_SQUARE_BRACKET { change_memory_addr_space($1); } - | IDENTIFIER LEFT_SQUARE_BRACKET twin_operand RIGHT_SQUARE_BRACKET { change_memory_addr_space($1); add_memory_operand();} - | MINUS memory_operand { change_operand_neg(); } +memory_operand : LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { recognizer->add_memory_operand(); } + | IDENTIFIER LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { recognizer->add_memory_operand(); recognizer->change_memory_addr_space($1); } + | IDENTIFIER LEFT_SQUARE_BRACKET literal_operand RIGHT_SQUARE_BRACKET { recognizer->change_memory_addr_space($1); } + | IDENTIFIER LEFT_SQUARE_BRACKET twin_operand RIGHT_SQUARE_BRACKET { recognizer->change_memory_addr_space($1); recognizer->add_memory_operand();} + | MINUS memory_operand { recognizer->change_operand_neg(); } ; -twin_operand : IDENTIFIER PLUS IDENTIFIER { add_double_operand($1,$3); change_double_operand_type(1); } - | IDENTIFIER PLUS IDENTIFIER LO_OPTION { add_double_operand($1,$3); change_double_operand_type(1); change_operand_lohi(1); } - | IDENTIFIER PLUS IDENTIFIER HI_OPTION { add_double_operand($1,$3); change_double_operand_type(1); change_operand_lohi(2); } - | IDENTIFIER PLUS EQUALS IDENTIFIER { add_double_operand($1,$4); change_double_operand_type(2); } - | IDENTIFIER PLUS EQUALS IDENTIFIER LO_OPTION { add_double_operand($1,$4); change_double_operand_type(2); change_operand_lohi(1); } - | IDENTIFIER PLUS EQUALS IDENTIFIER HI_OPTION { add_double_operand($1,$4); change_double_operand_type(2); change_operand_lohi(2); } - | IDENTIFIER PLUS EQUALS INT_OPERAND { add_address_operand($1,$4); change_double_operand_type(3); } +twin_operand : IDENTIFIER PLUS IDENTIFIER { recognizer->add_double_operand($1,$3); recognizer->change_double_operand_type(1); } + | IDENTIFIER PLUS IDENTIFIER LO_OPTION { recognizer->add_double_operand($1,$3); recognizer->change_double_operand_type(1); recognizer->change_operand_lohi(1); } + | IDENTIFIER PLUS IDENTIFIER HI_OPTION { recognizer->add_double_operand($1,$3); recognizer->change_double_operand_type(1); recognizer->change_operand_lohi(2); } + | IDENTIFIER PLUS EQUALS IDENTIFIER { recognizer->add_double_operand($1,$4); recognizer->change_double_operand_type(2); } + | IDENTIFIER PLUS EQUALS IDENTIFIER LO_OPTION { recognizer->add_double_operand($1,$4); recognizer->change_double_operand_type(2); recognizer->change_operand_lohi(1); } + | IDENTIFIER PLUS EQUALS IDENTIFIER HI_OPTION { recognizer->add_double_operand($1,$4); recognizer->change_double_operand_type(2); recognizer->change_operand_lohi(2); } + | IDENTIFIER PLUS EQUALS INT_OPERAND { recognizer->add_address_operand($1,$4); recognizer->change_double_operand_type(3); } ; -literal_operand : INT_OPERAND { add_literal_int($1); } - | FLOAT_OPERAND { add_literal_float($1); } - | DOUBLE_OPERAND { add_literal_double($1); } +literal_operand : INT_OPERAND { recognizer->add_literal_int($1); } + | FLOAT_OPERAND { recognizer->add_literal_float($1); } + | DOUBLE_OPERAND { recognizer->add_literal_double($1); } ; -address_expression: IDENTIFIER { add_address_operand($1,0); } - | IDENTIFIER LO_OPTION { add_address_operand($1,0); change_operand_lohi(1);} - | IDENTIFIER HI_OPTION { add_address_operand($1,0); change_operand_lohi(2); } - | IDENTIFIER PLUS INT_OPERAND { add_address_operand($1,$3); } - | INT_OPERAND { add_address_operand2($1); } +address_expression: IDENTIFIER { recognizer->add_address_operand($1,0); } + | IDENTIFIER LO_OPTION { recognizer->add_address_operand($1,0); recognizer->change_operand_lohi(1);} + | IDENTIFIER HI_OPTION { recognizer->add_address_operand($1,0); recognizer->change_operand_lohi(2); } + | IDENTIFIER PLUS INT_OPERAND { recognizer->add_address_operand($1,$3); } + | INT_OPERAND { recognizer->add_address_operand2($1); } ; %% -extern int ptx_lineno; extern const char *g_filename; -void syntax_not_implemented() +void syntax_not_implemented(yyscan_t yyscanner, ptx_recognizer* recognizer) { - printf("Parse error (%s:%u): this syntax is not (yet) implemented:\n",g_filename,ptx_lineno); - ptx_error(NULL); + printf("Parse error (%s): this syntax is not (yet) implemented:\n",g_filename); + ptx_error(yyscanner, recognizer, NULL); abort(); } diff --git a/src/cuda-sim/ptx_ir.cc b/src/cuda-sim/ptx_ir.cc index 73db24d..8cedf79 100644 --- a/src/cuda-sim/ptx_ir.cc +++ b/src/cuda-sim/ptx_ir.cc @@ -28,6 +28,7 @@ #include "ptx_parser.h" #include "ptx_ir.h" +typedef void * yyscan_t; #include "ptx.tab.h" #include "opcodes.h" #include <stdio.h> diff --git a/src/cuda-sim/ptx_loader.cc b/src/cuda-sim/ptx_loader.cc index 8c6f361..921d1e6 100644 --- a/src/cuda-sim/ptx_loader.cc +++ b/src/cuda-sim/ptx_loader.cc @@ -33,26 +33,28 @@ #include <dirent.h> #include <fstream> #include <sstream> +#include "../../libcuda/gpgpu_context.h" /// globals -memory_space *g_global_mem; -memory_space *g_tex_mem; -memory_space *g_surf_mem; -memory_space *g_param_mem; bool g_override_embedded_ptx = false; /// extern prototypes -extern int ptx_parse(); -extern int ptx__scan_string(const char*); +extern int ptx_error( yyscan_t yyscanner, const char *s ); +extern int ptx_lex_init(yyscan_t* scanner); +extern void ptx_set_in(FILE * _in_str ,yyscan_t yyscanner ); +extern int ptx_parse(yyscan_t scanner, ptx_recognizer* recognizer); +extern int ptx_lex_destroy(yyscan_t scanner); +extern int ptx__scan_string(const char*, yyscan_t scanner); extern std::map<unsigned,const char*> get_duplicate(); -const char *g_ptxinfo_filename; -extern int ptxinfo_parse(); -extern int ptxinfo_debug; -extern FILE *ptxinfo_in; +typedef void * yyscan_t; +extern int ptxinfo_lex_init(yyscan_t* scanner); +extern void ptxinfo_set_in (FILE * _in_str ,yyscan_t yyscanner ); +extern int ptxinfo_parse(yyscan_t scanner, ptxinfo_data* ptxinfo); +extern int ptxinfo_lex_destroy(yyscan_t scanner); static bool g_save_embedded_ptx; static int g_occupancy_sm_number; @@ -79,7 +81,7 @@ void ptx_reg_options(option_parser_t opp) "0"); } -void print_ptx_file( const char *p, unsigned source_num, const char *filename ) +void gpgpu_context::print_ptx_file( const char *p, unsigned source_num, const char *filename ) { printf("\nGPGPU-Sim PTX: file _%u.ptx contents:\n\n", source_num ); char *s = strdup(p); @@ -158,7 +160,7 @@ char* gpgpu_ptx_sim_convert_ptx_and_sass_to_ptxplus(const std::string ptxfilenam } -symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num ) +symbol_table *gpgpu_context::gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num ) { char buf[1024]; snprintf(buf,1024,"_%u.ptx", source_num ); @@ -168,8 +170,9 @@ symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source fclose(fp); } symbol_table *symtab=init_parser(buf); - ptx__scan_string(p); - int errors = ptx_parse (); + ptx_lex_init(&(ptx_parser->scanner)); + ptx__scan_string(p, ptx_parser->scanner); + int errors = ptx_parse (ptx_parser->scanner, ptx_parser); if ( errors ) { char fname[1024]; snprintf(fname,1024,"_ptx_errors_XXXXXX"); @@ -182,6 +185,7 @@ symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source abort(); exit(40); } + ptx_lex_destroy(ptx_parser->scanner); if ( g_debug_execution >= 100 ) print_ptx_file(p,source_num,buf); @@ -190,7 +194,7 @@ symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source return symtab; } -symbol_table *gpgpu_ptx_sim_load_ptx_from_filename( const char *filename ) +symbol_table *gpgpu_context::gpgpu_ptx_sim_load_ptx_from_filename( const char *filename ) { symbol_table *symtab=init_parser(filename); printf("GPGPU-Sim PTX: finished parsing EMBEDDED .ptx file %s\n",filename); @@ -327,7 +331,7 @@ char* get_app_binary_name(){ return self_exe_path; } -void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_version) +void gpgpu_context::gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_version) { std::string ptxas_filename(std::string(filename) + "as"); char buff[1024], extra_flags[1024]; @@ -346,13 +350,17 @@ void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_versio exit(1); } - g_ptxinfo_filename = strdup(ptxas_filename.c_str()); - ptxinfo_in = fopen(g_ptxinfo_filename,"r"); - ptxinfo_parse(); + FILE *ptxinfo_in; + ptxinfo->g_ptxinfo_filename = strdup(ptxas_filename.c_str()); + ptxinfo_in = fopen(ptxinfo->g_ptxinfo_filename,"r"); + ptxinfo_lex_init(&(ptxinfo->scanner)); + ptxinfo_set_in(ptxinfo_in, ptxinfo->scanner); + ptxinfo_parse(ptxinfo->scanner, ptxinfo); + ptxinfo_lex_destroy(ptxinfo->scanner); fclose(ptxinfo_in); } -void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version ) +void gpgpu_context::gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version, int no_of_ptx ) { //do ptxas for individual files instead of one big embedded ptx. This prevents the duplicate defs and declarations. char ptx_file[1000]; @@ -410,9 +418,14 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num if( result != 0 ) { // 65280 = duplicate errors if (result == 65280) { + FILE *ptxinfo_in; ptxinfo_in = fopen(tempfile_ptxinfo,"r"); - g_ptxinfo_filename = tempfile_ptxinfo; - ptxinfo_parse(); + ptxinfo->g_ptxinfo_filename = tempfile_ptxinfo; + ptxinfo_lex_init(&(ptxinfo->scanner)); + ptxinfo_set_in(ptxinfo_in, ptxinfo->scanner); + ptxinfo_parse(ptxinfo->scanner, ptxinfo); + ptxinfo_lex_destroy(ptxinfo->scanner); + fclose(ptxinfo_in); fix_duplicate_errors(fname2); snprintf(commandline,1024,"$CUDA_INSTALL_PATH/bin/ptxas %s -v %s --output-file /dev/null 2> %s", @@ -492,12 +505,17 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num } if(no_of_ptx>0) - g_ptxinfo_filename = final_tempfile_ptxinfo; + ptxinfo->g_ptxinfo_filename = final_tempfile_ptxinfo; else - g_ptxinfo_filename = tempfile_ptxinfo; - ptxinfo_in = fopen(g_ptxinfo_filename,"r"); + ptxinfo->g_ptxinfo_filename = tempfile_ptxinfo; + FILE *ptxinfo_in; + ptxinfo_in = fopen(ptxinfo->g_ptxinfo_filename,"r"); - ptxinfo_parse(); + ptxinfo_lex_init(&(ptxinfo->scanner)); + ptxinfo_set_in(ptxinfo_in, ptxinfo->scanner); + ptxinfo_parse(ptxinfo->scanner, ptxinfo); + ptxinfo_lex_destroy(ptxinfo->scanner); + fclose(ptxinfo_in); snprintf(commandline,1024,"rm -f *info"); if( system(commandline) != 0 ) { @@ -515,4 +533,4 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num exit(1); } } -}
\ No newline at end of file +} diff --git a/src/cuda-sim/ptx_loader.h b/src/cuda-sim/ptx_loader.h index e5df6a9..ee09e16 100644 --- a/src/cuda-sim/ptx_loader.h +++ b/src/cuda-sim/ptx_loader.h @@ -29,13 +29,21 @@ #define PTX_LOADER_H_INCLUDED #include <string> +#define PTXINFO_LINEBUF_SIZE 1024 +typedef void * yyscan_t; +class ptxinfo_data{ + public: + yyscan_t scanner; + char linebuf[PTXINFO_LINEBUF_SIZE]; + unsigned col; + const char *g_ptxinfo_filename; + +}; + + extern bool g_override_embedded_ptx; extern int no_of_ptx; //counter to track number of ptx files to be extracted in an application. -class symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num ); -class symbol_table *gpgpu_ptx_sim_load_ptx_from_filename( const char *filename ); -void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version=20 ); -void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_version ); char* gpgpu_ptx_sim_convert_ptx_and_sass_to_ptxplus(const std::string ptx_str, const std::string sass_str, const std::string elf_str); bool keep_intermediate_files(); diff --git a/src/cuda-sim/ptx_parser.cc b/src/cuda-sim/ptx_parser.cc index 25758dd..2872b84 100644 --- a/src/cuda-sim/ptx_parser.cc +++ b/src/cuda-sim/ptx_parser.cc @@ -27,13 +27,20 @@ #include "ptx_parser.h" #include "ptx_ir.h" +#include "../../libcuda/gpgpu_context.h" + +typedef void * yyscan_t; #include "ptx.tab.h" #include <stdarg.h> -extern int ptx_error( const char *s ); -extern int ptx_lineno; -extern int ptx_parse(); -extern FILE *ptx_in; +extern int ptx_get_lineno (yyscan_t yyscanner ); +extern YYSTYPE* ptx_get_lval (yyscan_t yyscanner ); +extern int ptx_error( yyscan_t yyscanner, const char *s ); +extern int ptx_lex_init(yyscan_t* scanner); +extern void ptx_set_in(FILE * _in_str ,yyscan_t yyscanner ); +extern FILE *ptx_get_in (yyscan_t yyscanner ); +extern int ptx_parse(yyscan_t scanner, ptx_recognizer* recognizer); +extern int ptx_lex_destroy(yyscan_t scanner); static const struct core_config *g_shader_core_config; void set_ptx_warp_size(const struct core_config * warp_size) @@ -43,54 +50,20 @@ void set_ptx_warp_size(const struct core_config * warp_size) static bool g_debug_ir_generation=false; const char *g_filename; -unsigned g_max_regs_per_thread = 0; // the program intermediate representation... -static symbol_table *g_global_allfiles_symbol_table = NULL; -static symbol_table *g_global_symbol_table = NULL; std::map<std::string,symbol_table*> g_sym_name_to_symbol_table; -static symbol_table *g_current_symbol_table = NULL; -static std::list<ptx_instruction*> g_instructions; -static symbol *g_last_symbol = NULL; - -int g_error_detected = 0; - -// type specifier stuff: -memory_space_t g_space_spec = undefined_space; -memory_space_t g_ptr_spec = undefined_space; -int g_scalar_type_spec = -1; -int g_vector_spec = -1; -int g_alignment_spec = -1; -int g_size = -1; -int g_extern_spec = 0; - -// variable declaration stuff: -type_info *g_var_type = NULL; - -// instruction definition stuff: -const symbol *g_pred; -int g_neg_pred; -int g_pred_mod; -symbol *g_label; -int g_opcode = -1; -std::list<operand_info> g_operands; -std::list<int> g_options; -std::list<int> g_wmma_options; -std::list<int> g_scalar_type; #define PTX_PARSE_DPRINTF(...) \ if( g_debug_ir_generation ) { \ - printf(" %s:%u => ",g_filename,ptx_lineno); \ + printf(" %s:%u => ",g_filename,ptx_get_lineno(scanner)); \ printf(" (%s:%u) ", __FILE__, __LINE__); \ printf(__VA_ARGS__); \ printf("\n"); \ fflush(stdout); \ } -static unsigned g_entry_func_param_index=0; -static function_info *g_func_info = NULL; static std::map<unsigned,std::string> g_ptx_token_decode; -static operand_info g_return_var; const char *decode_token( int type ) { @@ -109,7 +82,7 @@ void read_parser_environment_variables() } } -void init_directive_state() +void ptx_recognizer::init_directive_state() { PTX_PARSE_DPRINTF("init_directive_state"); g_space_spec=undefined_space; @@ -125,7 +98,7 @@ void init_directive_state() g_last_symbol = NULL; } -void init_instruction_state() +void ptx_recognizer::init_instruction_state() { PTX_PARSE_DPRINTF("init_instruction_state"); g_pred = NULL; @@ -139,17 +112,16 @@ void init_instruction_state() init_directive_state(); } -symbol_table *init_parser( const char *ptx_filename ) +symbol_table * gpgpu_context::init_parser( const char *ptx_filename ) { g_filename = strdup(ptx_filename); if (g_global_allfiles_symbol_table == NULL) { g_global_allfiles_symbol_table = new symbol_table("global_allfiles", 0, NULL); - g_global_symbol_table = g_current_symbol_table = g_global_allfiles_symbol_table; + ptx_parser->g_global_symbol_table = ptx_parser->g_current_symbol_table = g_global_allfiles_symbol_table; } /*else { g_global_symbol_table = g_current_symbol_table = new symbol_table("global",0,g_global_allfiles_symbol_table); }*/ - ptx_lineno = 1; #define DEF(X,Y) g_ptx_token_decode[X] = Y; #include "ptx_parser_decode.def" @@ -169,18 +141,23 @@ symbol_table *init_parser( const char *ptx_filename ) g_ptx_token_decode[generic_space] = "generic_space"; g_ptx_token_decode[instruction_space] = "instruction_space"; - init_directive_state(); - init_instruction_state(); + ptx_lex_init(&(ptx_parser->scanner)); + ptx_parser->init_directive_state(); + ptx_parser->init_instruction_state(); + FILE *ptx_in; ptx_in = fopen(ptx_filename, "r"); - ptx_parse(); + ptx_set_in(ptx_in, ptx_parser->scanner); + ptx_parse(ptx_parser->scanner, ptx_parser); + ptx_in = ptx_get_in(ptx_parser->scanner); + ptx_lex_destroy(ptx_parser->scanner); fclose(ptx_in); - return g_global_symbol_table; + return ptx_parser->g_global_symbol_table; } static int g_entry_point; -void start_function( int entry_point ) +void ptx_recognizer::start_function( int entry_point ) { PTX_PARSE_DPRINTF("start_function"); init_directive_state(); @@ -190,11 +167,7 @@ void start_function( int entry_point ) g_entry_func_param_index=0; } -char *g_add_identifier_cached__identifier = NULL; -int g_add_identifier_cached__array_dim; -int g_add_identifier_cached__array_ident; - -void add_function_name( const char *name ) +void ptx_recognizer::add_function_name( const char *name ) { PTX_PARSE_DPRINTF("add_function_name %s %s", name, ((g_entry_point==1)?"(entrypoint)":((g_entry_point==2)?"(extern)":""))); bool prior_decl = g_global_symbol_table->add_function_decl( name, g_entry_point, &g_func_info, &g_current_symbol_table ); @@ -210,21 +183,21 @@ void add_function_name( const char *name ) if( prior_decl ) { g_func_info->remove_args(); } - g_global_symbol_table->add_function( g_func_info, g_filename, ptx_lineno ); + g_global_symbol_table->add_function( g_func_info, g_filename, ptx_get_lineno(scanner) ); } //Jin: handle instruction group for cdp -void start_inst_group() { +void ptx_recognizer::start_inst_group() { PTX_PARSE_DPRINTF("start_instruction_group"); g_current_symbol_table = g_current_symbol_table->start_inst_group(); } -void end_inst_group() { +void ptx_recognizer::end_inst_group() { PTX_PARSE_DPRINTF("end_instruction_group"); g_current_symbol_table = g_current_symbol_table->end_inst_group(); } -void add_directive() +void ptx_recognizer::add_directive() { PTX_PARSE_DPRINTF("add_directive"); init_directive_state(); @@ -232,7 +205,7 @@ void add_directive() #define mymax(a,b) ((a)>(b)?(a):(b)) -void end_function() +void ptx_recognizer::end_function() { PTX_PARSE_DPRINTF("end_function"); @@ -250,7 +223,7 @@ void end_function() #define parse_error(msg, ...) parse_error_impl(__FILE__,__LINE__, msg, ##__VA_ARGS__) #define parse_assert(cond,msg, ...) parse_assert_impl((cond),__FILE__,__LINE__, msg, ##__VA_ARGS__) -void parse_error_impl( const char *file, unsigned line, const char *msg, ... ) +void ptx_recognizer::parse_error_impl( const char *file, unsigned line, const char *msg, ... ) { va_list ap; char buf[1024]; @@ -259,13 +232,13 @@ void parse_error_impl( const char *file, unsigned line, const char *msg, ... ) va_end(ap); g_error_detected = 1; - printf("%s:%u: Parse error: %s (%s:%u)\n\n", g_filename, ptx_lineno, buf, file, line); - ptx_error(NULL); + printf("%s:%u: Parse error: %s (%s:%u)\n\n", g_filename, ptx_get_lineno(scanner), buf, file, line); + ptx_error(scanner, NULL); abort(); exit(1); } -void parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... ) +void ptx_recognizer::parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... ) { va_list ap; char buf[1024]; @@ -277,10 +250,9 @@ void parse_assert_impl( int test_value, const char *file, unsigned line, const c parse_error_impl(file,line, msg); } -extern char linebuf[4096]; -void set_return() +void ptx_recognizer::set_return() { parse_assert( (g_opcode == CALL_OP || g_opcode == CALLP_OP), "only call can have return value"); g_operands.front().set_return(); @@ -300,7 +272,7 @@ const ptx_instruction *ptx_instruction_lookup( const char *filename, unsigned li return l->second; } -void add_instruction() +void ptx_recognizer::add_instruction() { PTX_PARSE_DPRINTF("add_instruction: %s", ((g_opcode>0)?g_opcode_string[g_opcode]:"<label>") ); assert( g_shader_core_config != 0 ); @@ -316,15 +288,15 @@ void add_instruction() g_scalar_type, g_space_spec, g_filename, - ptx_lineno, + ptx_get_lineno(scanner), linebuf, g_shader_core_config ); g_instructions.push_back(i); - g_inst_lookup[g_filename][ptx_lineno] = i; + g_inst_lookup[g_filename][ptx_get_lineno(scanner)] = i; init_instruction_state(); } -void add_variables() +void ptx_recognizer::add_variables() { PTX_PARSE_DPRINTF("add_variables"); if ( !g_operands.empty() ) { @@ -334,7 +306,7 @@ void add_variables() init_directive_state(); } -void set_variable_type() +void ptx_recognizer::set_variable_type() { PTX_PARSE_DPRINTF("set_variable_type space_spec=%s scalar_type_spec=%s", g_ptx_token_decode[g_space_spec.get_type()].c_str(), @@ -348,7 +320,7 @@ void set_variable_type() g_extern_spec ); } -bool check_for_duplicates( const char *identifier ) +bool ptx_recognizer::check_for_duplicates( const char *identifier ) { const symbol *s = g_current_symbol_table->lookup(identifier); return ( s != NULL ); @@ -357,10 +329,6 @@ bool check_for_duplicates( const char *identifier ) extern std::set<std::string> g_globals; extern std::set<std::string> g_constants; -int g_func_decl = 0; -int g_ident_add_uid = 0; -unsigned g_const_alloc = 1; - // Returns padding that needs to be inserted ahead of address to make it aligned to min(size, maxalign) /* * @param address the address in bytes @@ -378,7 +346,7 @@ int pad_address (new_addr_type address, unsigned size, unsigned maxalign) { return alignto ? ((alignto - (address % alignto)) % alignto) : 0; } -void add_identifier( const char *identifier, int array_dim, unsigned array_ident ) +void ptx_recognizer::add_identifier( const char *identifier, int array_dim, unsigned array_ident ) { if(array_ident==ARRAY_IDENTIFIER){ g_size *= array_dim; @@ -426,7 +394,7 @@ void add_identifier( const char *identifier, int array_dim, unsigned array_ident default: break; } - g_last_symbol = g_current_symbol_table->add_variable(identifier,type,num_bits/8,g_filename,ptx_lineno); + g_last_symbol = g_current_symbol_table->add_variable(identifier,type,num_bits/8,g_filename,ptx_get_lineno(scanner)); switch ( ti.get_memory_space().get_type() ) { case reg_space: { regnum = g_current_symbol_table->next_reg_num(); @@ -569,7 +537,7 @@ void add_identifier( const char *identifier, int array_dim, unsigned array_ident } } -void add_constptr(const char* identifier1, const char* identifier2, int offset) +void ptx_recognizer::add_constptr(const char* identifier1, const char* identifier2, int offset) { symbol *s1 = g_current_symbol_table->lookup(identifier1); const symbol *s2 = g_current_symbol_table->lookup(identifier2); @@ -584,7 +552,7 @@ void add_constptr(const char* identifier1, const char* identifier2, int offset) s1->set_address( addr + offset ); } -void add_function_arg() +void ptx_recognizer::add_function_arg() { assert(g_size>0); if( g_func_info ) { @@ -597,20 +565,20 @@ void add_function_arg() } -void add_extern_spec() +void ptx_recognizer::add_extern_spec() { PTX_PARSE_DPRINTF("add_extern_spec"); g_extern_spec = 1; } -void add_alignment_spec( int spec ) +void ptx_recognizer::add_alignment_spec( int spec ) { PTX_PARSE_DPRINTF("add_alignment_spec"); parse_assert( g_alignment_spec == -1, "multiple .align specifiers per variable declaration not allowed." ); g_alignment_spec = spec; } -void add_ptr_spec( enum _memory_space_t spec ) +void ptx_recognizer::add_ptr_spec( enum _memory_space_t spec ) { PTX_PARSE_DPRINTF("add_ptr_spec \"%s\"", g_ptx_token_decode[spec].c_str() ); parse_assert( g_ptr_spec == undefined_space, "multiple ptr space specifiers not allowed." ); @@ -618,7 +586,7 @@ void add_ptr_spec( enum _memory_space_t spec ) g_ptr_spec = spec; } -void add_space_spec( enum _memory_space_t spec, int value ) +void ptx_recognizer::add_space_spec( enum _memory_space_t spec, int value ) { PTX_PARSE_DPRINTF("add_space_spec \"%s\"", g_ptx_token_decode[spec].c_str() ); parse_assert( g_space_spec == undefined_space, "multiple space specifiers not allowed." ); @@ -637,14 +605,14 @@ void add_space_spec( enum _memory_space_t spec, int value ) } } -void add_vector_spec(int spec ) +void ptx_recognizer::add_vector_spec(int spec ) { PTX_PARSE_DPRINTF("add_vector_spec"); parse_assert( g_vector_spec == -1, "multiple vector specifiers not allowed." ); g_vector_spec = spec; } -void add_scalar_type_spec( int type_spec ) +void ptx_recognizer::add_scalar_type_spec( int type_spec ) { //save size of parameter switch ( type_spec ) { @@ -682,23 +650,23 @@ void add_scalar_type_spec( int type_spec ) g_scalar_type_spec = type_spec; } -void add_label( const char *identifier ) +void ptx_recognizer::add_label( const char *identifier ) { PTX_PARSE_DPRINTF("add_label"); symbol *s = g_current_symbol_table->lookup(identifier); if ( s != NULL ) { g_label = s; } else { - g_label = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_lineno); + g_label = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_get_lineno(scanner)); } } -void add_opcode( int opcode ) +void ptx_recognizer::add_opcode( int opcode ) { g_opcode = opcode; } -void add_pred( const char *identifier, int neg, int predModifier ) +void ptx_recognizer::add_pred( const char *identifier, int neg, int predModifier ) { PTX_PARSE_DPRINTF("add_pred"); const symbol *s = g_current_symbol_table->lookup(identifier); @@ -711,17 +679,17 @@ void add_pred( const char *identifier, int neg, int predModifier ) g_pred_mod = predModifier; } -void add_option( int option ) +void ptx_recognizer::add_option( int option ) { PTX_PARSE_DPRINTF("add_option"); g_options.push_back( option ); } -void add_wmma_option( int option ) +void ptx_recognizer::add_wmma_option( int option ) { PTX_PARSE_DPRINTF("add_option"); g_wmma_options.push_back( option ); } -void add_double_operand( const char *d1, const char *d2 ) +void ptx_recognizer::add_double_operand( const char *d1, const char *d2 ) { //operands that access two variables. //eg. s[$ofs1+$r0], g[$ofs1+=$r0] @@ -734,7 +702,7 @@ void add_double_operand( const char *d1, const char *d2 ) g_operands.push_back( operand_info(s1,s2) ); } -void add_1vector_operand( const char *d1 ) +void ptx_recognizer::add_1vector_operand( const char *d1 ) { // handles the single element vector operand ({%v1}) found in tex.1d instructions PTX_PARSE_DPRINTF("add_1vector_operand"); @@ -743,7 +711,7 @@ void add_1vector_operand( const char *d1 ) g_operands.push_back( operand_info(s1,NULL,NULL,NULL) ); } -void add_2vector_operand( const char *d1, const char *d2 ) +void ptx_recognizer::add_2vector_operand( const char *d1, const char *d2 ) { PTX_PARSE_DPRINTF("add_2vector_operand"); const symbol *s1 = g_current_symbol_table->lookup(d1); @@ -752,7 +720,7 @@ void add_2vector_operand( const char *d1, const char *d2 ) g_operands.push_back( operand_info(s1,s2,NULL,NULL) ); } -void add_3vector_operand( const char *d1, const char *d2, const char *d3 ) +void ptx_recognizer::add_3vector_operand( const char *d1, const char *d2, const char *d3 ) { PTX_PARSE_DPRINTF("add_3vector_operand"); const symbol *s1 = g_current_symbol_table->lookup(d1); @@ -762,7 +730,7 @@ void add_3vector_operand( const char *d1, const char *d2, const char *d3 ) g_operands.push_back( operand_info(s1,s2,s3,NULL) ); } -void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ) +void ptx_recognizer::add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ) { PTX_PARSE_DPRINTF("add_4vector_operand"); const symbol *s1 = g_current_symbol_table->lookup(d1); @@ -776,7 +744,7 @@ void add_4vector_operand( const char *d1, const char *d2, const char *d3, const if ( s4 == null_op ) s4 = NULL; g_operands.push_back( operand_info(s1,s2,s3,s4) ); } -void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4,const char *d5,const char *d6,const char *d7,const char *d8 ) +void ptx_recognizer::add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4,const char *d5,const char *d6,const char *d7,const char *d8 ) { PTX_PARSE_DPRINTF("add_8vector_operand"); const symbol *s1 = g_current_symbol_table->lookup(d1); @@ -799,13 +767,13 @@ void add_8vector_operand( const char *d1, const char *d2, const char *d3, const g_operands.push_back( operand_info(s1,s2,s3,s4,s5,s6,s7,s8) ); } -void add_builtin_operand( int builtin, int dim_modifier ) +void ptx_recognizer::add_builtin_operand( int builtin, int dim_modifier ) { PTX_PARSE_DPRINTF("add_builtin_operand"); g_operands.push_back( operand_info(builtin,dim_modifier) ); } -void add_memory_operand() +void ptx_recognizer::add_memory_operand() { PTX_PARSE_DPRINTF("add_memory_operand"); assert( !g_operands.empty() ); @@ -813,7 +781,7 @@ void add_memory_operand() } /*TODO: add other memory locations*/ -void change_memory_addr_space(const char *identifier) +void ptx_recognizer::change_memory_addr_space(const char *identifier) { /*0 = N/A, not reading from memory *1 = global memory @@ -860,7 +828,7 @@ void change_memory_addr_space(const char *identifier) parse_assert(recognizedType, "Error: unrecognized memory type."); } -void change_operand_lohi( int lohi ) +void ptx_recognizer::change_operand_lohi( int lohi ) { /*0 = N/A, read entire operand *1 = lo, reading from lowest bits @@ -874,14 +842,14 @@ void change_operand_lohi( int lohi ) } -void set_immediate_operand_type () +void ptx_recognizer::set_immediate_operand_type () { PTX_PARSE_DPRINTF("set_immediate_operand_type"); assert( !g_operands.empty() ); g_operands.back().set_immediate_addr(); } -void change_double_operand_type( int operand_type ) +void ptx_recognizer::change_double_operand_type( int operand_type ) { /* *-3 = reg / reg (set instruction, but both get same value) @@ -913,7 +881,7 @@ void change_double_operand_type( int operand_type ) } -void change_operand_neg( ) +void ptx_recognizer::change_operand_neg( ) { PTX_PARSE_DPRINTF("change_operand_neg"); assert( !g_operands.empty() ); @@ -922,32 +890,32 @@ void change_operand_neg( ) } -void add_literal_int( int value ) +void ptx_recognizer::add_literal_int( int value ) { PTX_PARSE_DPRINTF("add_literal_int"); g_operands.push_back( operand_info(value) ); } -void add_literal_float( float value ) +void ptx_recognizer::add_literal_float( float value ) { PTX_PARSE_DPRINTF("add_literal_float"); g_operands.push_back( operand_info(value) ); } -void add_literal_double( double value ) +void ptx_recognizer::add_literal_double( double value ) { PTX_PARSE_DPRINTF("add_literal_double"); g_operands.push_back( operand_info(value) ); } -void add_scalar_operand( const char *identifier ) +void ptx_recognizer::add_scalar_operand( const char *identifier ) { PTX_PARSE_DPRINTF("add_scalar_operand"); const symbol *s = g_current_symbol_table->lookup(identifier); if ( s == NULL ) { if ( g_opcode == BRA_OP || g_opcode == CALLP_OP) { // forward branch target... - s = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_lineno); + s = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_get_lineno(scanner)); } else { std::string msg = std::string("operand \"") + identifier + "\" has no declaration."; parse_error( msg.c_str() ); @@ -956,19 +924,19 @@ void add_scalar_operand( const char *identifier ) g_operands.push_back( operand_info(s) ); } -void add_neg_pred_operand( const char *identifier ) +void ptx_recognizer::add_neg_pred_operand( const char *identifier ) { PTX_PARSE_DPRINTF("add_neg_pred_operand"); const symbol *s = g_current_symbol_table->lookup(identifier); if ( s == NULL ) { - s = g_current_symbol_table->add_variable(identifier,NULL,1,g_filename,ptx_lineno); + s = g_current_symbol_table->add_variable(identifier,NULL,1,g_filename,ptx_get_lineno(scanner)); } operand_info op(s); op.set_neg_pred(); g_operands.push_back( op ); } -void add_address_operand( const char *identifier, int offset ) +void ptx_recognizer::add_address_operand( const char *identifier, int offset ) { PTX_PARSE_DPRINTF("add_address_operand"); const symbol *s = g_current_symbol_table->lookup(identifier); @@ -979,23 +947,23 @@ void add_address_operand( const char *identifier, int offset ) g_operands.push_back( operand_info(s,offset) ); } -void add_address_operand2( int offset ) +void ptx_recognizer::add_address_operand2( int offset ) { PTX_PARSE_DPRINTF("add_address_operand"); g_operands.push_back( operand_info((unsigned)offset) ); } -void add_array_initializer() +void ptx_recognizer::add_array_initializer() { g_last_symbol->add_initializer(g_operands); } -void add_version_info( float ver, unsigned ext ) +void ptx_recognizer::add_version_info( float ver, unsigned ext ) { g_global_symbol_table->set_ptx_version(ver,ext); } -void add_file( unsigned num, const char *filename ) +void ptx_recognizer::add_file( unsigned num, const char *filename ) { if( g_filename == NULL ) { char *b = strdup(filename); @@ -1022,44 +990,44 @@ void add_file( unsigned num, const char *filename ) g_current_symbol_table = g_global_symbol_table; } -void *reset_symtab() +void * ptx_recognizer::reset_symtab() { void *result = g_current_symbol_table; g_current_symbol_table = g_global_symbol_table; return result; } -void set_symtab(void*symtab) +void ptx_recognizer::set_symtab(void*symtab) { g_current_symbol_table = (symbol_table*)symtab; } -void add_pragma( const char *str ) +void ptx_recognizer::add_pragma( const char *str ) { printf("GPGPU-Sim PTX: Warning -- ignoring pragma '%s'\n", str ); } -void version_header(double a) {} //intentional dummy function +void ptx_recognizer::version_header(double a) {} //intentional dummy function -void target_header(char* a) +void ptx_recognizer::target_header(char* a) { g_global_symbol_table->set_sm_target(a,NULL,NULL); } -void target_header2(char* a, char* b) +void ptx_recognizer::target_header2(char* a, char* b) { g_global_symbol_table->set_sm_target(a,b,NULL); } -void target_header3(char* a, char* b, char* c) +void ptx_recognizer::target_header3(char* a, char* b, char* c) { g_global_symbol_table->set_sm_target(a,b,c); } -void maxnt_id(int x, int y, int z) { +void ptx_recognizer::maxnt_id(int x, int y, int z) { g_func_info->set_maxnt_id(x * y * z); } -void func_header(const char* a) {} //intentional dummy function -void func_header_info(const char* a) {} //intentional dummy function -void func_header_info_int(const char* a, int b) {} //intentional dummy function +void ptx_recognizer::func_header(const char* a) {} //intentional dummy function +void ptx_recognizer::func_header_info(const char* a) {} //intentional dummy function +void ptx_recognizer::func_header_info_int(const char* a, int b) {} //intentional dummy function diff --git a/src/cuda-sim/ptx_parser.h b/src/cuda-sim/ptx_parser.h index 7b6e3a2..25c01fe 100644 --- a/src/cuda-sim/ptx_parser.h +++ b/src/cuda-sim/ptx_parser.h @@ -29,77 +29,151 @@ #define ptx_parser_INCLUDED #include "../abstract_hardware_model.h" +#include "ptx_ir.h" extern const char *g_filename; extern int g_error_detected; #ifdef __cplusplus -class symbol_table* init_parser(const char*); const class ptx_instruction *ptx_instruction_lookup( const char *filename, unsigned linenumber ); #endif +typedef void * yyscan_t; +class ptx_recognizer { + public: + ptx_recognizer() { + scanner = NULL; + g_size = -1; + g_add_identifier_cached__identifier = NULL; + g_alignment_spec = -1; + g_var_type = NULL; + g_opcode = -1; + g_space_spec = undefined_space; + g_ptr_spec = undefined_space; + g_scalar_type_spec = -1; + g_vector_spec = -1; + g_extern_spec = 0; + g_func_decl = 0; + g_ident_add_uid = 0; + g_const_alloc = 1; + g_max_regs_per_thread = 0; + g_global_symbol_table = NULL; + g_current_symbol_table = NULL; + g_last_symbol = NULL; + g_error_detected = 0; + g_entry_func_param_index=0; + g_func_info = NULL; + } + // global list + yyscan_t scanner; +#define PTX_LINEBUF_SIZE (4*1024) + char linebuf[PTX_LINEBUF_SIZE]; + unsigned col; + int g_size; + char *g_add_identifier_cached__identifier; + int g_add_identifier_cached__array_dim; + int g_add_identifier_cached__array_ident; + int g_alignment_spec; + // variable declaration stuff: + type_info *g_var_type; + // instruction definition stuff: + const symbol *g_pred; + int g_neg_pred; + int g_pred_mod; + symbol *g_label; + int g_opcode; + std::list<operand_info> g_operands; + std::list<int> g_options; + std::list<int> g_wmma_options; + std::list<int> g_scalar_type; + // type specifier stuff: + memory_space_t g_space_spec; + memory_space_t g_ptr_spec; + int g_scalar_type_spec; + int g_vector_spec; + int g_extern_spec; + int g_func_decl; + int g_ident_add_uid; + unsigned g_const_alloc; + unsigned g_max_regs_per_thread; + symbol_table *g_global_symbol_table; + symbol_table *g_current_symbol_table; + symbol *g_last_symbol; + std::list<ptx_instruction*> g_instructions; + int g_error_detected; + unsigned g_entry_func_param_index; + function_info *g_func_info; + operand_info g_return_var; + + // member function list + void init_directive_state(); + void init_instruction_state(); + void start_function( int entry_point ); + void add_function_name( const char *fname ); + void add_directive(); + void end_function(); + void add_identifier( const char *s, int array_dim, unsigned array_ident ); + void add_function_arg(); + void add_scalar_type_spec( int type_spec ); + void add_scalar_operand( const char *identifier ); + void add_neg_pred_operand( const char *identifier ); + void add_variables(); + void set_variable_type(); + void add_opcode( int opcode ); + void add_pred( const char *identifier, int negate, int predModifier ); + void add_1vector_operand( const char *d1 ); + void add_2vector_operand( const char *d1, const char *d2 ); + void add_3vector_operand( const char *d1, const char *d2, const char *d3 ); + void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ); + void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ,const char *d5,const char *d6,const char *d7,const char *d8); + void add_option(int option ); + void add_wmma_option(int option ); + void add_builtin_operand( int builtin, int dim_modifier ); + void add_memory_operand( ); + void add_literal_int( int value ); + void add_literal_float( float value ); + void add_literal_double( double value ); + void add_address_operand( const char *identifier, int offset ); + void add_address_operand2( int offset ); + void add_label( const char *idenfiier ); + void add_vector_spec(int spec ); + void add_space_spec( enum _memory_space_t spec, int value ); + void add_ptr_spec( enum _memory_space_t spec ); + void add_extern_spec(); + void add_instruction(); + void set_return(); + void add_alignment_spec( int spec ); + void add_array_initializer(); + void add_file( unsigned num, const char *filename ); + void add_version_info( float ver, unsigned ext); + void *reset_symtab(); + void set_symtab(void*); + void add_pragma( const char *str ); + void func_header(const char* a); + void func_header_info(const char* a); + void func_header_info_int(const char* a, int b); + void add_constptr(const char* identifier1, const char* identifier2, int offset); + void target_header(char* a); + void target_header2(char* a, char* b); + void target_header3(char* a, char* b, char* c); + void add_double_operand( const char *d1, const char *d2 ); + void change_memory_addr_space( const char *identifier ); + void change_operand_lohi( int lohi ); + void change_double_operand_type( int addr_type ); + void change_operand_neg( ); + void set_immediate_operand_type( ); + void version_header(double a); + void maxnt_id(int x, int y, int z); + void parse_error_impl( const char *file, unsigned line, const char *msg, ... ); + void parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... ); + //Jin: handle instructino group for cdp + void start_inst_group(); + void end_inst_group(); + bool check_for_duplicates( const char *identifier ); + +}; + const char *decode_token( int type ); void read_parser_environment_variables(); -void start_function( int entry_point ); -void add_function_name( const char *fname ); -void init_directive_state(); -void add_directive(); -void end_function(); -void add_identifier( const char *s, int array_dim, unsigned array_ident ); -void add_function_arg(); -void add_scalar_type_spec( int type_spec ); -void add_scalar_operand( const char *identifier ); -void add_neg_pred_operand( const char *identifier ); -void add_variables(); -void set_variable_type(); -void add_opcode( int opcode ); -void add_pred( const char *identifier, int negate, int predModifier ); -void add_1vector_operand( const char *d1 ); -void add_2vector_operand( const char *d1, const char *d2 ); -void add_3vector_operand( const char *d1, const char *d2, const char *d3 ); -void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ); -void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ,const char *d5,const char *d6,const char *d7,const char *d8); -void add_option(int option ); -void add_wmma_option(int option ); -void add_builtin_operand( int builtin, int dim_modifier ); -void add_memory_operand( ); -void add_literal_int( int value ); -void add_literal_float( float value ); -void add_literal_double( double value ); -void add_address_operand( const char *identifier, int offset ); -void add_address_operand2( int offset ); -void add_label( const char *idenfiier ); -void add_vector_spec(int spec ); -void add_space_spec( enum _memory_space_t spec, int value ); -void add_ptr_spec( enum _memory_space_t spec ); -void add_extern_spec(); -void add_instruction(); -void set_return(); -void add_alignment_spec( int spec ); -void add_array_initializer(); -void add_file( unsigned num, const char *filename ); -void add_version_info( float ver, unsigned ext); -void *reset_symtab(); -void set_symtab(void*); -void add_pragma( const char *str ); -void func_header(const char* a); -void func_header_info(const char* a); -void func_header_info_int(const char* a, int b); -void add_constptr(const char* identifier1, const char* identifier2, int offset); -void target_header(char* a); -void target_header2(char* a, char* b); -void target_header3(char* a, char* b, char* c); -void add_double_operand( const char *d1, const char *d2 ); -void change_memory_addr_space( const char *identifier ); -void change_operand_lohi( int lohi ); -void change_double_operand_type( int addr_type ); -void change_operand_neg( ); -void set_immediate_operand_type( ); -void version_header(double a); -void maxnt_id(int x, int y, int z); - -//Jin: handle instructino group for cdp -void start_inst_group(); -void end_inst_group(); #define NON_ARRAY_IDENTIFIER 1 #define ARRAY_IDENTIFIER_NO_DIM 2 diff --git a/src/cuda-sim/ptx_sim.cc b/src/cuda-sim/ptx_sim.cc index 820287d..1b8831a 100644 --- a/src/cuda-sim/ptx_sim.cc +++ b/src/cuda-sim/ptx_sim.cc @@ -28,6 +28,8 @@ #include "ptx_sim.h" #include <string> #include "ptx_ir.h" +class ptx_recognizer; +typedef void * yyscan_t; #include "ptx.tab.h" #include "../gpgpu-sim/gpu-sim.h" #include "../gpgpu-sim/shader.h" @@ -222,7 +224,7 @@ void ptx_thread_info::set_done() { assert( !m_at_barrier ); m_thread_done = true; - m_cycle_done = gpu_sim_cycle; + m_cycle_done = m_gpu->gpu_sim_cycle; } unsigned ptx_thread_info::get_builtin( int builtin_id, unsigned dim_mod ) @@ -230,15 +232,15 @@ unsigned ptx_thread_info::get_builtin( int builtin_id, unsigned dim_mod ) assert( m_valid ); switch ((builtin_id&0xFFFF)) { case CLOCK_REG: - return (unsigned)(gpu_sim_cycle + gpu_tot_sim_cycle); + return (unsigned)(m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle); case CLOCK64_REG: abort(); // change return value to unsigned long long? // GPGPUSim clock is 4 times slower - multiply by 4 - return (gpu_sim_cycle + gpu_tot_sim_cycle)*4; + return (m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle)*4; case HALFCLOCK_ID: // GPGPUSim clock is 4 times slower - multiply by 4 // Hardware clock counter is incremented at half the shader clock frequency - divide by 2 (Henry '10) - return (gpu_sim_cycle + gpu_tot_sim_cycle)*2; + return (m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle)*2; case CTAID_REG: assert( dim_mod < 3 ); if( dim_mod == 0 ) return m_ctaid.x; diff --git a/src/cuda-sim/ptxinfo.l b/src/cuda-sim/ptxinfo.l index 33c2748..b0ada09 100644 --- a/src/cuda-sim/ptxinfo.l +++ b/src/cuda-sim/ptxinfo.l @@ -31,17 +31,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. %option noyywrap %option yylineno %option prefix="ptxinfo_" + +%option bison-bridge +%option reentrant + %{ +#include "ptx_loader.h" #include "ptxinfo.tab.h" #include <string.h> #define LINEBUF_SIZE 1024 -char ptxinfo_linebuf[LINEBUF_SIZE]; -unsigned ptxinfo_col = 0; -#define TC if( (ptxinfo_lineno == 1) && ((ptxinfo_col + strlen(ptxinfo_text)) < LINEBUF_SIZE) ) { \ - strncpy(ptxinfo_linebuf+ptxinfo_col,ptxinfo_text,strlen(ptxinfo_text)); \ +#define TC if( (yylineno == 1) && (ptxinfo->col + strlen(yytext) < LINEBUF_SIZE) ) { \ + strncpy(ptxinfo->linebuf+ptxinfo->col,yytext,strlen(yytext)); \ } \ - ptxinfo_col+=strlen(ptxinfo_text); + ptxinfo->col+=strlen(yytext); +#define YY_DECL int ptxinfo_lex \ + (YYSTYPE * yylval_param , yyscan_t yyscanner, ptxinfo_data* ptxinfo) %} %% @@ -61,12 +66,12 @@ unsigned ptxinfo_col = 0; "for" TC; return FOR; "textures" TC; return TEXTURES; "error : Duplicate definition of" TC; return DUPLICATE; -"function" TC; ptxinfo_lval.string_value = strdup(yytext); return FUNCTION; -"variable" TC; ptxinfo_lval.string_value = strdup(yytext); return VARIABLE; +"function" TC; yylval->string_value = strdup(yytext); return FUNCTION; +"variable" TC; yylval->string_value = strdup(yytext); return VARIABLE; "fatal : Ptx assembly aborted due to errors" TC; return FATAL; -[_A-Za-z$%][_0-9A-Za-z$]* TC; ptxinfo_lval.string_value = strdup(yytext); return IDENTIFIER; -[-]{0,1}[0-9]+ TC; ptxinfo_lval.int_value = atoi(yytext); return INT_OPERAND; +[_A-Za-z$%][_0-9A-Za-z$]* TC; yylval->string_value = strdup(yytext); return IDENTIFIER; +[-]{0,1}[0-9]+ TC; yylval->int_value = atoi(yytext); return INT_OPERAND; "+" TC; return PLUS; "," TC; return COMMA; @@ -78,26 +83,26 @@ unsigned ptxinfo_col = 0; " " TC; "\t" TC; -\n.* ptxinfo_col=0; strncpy(ptxinfo_linebuf, yytext + 1, 1024); yyless( 1 ); +\n.* ptxinfo->col=0; strncpy(ptxinfo->linebuf, yytext + 1, 1024); yyless( 1 ); %% extern int g_ptxinfo_error_detected; extern const char *g_filename; -extern const char *g_ptxinfo_filename; -int ptxinfo_error( const char *s ) +int ptxinfo_error(yyscan_t yyscanner, ptxinfo_data* ptxinfo, const char* msg) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; int i; g_ptxinfo_error_detected = 1; fflush(stdout); printf("GPGPU-Sim: ERROR while parsing output of ptxas (used to capture resource usage information)\n"); - if( s != NULL ) - printf("GPGPU-Sim: %s (%s:%u) Syntax error:\n\n", g_filename, g_ptxinfo_filename, ptxinfo_lineno ); - printf(" %s\n", ptxinfo_linebuf ); + if( msg != NULL ) + printf("GPGPU-Sim: %s (%s:%u) Syntax error:\n\n", g_filename, ptxinfo->g_ptxinfo_filename, yylineno ); + printf(" %s\n", ptxinfo->linebuf ); printf(" "); - for( i=0; i < ptxinfo_col-1; i++ ) { - if( ptxinfo_linebuf[i] == '\t' ) printf("\t"); + for( i=0; i < ptxinfo->col-1; i++ ) { + if( ptxinfo->linebuf[i] == '\t' ) printf("\t"); else printf(" "); } diff --git a/src/cuda-sim/ptxinfo.y b/src/cuda-sim/ptxinfo.y index d241d8c..00c81e0 100644 --- a/src/cuda-sim/ptxinfo.y +++ b/src/cuda-sim/ptxinfo.y @@ -27,6 +27,17 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +%{ +typedef void * yyscan_t; +class ptxinfo_data; +%} + +%define api.pure full +%parse-param {yyscan_t scanner} +%parse-param {ptxinfo_data* ptxinfo} +%lex-param {yyscan_t scanner} +%lex-param {ptxinfo_data* ptxinfo} + %union { int int_value; char * string_value; @@ -66,7 +77,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. static unsigned g_declared; static unsigned g_system; - int ptxinfo_lex(void); + int ptxinfo_lex(YYSTYPE * yylval_param, yyscan_t yyscanner, ptxinfo_data* ptxinfo); + void yyerror(yyscan_t yyscanner, ptxinfo_data* ptxinfo, const char* msg); void ptxinfo_addinfo(); void ptxinfo_function(const char *fname ); void ptxinfo_regs( unsigned nregs ); @@ -74,7 +86,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. void ptxinfo_gmem( unsigned declared, unsigned system ); void ptxinfo_smem( unsigned declared, unsigned system ); void ptxinfo_cmem( unsigned nbytes, unsigned bank ); - int ptxinfo_error(const char*); void ptxinfo_linenum( unsigned ); void ptxinfo_dup_type( const char* ); %} diff --git a/src/gpgpu-sim/Makefile b/src/gpgpu-sim/Makefile index f10a8a4..4994577 100644 --- a/src/gpgpu-sim/Makefile +++ b/src/gpgpu-sim/Makefile @@ -53,6 +53,8 @@ else CXXFLAGS += endif +CXXFLAGS += -I$(CUDA_INSTALL_PATH)/include + POWER_FLAGS= ifneq ($(GPGPUSIM_POWER_MODEL),) POWER_FLAGS = -I$(GPGPUSIM_POWER_MODEL) -DGPGPUSIM_POWER_MODEL diff --git a/src/gpgpu-sim/dram.cc b/src/gpgpu-sim/dram.cc index 192cb65..5e36d4b 100644 --- a/src/gpgpu-sim/dram.cc +++ b/src/gpgpu-sim/dram.cc @@ -42,12 +42,13 @@ template class fifo_pipeline<mem_fetch>; template class fifo_pipeline<dram_req_t>; dram_t::dram_t( unsigned int partition_id, const struct memory_config *config, memory_stats_t *stats, - memory_partition_unit *mp ) + memory_partition_unit *mp, gpgpu_sim* gpu ) { id = partition_id; m_memory_partition_unit = mp; m_stats = stats; m_config = config; + m_gpu = gpu; //rowblp access_num=0; @@ -191,11 +192,12 @@ unsigned int dram_t::queue_limit() const } -dram_req_t::dram_req_t( class mem_fetch *mf, unsigned banks, unsigned dram_bnk_indexing_policy) +dram_req_t::dram_req_t( class mem_fetch *mf, unsigned banks, unsigned dram_bnk_indexing_policy, class gpgpu_sim* gpu) { txbytes = 0; dqbytes = 0; data = mf; + m_gpu = gpu; const addrdec_t &tlx = mf->get_tlx_addr(); @@ -226,9 +228,9 @@ dram_req_t::dram_req_t( class mem_fetch *mf, unsigned banks, unsigned dram_bnk_i col = tlx.col; nbytes = mf->get_data_size(); - timestamp = gpu_tot_sim_cycle + gpu_sim_cycle; + timestamp = m_gpu->gpu_tot_sim_cycle + m_gpu->gpu_sim_cycle; addr = mf->get_addr(); - insertion_time = (unsigned) gpu_sim_cycle; + insertion_time = (unsigned) m_gpu->gpu_sim_cycle; rw = data->get_is_write()?WRITE:READ; } @@ -236,9 +238,9 @@ void dram_t::push( class mem_fetch *data ) { assert(id == data->get_tlx_addr().chip); // Ensure request is in correct memory partition - dram_req_t *mrq = new dram_req_t(data,m_config->nbk,m_config->dram_bnk_indexing_policy); + dram_req_t *mrq = new dram_req_t(data,m_config->nbk,m_config->dram_bnk_indexing_policy,m_memory_partition_unit->get_mgpu()); - data->set_status(IN_PARTITION_MC_INTERFACE_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + data->set_status(IN_PARTITION_MC_INTERFACE_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); mrqq->push(mrq); // stats... @@ -259,7 +261,7 @@ void dram_t::scheduler_fifo() if (!mrqq->empty()) { unsigned int bkn; dram_req_t *head_mrqq = mrqq->top(); - head_mrqq->data->set_status(IN_PARTITION_MC_BANK_ARB_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + head_mrqq->data->set_status(IN_PARTITION_MC_BANK_ARB_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); bkn = head_mrqq->bk; if (!bk[bkn]->mrq) bk[bkn]->mrq = mrqq->pop(); @@ -283,7 +285,7 @@ void dram_t::cycle() if (cmd->dqbytes >= cmd->nbytes) { mem_fetch *data = cmd->data; - data->set_status(IN_PARTITION_MC_RETURNQ,gpu_sim_cycle+gpu_tot_sim_cycle); + data->set_status(IN_PARTITION_MC_RETURNQ,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); if( data->get_access_type() != L1_WRBK_ACC && data->get_access_type() != L2_WRBK_ACC ) { data->set_reply(); returnq->push(data); @@ -566,7 +568,7 @@ bool dram_t::issue_col_command(int j) bool issued = false; unsigned grp = get_bankgrp_number(j); if (bk[j]->mrq) { //if currently servicing a memory request - bk[j]->mrq->data->set_status(IN_PARTITION_DRAM,gpu_sim_cycle+gpu_tot_sim_cycle); + bk[j]->mrq->data->set_status(IN_PARTITION_DRAM,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); // correct row activated for a READ if ( !issued && !CCDc && !bk[j]->RCDc && !(bkgrp[grp]->CCDLc) && @@ -654,7 +656,7 @@ bool dram_t::issue_row_command(int j) bool issued = false; unsigned grp = get_bankgrp_number(j); if (bk[j]->mrq) { //if currently servicing a memory request - bk[j]->mrq->data->set_status(IN_PARTITION_DRAM,gpu_sim_cycle+gpu_tot_sim_cycle); + bk[j]->mrq->data->set_status(IN_PARTITION_DRAM,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); // bank is idle //else if ( !issued && !RRDc && diff --git a/src/gpgpu-sim/dram.h b/src/gpgpu-sim/dram.h index 1ab0153..7a3a2da 100644 --- a/src/gpgpu-sim/dram.h +++ b/src/gpgpu-sim/dram.h @@ -48,7 +48,7 @@ class dram_req_t { public: - dram_req_t( class mem_fetch *data , unsigned banks, unsigned dram_bnk_indexing_policy); + dram_req_t( class mem_fetch *data , unsigned banks, unsigned dram_bnk_indexing_policy, class gpgpu_sim* gpu); unsigned int row; unsigned int col; @@ -62,6 +62,7 @@ public: unsigned long long int addr; unsigned int insertion_time; class mem_fetch * data; + class gpgpu_sim * m_gpu; }; struct bankgrp_t @@ -110,7 +111,7 @@ class dram_t { public: dram_t( unsigned int parition_id, const struct memory_config *config, class memory_stats_t *stats, - class memory_partition_unit *mp ); + class memory_partition_unit *mp, class gpgpu_sim* gpu ); bool full(bool is_write) const; void print( FILE* simFile ) const; @@ -129,6 +130,7 @@ public: void dram_log (int task); class memory_partition_unit *m_memory_partition_unit; + class gpgpu_sim* m_gpu; unsigned int id; // Power Model diff --git a/src/gpgpu-sim/dram_sched.cc b/src/gpgpu-sim/dram_sched.cc index ff50050..6ee6271 100644 --- a/src/gpgpu-sim/dram_sched.cc +++ b/src/gpgpu-sim/dram_sched.cc @@ -84,13 +84,13 @@ void frfcfs_scheduler::add_req( dram_req_t *req ) void frfcfs_scheduler::data_collection(unsigned int bank) { - if (gpu_sim_cycle > row_service_timestamp[bank]) { - curr_row_service_time[bank] = gpu_sim_cycle - row_service_timestamp[bank]; + if (m_dram->m_gpu->gpu_sim_cycle > row_service_timestamp[bank]) { + curr_row_service_time[bank] = m_dram->m_gpu->gpu_sim_cycle - row_service_timestamp[bank]; if (curr_row_service_time[bank] > m_stats->max_servicetime2samerow[m_dram->id][bank]) m_stats->max_servicetime2samerow[m_dram->id][bank] = curr_row_service_time[bank]; } curr_row_service_time[bank] = 0; - row_service_timestamp[bank] = gpu_sim_cycle; + row_service_timestamp[bank] = m_dram->m_gpu->gpu_sim_cycle; if (m_stats->concurrent_row_access[m_dram->id][bank] > m_stats->max_conc_access2samerow[m_dram->id][bank]) { m_stats->max_conc_access2samerow[m_dram->id][bank] = m_stats->concurrent_row_access[m_dram->id][bank]; } @@ -215,7 +215,7 @@ void dram_t::scheduler_frfcfs() m_stats->total_n_reads++; } - req->data->set_status(IN_PARTITION_MC_INPUT_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + req->data->set_status(IN_PARTITION_MC_INPUT_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); sched->add_req(req); } @@ -228,14 +228,14 @@ void dram_t::scheduler_frfcfs() req = sched->schedule(b, bk[b]->curr_row); if ( req ) { - req->data->set_status(IN_PARTITION_MC_BANK_ARB_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + req->data->set_status(IN_PARTITION_MC_BANK_ARB_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); prio = (prio+1)%m_config->nbk; bk[b]->mrq = req; if (m_config->gpgpu_memlatency_stat) { - mrq_latency = gpu_sim_cycle + gpu_tot_sim_cycle - bk[b]->mrq->timestamp; + mrq_latency = m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle - bk[b]->mrq->timestamp; m_stats->tot_mrq_latency += mrq_latency; m_stats->tot_mrq_num++; - bk[b]->mrq->timestamp = gpu_tot_sim_cycle + gpu_sim_cycle; + bk[b]->mrq->timestamp =m_gpu->gpu_tot_sim_cycle + m_gpu->gpu_sim_cycle; m_stats->mrq_lat_table[LOGB2(mrq_latency)]++; if (mrq_latency > m_stats->max_mrq_latency) { m_stats->max_mrq_latency = mrq_latency; diff --git a/src/gpgpu-sim/gpu-cache.cc b/src/gpgpu-sim/gpu-cache.cc index 370f6e6..f1f6e19 100644 --- a/src/gpgpu-sim/gpu-cache.cc +++ b/src/gpgpu-sim/gpu-cache.cc @@ -26,6 +26,7 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "gpu-cache.h" +#include "gpu-sim.h" #include "stat-tool.h" #include <assert.h> @@ -1258,7 +1259,8 @@ data_cache::wr_miss_wa_naive( new_addr_type addr, mf->get_wid(), mf->get_sid(), mf->get_tpc(), - mf->get_mem_config()); + mf->get_mem_config(), + m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle); bool do_miss = false; bool wb = false; @@ -1276,7 +1278,7 @@ data_cache::wr_miss_wa_naive( new_addr_type addr, if( wb && (m_config.m_write_policy != WRITE_THROUGH) ) { assert(status == MISS); //SECTOR_MISS and HIT_RESERVED should not send write back mem_fetch *wb = m_memfetch_creator->alloc(evicted.m_block_addr, - m_wrbk_type,evicted.m_modified_size,true); + m_wrbk_type,evicted.m_modified_size,true,m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle); send_write_request(wb, cache_event(WRITE_BACK_REQUEST_SENT, evicted), time, events); } return MISS; @@ -1320,7 +1322,7 @@ data_cache::wr_miss_wa_fetch_on_write( new_addr_type addr, // (already modified lower level) if( wb && (m_config.m_write_policy != WRITE_THROUGH) ) { mem_fetch *wb = m_memfetch_creator->alloc(evicted.m_block_addr, - m_wrbk_type,evicted.m_modified_size,true); + m_wrbk_type,evicted.m_modified_size,true,m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle); send_write_request(wb, cache_event(WRITE_BACK_REQUEST_SENT, evicted), time, events); } return MISS; @@ -1372,6 +1374,7 @@ data_cache::wr_miss_wa_fetch_on_write( new_addr_type addr, mf->get_sid(), mf->get_tpc(), mf->get_mem_config(), + m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle, NULL, mf); @@ -1395,7 +1398,7 @@ data_cache::wr_miss_wa_fetch_on_write( new_addr_type addr, // (already modified lower level) if(wb && (m_config.m_write_policy != WRITE_THROUGH) ){ mem_fetch *wb = m_memfetch_creator->alloc(evicted.m_block_addr, - m_wrbk_type,evicted.m_modified_size,true); + m_wrbk_type,evicted.m_modified_size,true,m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle); send_write_request(wb, cache_event(WRITE_BACK_REQUEST_SENT, evicted), time, events); } return MISS; @@ -1448,7 +1451,7 @@ data_cache::wr_miss_wa_lazy_fetch_on_read( new_addr_type addr, // (already modified lower level) if( wb && (m_config.m_write_policy != WRITE_THROUGH) ) { mem_fetch *wb = m_memfetch_creator->alloc(evicted.m_block_addr, - m_wrbk_type,evicted.m_modified_size,true); + m_wrbk_type,evicted.m_modified_size,true,m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle); send_write_request(wb, cache_event(WRITE_BACK_REQUEST_SENT, evicted), time, events); } return MISS; @@ -1533,7 +1536,7 @@ data_cache::rd_miss_base( new_addr_type addr, // (already modified lower level) if(wb && (m_config.m_write_policy != WRITE_THROUGH) ){ mem_fetch *wb = m_memfetch_creator->alloc(evicted.m_block_addr, - m_wrbk_type,evicted.m_modified_size,true); + m_wrbk_type,evicted.m_modified_size,true,m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle); send_write_request(wb, WRITE_BACK_REQUEST_SENT, time, events); } return MISS; diff --git a/src/gpgpu-sim/gpu-cache.h b/src/gpgpu-sim/gpu-cache.h index 337f710..be33d96 100644 --- a/src/gpgpu-sim/gpu-cache.h +++ b/src/gpgpu-sim/gpu-cache.h @@ -1290,12 +1290,13 @@ public: data_cache( const char *name, cache_config &config, int core_id, int type_id, mem_fetch_interface *memport, mem_fetch_allocator *mfcreator, enum mem_fetch_status status, - mem_access_type wr_alloc_type, mem_access_type wrbk_type ) + mem_access_type wr_alloc_type, mem_access_type wrbk_type, class gpgpu_sim* gpu ) : baseline_cache(name,config,core_id,type_id,memport,status) { init( mfcreator ); m_wr_alloc_type = wr_alloc_type; m_wrbk_type = wrbk_type; + m_gpu=gpu; } virtual ~data_cache() {} @@ -1353,16 +1354,19 @@ protected: enum mem_fetch_status status, tag_array* new_tag_array, mem_access_type wr_alloc_type, - mem_access_type wrbk_type) + mem_access_type wrbk_type, + class gpgpu_sim* gpu ) : baseline_cache(name, config, core_id, type_id, memport,status, new_tag_array) { init( mfcreator ); m_wr_alloc_type = wr_alloc_type; m_wrbk_type = wrbk_type; + m_gpu=gpu; } mem_access_type m_wr_alloc_type; // Specifies type of write allocate request (e.g., L1 or L2) mem_access_type m_wrbk_type; // Specifies type of writeback request (e.g., L1 or L2) + class gpgpu_sim* m_gpu; //! A general function that takes the result of a tag_array probe // and performs the correspding functions based on the cache configuration @@ -1519,8 +1523,8 @@ class l1_cache : public data_cache { public: l1_cache(const char *name, cache_config &config, int core_id, int type_id, mem_fetch_interface *memport, - mem_fetch_allocator *mfcreator, enum mem_fetch_status status ) - : data_cache(name,config,core_id,type_id,memport,mfcreator,status, L1_WR_ALLOC_R, L1_WRBK_ACC){} + mem_fetch_allocator *mfcreator, enum mem_fetch_status status, class gpgpu_sim* gpu ) + : data_cache(name,config,core_id,type_id,memport,mfcreator,status, L1_WR_ALLOC_R, L1_WRBK_ACC, gpu){} virtual ~l1_cache(){} @@ -1538,10 +1542,11 @@ protected: mem_fetch_interface *memport, mem_fetch_allocator *mfcreator, enum mem_fetch_status status, - tag_array* new_tag_array ) + tag_array* new_tag_array, + class gpgpu_sim* gpu) : data_cache( name, config, - core_id,type_id,memport,mfcreator,status, new_tag_array, L1_WR_ALLOC_R, L1_WRBK_ACC ){} + core_id,type_id,memport,mfcreator,status, new_tag_array, L1_WR_ALLOC_R, L1_WRBK_ACC, gpu ){} }; @@ -1551,8 +1556,8 @@ class l2_cache : public data_cache { public: l2_cache(const char *name, cache_config &config, int core_id, int type_id, mem_fetch_interface *memport, - mem_fetch_allocator *mfcreator, enum mem_fetch_status status ) - : data_cache(name,config,core_id,type_id,memport,mfcreator,status, L2_WR_ALLOC_R, L2_WRBK_ACC){} + mem_fetch_allocator *mfcreator, enum mem_fetch_status status, class gpgpu_sim* gpu ) + : data_cache(name,config,core_id,type_id,memport,mfcreator,status, L2_WR_ALLOC_R, L2_WRBK_ACC, gpu){} virtual ~l2_cache() {} diff --git a/src/gpgpu-sim/gpu-sim.cc b/src/gpgpu-sim/gpu-sim.cc index c1ba934..a557d6f 100644 --- a/src/gpgpu-sim/gpu-sim.cc +++ b/src/gpgpu-sim/gpu-sim.cc @@ -82,23 +82,6 @@ class gpgpu_sim_wrapper {}; bool g_interactive_debugger_enabled=false; - -unsigned long long gpu_sim_cycle = 0; -unsigned long long gpu_tot_sim_cycle = 0; - - -// performance counter for stalls due to congestion. -unsigned int gpu_stall_dramfull = 0; -unsigned int gpu_stall_icnt2sh = 0; -unsigned long long partiton_reqs_in_parallel = 0; -unsigned long long partiton_reqs_in_parallel_total = 0; -unsigned long long partiton_reqs_in_parallel_util = 0; -unsigned long long partiton_reqs_in_parallel_util_total = 0; -unsigned long long gpu_sim_cycle_parition_util = 0; -unsigned long long gpu_tot_sim_cycle_parition_util = 0; -unsigned long long partiton_replys_in_parallel = 0; -unsigned long long partiton_replys_in_parallel_total = 0; - tr1_hash_map<new_addr_type,unsigned> address_random_interleaving; /* Clock Domains */ @@ -112,8 +95,6 @@ tr1_hash_map<new_addr_type,unsigned> address_random_interleaving; #define MEM_LATENCY_STAT_IMPL - - #include "mem_latency_stat.h" void power_config::reg_options(class OptionParser * opp) @@ -731,7 +712,7 @@ gpgpu_sim::gpgpu_sim( const gpgpu_sim_config &config ) #endif m_shader_stats = new shader_core_stats(m_shader_config); - m_memory_stats = new memory_stats_t(m_config.num_shader(),m_shader_config,m_memory_config); + m_memory_stats = new memory_stats_t(m_config.num_shader(),m_shader_config,m_memory_config,this); average_pipeline_duty_cycle = (float *)malloc(sizeof(float)); active_sms=(float *)malloc(sizeof(float)); m_power_stats = new power_stat_t(m_shader_config,average_pipeline_duty_cycle,active_sms,m_shader_stats,m_memory_config,m_memory_stats); @@ -742,6 +723,16 @@ gpgpu_sim::gpgpu_sim( const gpgpu_sim_config &config ) m_total_cta_launched = 0; gpu_deadlock = false; + gpu_stall_dramfull = 0; + gpu_stall_icnt2sh = 0; + partiton_reqs_in_parallel = 0; + partiton_reqs_in_parallel_total = 0; + partiton_reqs_in_parallel_util = 0; + partiton_reqs_in_parallel_util_total = 0; + gpu_sim_cycle_parition_util = 0; + gpu_tot_sim_cycle_parition_util = 0; + partiton_replys_in_parallel = 0; + partiton_replys_in_parallel_total = 0; m_cluster = new simt_core_cluster*[m_shader_config->n_simt_clusters]; for (unsigned i=0;i<m_shader_config->n_simt_clusters;i++) @@ -750,7 +741,7 @@ gpgpu_sim::gpgpu_sim( const gpgpu_sim_config &config ) m_memory_partition_unit = new memory_partition_unit*[m_memory_config->m_n_mem]; m_memory_sub_partition = new memory_sub_partition*[m_memory_config->m_n_mem_sub_partition]; for (unsigned i=0;i<m_memory_config->m_n_mem;i++) { - m_memory_partition_unit[i] = new memory_partition_unit(i, m_memory_config, m_memory_stats); + m_memory_partition_unit[i] = new memory_partition_unit(i, m_memory_config, m_memory_stats, this); for (unsigned p = 0; p < m_memory_config->m_n_sub_partition_per_memory_channel; p++) { unsigned submpid = i * m_memory_config->m_n_sub_partition_per_memory_channel + p; m_memory_sub_partition[submpid] = m_memory_partition_unit[i]->get_sub_partition(p); @@ -1140,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 ); @@ -1504,7 +1495,7 @@ void shader_core_ctx::issue_block2core( kernel_info_t &kernel ) shader_CTA_count_log(m_sid, 1); SHADER_DPRINTF(LIVENESS, "GPGPU-Sim uArch: cta:%2u, start_tid:%4u, end_tid:%4u, initialized @(%lld,%lld)\n", - free_cta_hw_id, start_thread, end_thread, gpu_sim_cycle, gpu_tot_sim_cycle ); + free_cta_hw_id, start_thread, end_thread, m_gpu->gpu_sim_cycle, m_gpu->gpu_tot_sim_cycle ); } @@ -1710,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; @@ -1721,7 +1712,7 @@ void gpgpu_sim::cycle() for (unsigned i=0;i<m_shader_config->n_simt_clusters;i++) { m_cluster[i]->get_current_occupancy(active, total); } - DPRINTF(LIVENESS, "uArch: inst.: %lld (ipc=%4.1f, occ=%0.4f\% [%llu / %llu]) sim_rate=%u (inst/sec) elapsed = %u:%u:%02u:%02u / %s", + DPRINTFG(LIVENESS, "uArch: inst.: %lld (ipc=%4.1f, occ=%0.4f\% [%llu / %llu]) sim_rate=%u (inst/sec) elapsed = %u:%u:%02u:%02u / %s", gpu_tot_sim_insn + gpu_sim_insn, (double)gpu_sim_insn/(double)gpu_sim_cycle, float(active)/float(total) * 100, active, total, diff --git a/src/gpgpu-sim/gpu-sim.h b/src/gpgpu-sim/gpu-sim.h index c8dad89..5ea5765 100644 --- a/src/gpgpu-sim/gpu-sim.h +++ b/src/gpgpu-sim/gpu-sim.h @@ -64,7 +64,6 @@ extern tr1_hash_map<new_addr_type,unsigned> address_random_interleaving; - enum dram_ctrl_t { DRAM_FIFO=0, DRAM_FRFCFS=1 @@ -292,9 +291,6 @@ struct memory_config { bool m_perf_sim_memcpy; }; -// global counters and flags (please try not to add to this list!!!) -extern unsigned long long gpu_sim_cycle; -extern unsigned long long gpu_tot_sim_cycle; extern bool g_interactive_debugger_enabled; class gpgpu_sim_config : public power_config, public gpgpu_functional_sim_config { @@ -566,6 +562,18 @@ public: occupancy_stats gpu_occupancy; occupancy_stats gpu_tot_occupancy; + // performance counter for stalls due to congestion. + unsigned int gpu_stall_dramfull; + unsigned int gpu_stall_icnt2sh; + unsigned long long partiton_reqs_in_parallel; + unsigned long long partiton_reqs_in_parallel_total; + unsigned long long partiton_reqs_in_parallel_util; + unsigned long long partiton_reqs_in_parallel_util_total; + unsigned long long gpu_sim_cycle_parition_util; + unsigned long long gpu_tot_sim_cycle_parition_util; + unsigned long long partiton_replys_in_parallel; + unsigned long long partiton_replys_in_parallel_total; + FuncCache get_cache_config(std::string kernel_name); void set_cache_config(std::string kernel_name, FuncCache cacheConfig ); diff --git a/src/gpgpu-sim/l2cache.cc b/src/gpgpu-sim/l2cache.cc index 0edc3b7..62e70a7 100644 --- a/src/gpgpu-sim/l2cache.cc +++ b/src/gpgpu-sim/l2cache.cc @@ -46,7 +46,7 @@ #include "l2cache_trace.h" -mem_fetch * partition_mf_allocator::alloc(new_addr_type addr, mem_access_type type, unsigned size, bool wr ) const +mem_fetch * partition_mf_allocator::alloc(new_addr_type addr, mem_access_type type, unsigned size, bool wr, unsigned long long cycle ) const { assert( wr ); mem_access_t access( type, addr, size, wr ); @@ -56,22 +56,25 @@ mem_fetch * partition_mf_allocator::alloc(new_addr_type addr, mem_access_type ty -1, -1, -1, - m_memory_config ); + m_memory_config, + cycle); return mf; } memory_partition_unit::memory_partition_unit( unsigned partition_id, const struct memory_config *config, - class memory_stats_t *stats ) -: m_id(partition_id), m_config(config), m_stats(stats), m_arbitration_metadata(config) + class memory_stats_t *stats, + class gpgpu_sim* gpu) +: m_id(partition_id), m_config(config), m_stats(stats), m_arbitration_metadata(config), m_gpu(gpu) { - m_dram = new dram_t(m_id,m_config,m_stats,this); + m_dram = new dram_t(m_id,m_config,m_stats,this,gpu); m_sub_partition = new memory_sub_partition*[m_config->m_n_sub_partition_per_memory_channel]; for (unsigned p = 0; p < m_config->m_n_sub_partition_per_memory_channel; p++) { unsigned sub_partition_id = m_id * m_config->m_n_sub_partition_per_memory_channel + p; - m_sub_partition[p] = new memory_sub_partition(sub_partition_id, m_config, stats); + m_sub_partition[p] = new memory_sub_partition(sub_partition_id, m_config, stats, gpu); } + } void memory_partition_unit::handle_memcpy_to_gpu( size_t addr, unsigned global_subpart_id, mem_access_sector_mask_t mask ) @@ -80,7 +83,7 @@ void memory_partition_unit::handle_memcpy_to_gpu( size_t addr, unsigned global_s std::string mystring = mask.to_string<char,std::string::traits_type,std::string::allocator_type>(); MEMPART_DPRINTF("Copy Engine Request Received For Address=%llx, local_subpart=%u, global_subpart=%u, sector_mask=%s \n", addr, p, global_subpart_id, mystring.c_str()); - m_sub_partition[p]->force_l2_tag_update(addr,gpu_sim_cycle+gpu_tot_sim_cycle, mask); + m_sub_partition[p]->force_l2_tag_update(addr,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle, mask); } memory_partition_unit::~memory_partition_unit() @@ -218,7 +221,7 @@ void memory_partition_unit::dram_cycle() delete mf_return; } else { m_sub_partition[dest_spid]->dram_L2_queue_push(mf_return); - mf_return->set_status(IN_PARTITION_DRAM_TO_L2_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf_return->set_status(IN_PARTITION_DRAM_TO_L2_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_arbitration_metadata.return_credit(dest_spid); MEMPART_DPRINTF("mem_fetch request %p return from dram to sub partition %d\n", mf_return, dest_spid); } @@ -247,9 +250,9 @@ void memory_partition_unit::dram_cycle() MEMPART_DPRINTF("Issue mem_fetch request %p from sub partition %d to dram\n", mf, spid); dram_delay_t d; d.req = mf; - d.ready_cycle = gpu_sim_cycle+gpu_tot_sim_cycle + m_config->dram_latency; + d.ready_cycle = m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle + m_config->dram_latency; m_dram_latency_queue.push_back(d); - mf->set_status(IN_PARTITION_DRAM_LATENCY_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_PARTITION_DRAM_LATENCY_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_arbitration_metadata.borrow_credit(spid); break; // the DRAM should only accept one request per cycle } @@ -258,7 +261,7 @@ void memory_partition_unit::dram_cycle() // DRAM latency queue - if( !m_dram_latency_queue.empty() && ( (gpu_sim_cycle+gpu_tot_sim_cycle) >= m_dram_latency_queue.front().ready_cycle ) && !m_dram->full(m_dram_latency_queue.front().req->is_write()) ) { + if( !m_dram_latency_queue.empty() && ( (m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle) >= m_dram_latency_queue.front().ready_cycle ) && !m_dram->full(m_dram_latency_queue.front().req->is_write()) ) { mem_fetch* mf = m_dram_latency_queue.front().req; m_dram_latency_queue.pop_front(); m_dram->push(mf); @@ -310,11 +313,13 @@ void memory_partition_unit::print( FILE *fp ) const memory_sub_partition::memory_sub_partition( unsigned sub_partition_id, const struct memory_config *config, - class memory_stats_t *stats ) + class memory_stats_t *stats, + class gpgpu_sim* gpu) { m_id = sub_partition_id; m_config=config; m_stats=stats; + m_gpu = gpu; m_memcpy_cycle_offset = 0; assert(m_id < m_config->m_n_mem_sub_partition); @@ -325,7 +330,7 @@ memory_sub_partition::memory_sub_partition( unsigned sub_partition_id, m_mf_allocator = new partition_mf_allocator(config); if(!m_config->m_L2_config.disabled()) - m_L2cache = new l2_cache(L2c_name,m_config->m_L2_config,-1,-1,m_L2interface,m_mf_allocator,IN_PARTITION_L2_MISS_QUEUE); + m_L2cache = new l2_cache(L2c_name,m_config->m_L2_config,-1,-1,m_L2interface,m_mf_allocator,IN_PARTITION_L2_MISS_QUEUE, gpu); unsigned int icnt_L2; unsigned int L2_dram; @@ -357,7 +362,7 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) mem_fetch *mf = m_L2cache->next_access(); if(mf->get_access_type() != L2_WR_ALLOC_R){ // Don't pass write allocate read request back to upper level cache mf->set_reply(); - mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_L2_icnt_queue->push(mf); }else{ if(m_config->m_L2_config.m_write_alloc_policy == FETCH_ON_WRITE) @@ -365,7 +370,7 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) mem_fetch* original_wr_mf = mf->get_original_wr_mf(); assert(original_wr_mf); original_wr_mf->set_reply(); - original_wr_mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + original_wr_mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_L2_icnt_queue->push(original_wr_mf); } m_request_tracker.erase(mf); @@ -379,13 +384,13 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) mem_fetch *mf = m_dram_L2_queue->top(); if ( !m_config->m_L2_config.disabled() && m_L2cache->waiting_for_fill(mf) ) { if (m_L2cache->fill_port_free()) { - mf->set_status(IN_PARTITION_L2_FILL_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); - m_L2cache->fill(mf,gpu_sim_cycle+gpu_tot_sim_cycle+m_memcpy_cycle_offset); + mf->set_status(IN_PARTITION_L2_FILL_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); + m_L2cache->fill(mf,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle+m_memcpy_cycle_offset); m_dram_L2_queue->pop(); } } else if ( !m_L2_icnt_queue->full() ) { if(mf->is_write() && mf->get_type() == WRITE_ACK) - mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_L2_icnt_queue->push(mf); m_dram_L2_queue->pop(); } @@ -406,7 +411,7 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) bool port_free = m_L2cache->data_port_free(); if ( !output_full && port_free ) { std::list<cache_event> events; - enum cache_request_status status = m_L2cache->access(mf->get_addr(),mf,gpu_sim_cycle+gpu_tot_sim_cycle+m_memcpy_cycle_offset,events); + enum cache_request_status status = m_L2cache->access(mf->get_addr(),mf,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle+m_memcpy_cycle_offset,events); bool write_sent = was_write_sent(events); bool read_sent = was_read_sent(events); MEM_SUBPART_DPRINTF("Probing L2 cache Address=%llx, status=%u\n", mf->get_addr(), status); @@ -420,7 +425,7 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) delete mf; } else { mf->set_reply(); - mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_L2_icnt_queue->push(mf); } m_icnt_L2_queue->pop(); @@ -431,7 +436,7 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) } else if ( status != RESERVATION_FAIL ) { if(mf->is_write() && (m_config->m_L2_config.m_write_alloc_policy == FETCH_ON_WRITE || m_config->m_L2_config.m_write_alloc_policy == LAZY_FETCH_ON_READ) && !was_writeallocate_sent(events)) { mf->set_reply(); - mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_PARTITION_L2_TO_ICNT_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_L2_icnt_queue->push(mf); } // L2 cache accepted request @@ -444,7 +449,7 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) } } else { // L2 is disabled or non-texture access to texture-only L2 - mf->set_status(IN_PARTITION_L2_TO_DRAM_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_PARTITION_L2_TO_DRAM_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); m_L2_dram_queue->push(mf); m_icnt_L2_queue->pop(); } @@ -455,7 +460,7 @@ void memory_sub_partition::cache_cycle( unsigned cycle ) mem_fetch* mf = m_rop.front().req; m_rop.pop(); m_icnt_L2_queue->push(mf); - mf->set_status(IN_PARTITION_ICNT_TO_L2_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_PARTITION_ICNT_TO_L2_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); } } @@ -644,6 +649,7 @@ std::vector<mem_fetch*> memory_sub_partition::breakdown_request_to_sector_reques mf->get_sid(), mf->get_tpc(), mf->get_mem_config(), + m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle, mf); result.push_back(n_mf); @@ -673,13 +679,13 @@ void memory_sub_partition::push( mem_fetch* m_req, unsigned long long cycle ) m_request_tracker.insert(req); if( req->istexture() ) { m_icnt_L2_queue->push(req); - req->set_status(IN_PARTITION_ICNT_TO_L2_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + req->set_status(IN_PARTITION_ICNT_TO_L2_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); } else { rop_delay_t r; r.req = req; r.ready_cycle = cycle + m_config->rop_latency; m_rop.push(r); - req->set_status(IN_PARTITION_ROP_DELAY,gpu_sim_cycle+gpu_tot_sim_cycle); + req->set_status(IN_PARTITION_ROP_DELAY,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); } } } diff --git a/src/gpgpu-sim/l2cache.h b/src/gpgpu-sim/l2cache.h index beafdd3..8ff2666 100644 --- a/src/gpgpu-sim/l2cache.h +++ b/src/gpgpu-sim/l2cache.h @@ -42,12 +42,12 @@ public: { m_memory_config = config; } - virtual mem_fetch * alloc(const class warp_inst_t &inst, const mem_access_t &access) const + virtual mem_fetch * alloc(const class warp_inst_t &inst, const mem_access_t &access, unsigned long long cycle) const { abort(); return NULL; } - virtual mem_fetch * alloc(new_addr_type addr, mem_access_type type, unsigned size, bool wr) const; + virtual mem_fetch * alloc(new_addr_type addr, mem_access_type type, unsigned size, bool wr, unsigned long long cycle) const; private: const memory_config *m_memory_config; }; @@ -58,7 +58,7 @@ private: class memory_partition_unit { public: - memory_partition_unit( unsigned partition_id, const struct memory_config *config, class memory_stats_t *stats ); + memory_partition_unit( unsigned partition_id, const struct memory_config *config, class memory_stats_t *stats, class gpgpu_sim* gpu ); ~memory_partition_unit(); bool busy() const; @@ -93,6 +93,8 @@ public: unsigned get_mpid() const { return m_id; } + class gpgpu_sim* get_mgpu() const { return m_gpu; } + private: unsigned m_id; @@ -140,12 +142,14 @@ private: class mem_fetch* req; }; std::list<dram_delay_t> m_dram_latency_queue; + + class gpgpu_sim* m_gpu; }; class memory_sub_partition { public: - memory_sub_partition( unsigned sub_partition_id, const struct memory_config *config, class memory_stats_t *stats ); + memory_sub_partition( unsigned sub_partition_id, const struct memory_config *config, class memory_stats_t *stats, class gpgpu_sim* gpu ); ~memory_sub_partition(); unsigned get_id() const { return m_id; } @@ -196,6 +200,7 @@ private: const struct memory_config *m_config; class l2_cache *m_L2cache; class L2interface *m_L2interface; + class gpgpu_sim* m_gpu; partition_mf_allocator *m_mf_allocator; // model delay of ROP units with a fixed latency diff --git a/src/gpgpu-sim/l2cache_trace.h b/src/gpgpu-sim/l2cache_trace.h index 2235cdc..d2dd948 100644 --- a/src/gpgpu-sim/l2cache_trace.h +++ b/src/gpgpu-sim/l2cache_trace.h @@ -42,7 +42,7 @@ #define MEMPART_DPRINTF(...) do {\ if (MEMPART_DTRACE(MEMORY_PARTITION_UNIT)) {\ printf( MEMPART_PRINT_STR,\ - gpu_sim_cycle + gpu_tot_sim_cycle,\ + m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle,\ Trace::trace_streams_str[Trace::MEMORY_PARTITION_UNIT],\ get_mpid() );\ printf(__VA_ARGS__);\ @@ -52,7 +52,7 @@ #define MEM_SUBPART_DPRINTF(...) do {\ if (MEM_SUBPART_DTRACE(MEMORY_PARTITION_UNIT)) {\ printf( MEM_SUBPART_PRINT_STR,\ - gpu_sim_cycle + gpu_tot_sim_cycle,\ + m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle,\ Trace::trace_streams_str[Trace::MEMORY_SUBPARTITION_UNIT],\ m_id );\ printf(__VA_ARGS__);\ diff --git a/src/gpgpu-sim/mem_fetch.cc b/src/gpgpu-sim/mem_fetch.cc index a260a35..c9b0484 100644 --- a/src/gpgpu-sim/mem_fetch.cc +++ b/src/gpgpu-sim/mem_fetch.cc @@ -40,6 +40,7 @@ mem_fetch::mem_fetch( const mem_access_t &access, unsigned sid, unsigned tpc, const struct memory_config *config, + unsigned long long cycle, mem_fetch *m_original_mf, mem_fetch *m_original_wr_mf) @@ -58,10 +59,10 @@ mem_fetch::mem_fetch( const mem_access_t &access, config->m_address_mapping.addrdec_tlx(access.get_addr(),&m_raw_addr); m_partition_addr = config->m_address_mapping.partition_address(access.get_addr()); m_type = m_access.is_write()?WRITE_REQUEST:READ_REQUEST; - m_timestamp = gpu_sim_cycle + gpu_tot_sim_cycle; + m_timestamp = cycle; m_timestamp2 = 0; m_status = MEM_FETCH_INITIALIZED; - m_status_change = gpu_sim_cycle + gpu_tot_sim_cycle; + m_status_change = cycle; m_mem_config = config; icnt_flit_size = config->icnt_flit_size; original_mf = m_original_mf; diff --git a/src/gpgpu-sim/mem_fetch.h b/src/gpgpu-sim/mem_fetch.h index e5efffd..4eb3a52 100644 --- a/src/gpgpu-sim/mem_fetch.h +++ b/src/gpgpu-sim/mem_fetch.h @@ -56,6 +56,7 @@ public: unsigned sid, unsigned tpc, const struct memory_config *config, + unsigned long long cycle, mem_fetch *original_mf = NULL, mem_fetch *original_wr_mf = NULL); ~mem_fetch(); diff --git a/src/gpgpu-sim/mem_latency_stat.cc b/src/gpgpu-sim/mem_latency_stat.cc index 11624f4..04dc75b 100644 --- a/src/gpgpu-sim/mem_latency_stat.cc +++ b/src/gpgpu-sim/mem_latency_stat.cc @@ -42,7 +42,7 @@ #include <stdlib.h> #include <stdio.h> -memory_stats_t::memory_stats_t( unsigned n_shader, const struct shader_core_config *shader_config, const struct memory_config *mem_config ) +memory_stats_t::memory_stats_t( unsigned n_shader, const struct shader_core_config *shader_config, const struct memory_config *mem_config, const class gpgpu_sim* gpu ) { assert( mem_config->m_valid ); assert( shader_config->m_valid ); @@ -67,6 +67,7 @@ memory_stats_t::memory_stats_t( unsigned n_shader, const struct shader_core_conf m_n_shader=n_shader; m_memory_config=mem_config; + m_gpu=gpu; total_n_access=0; total_n_reads=0; total_n_writes=0; @@ -147,7 +148,7 @@ memory_stats_t::memory_stats_t( unsigned n_shader, const struct shader_core_conf unsigned memory_stats_t::memlatstat_done(mem_fetch *mf ) { unsigned mf_latency; - mf_latency = (gpu_sim_cycle+gpu_tot_sim_cycle) - mf->get_timestamp(); + mf_latency = (m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle) - mf->get_timestamp(); mf_num_lat_pw++; mf_tot_lat_pw += mf_latency; unsigned idx = LOGB2(mf_latency); @@ -167,7 +168,7 @@ void memory_stats_t::memlatstat_read_done(mem_fetch *mf) if (mf_latency > mf_max_lat_table[mf->get_tlx_addr().chip][mf->get_tlx_addr().bk]) mf_max_lat_table[mf->get_tlx_addr().chip][mf->get_tlx_addr().bk] = mf_latency; unsigned icnt2sh_latency; - icnt2sh_latency = (gpu_tot_sim_cycle+gpu_sim_cycle) - mf->get_return_timestamp(); + icnt2sh_latency = (m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle) - mf->get_return_timestamp(); tot_icnt2sh_latency += icnt2sh_latency; icnt2sh_lat_table[LOGB2(icnt2sh_latency)]++; if (icnt2sh_latency > max_icnt2sh_latency) @@ -201,7 +202,7 @@ void memory_stats_t::memlatstat_icnt2mem_pop(mem_fetch *mf) { if (m_memory_config->gpgpu_memlatency_stat) { unsigned icnt2mem_latency; - icnt2mem_latency = (gpu_tot_sim_cycle+gpu_sim_cycle) - mf->get_timestamp(); + icnt2mem_latency = (m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle) - mf->get_timestamp(); tot_icnt2mem_latency += icnt2mem_latency; icnt2mem_lat_table[LOGB2(icnt2mem_latency)]++; if (icnt2mem_latency > max_icnt2mem_latency) diff --git a/src/gpgpu-sim/mem_latency_stat.h b/src/gpgpu-sim/mem_latency_stat.h index 982b9ae..b9285c1 100644 --- a/src/gpgpu-sim/mem_latency_stat.h +++ b/src/gpgpu-sim/mem_latency_stat.h @@ -36,7 +36,8 @@ class memory_stats_t { public: memory_stats_t( unsigned n_shader, const struct shader_core_config *shader_config, - const struct memory_config *mem_config ); + const struct memory_config *mem_config, + const class gpgpu_sim* gpu); unsigned memlatstat_done( class mem_fetch *mf ); void memlatstat_read_done( class mem_fetch *mf ); @@ -54,6 +55,7 @@ public: const struct shader_core_config *m_shader_config; const struct memory_config *m_memory_config; + const class gpgpu_sim* m_gpu; unsigned max_mrq_latency; unsigned max_dq_latency; diff --git a/src/gpgpu-sim/scoreboard.cc b/src/gpgpu-sim/scoreboard.cc index ebec891..80f95c6 100644 --- a/src/gpgpu-sim/scoreboard.cc +++ b/src/gpgpu-sim/scoreboard.cc @@ -32,13 +32,15 @@ //Constructor -Scoreboard::Scoreboard( unsigned sid, unsigned n_warps ) +Scoreboard::Scoreboard( unsigned sid, unsigned n_warps, class gpgpu_t* gpu ) : longopregs() { m_sid = sid; //Initialize size of table reg_table.resize(n_warps); longopregs.resize(n_warps); + + m_gpu = gpu; } // Print scoreboard contents diff --git a/src/gpgpu-sim/scoreboard.h b/src/gpgpu-sim/scoreboard.h index 4a76ea3..a4baa19 100644 --- a/src/gpgpu-sim/scoreboard.h +++ b/src/gpgpu-sim/scoreboard.h @@ -38,7 +38,7 @@ class Scoreboard { public: - Scoreboard( unsigned sid, unsigned n_warps ); + Scoreboard( unsigned sid, unsigned n_warps, class gpgpu_t* gpu ); void reserveRegisters(const warp_inst_t *inst); void releaseRegisters(const warp_inst_t *inst); @@ -59,6 +59,8 @@ private: std::vector< std::set<unsigned> > reg_table; //Register that depend on a long operation (global, local or tex memory) std::vector< std::set<unsigned> > longopregs; + + class gpgpu_t* m_gpu; }; diff --git a/src/gpgpu-sim/shader.cc b/src/gpgpu-sim/shader.cc index 007ad42..69b619a 100644 --- a/src/gpgpu-sim/shader.cc +++ b/src/gpgpu-sim/shader.cc @@ -133,7 +133,7 @@ shader_core_ctx::shader_core_ctx( class gpgpu_sim *gpu, m_L1I = new read_only_cache( name,m_config->m_L1I_config,m_sid,get_shader_instruction_cache_id(),m_icnt,IN_L1I_MISS_QUEUE); m_warp.resize(m_config->max_warps_per_shader, shd_warp_t(this, warp_size)); - m_scoreboard = new Scoreboard(m_sid, m_config->max_warps_per_shader); + m_scoreboard = new Scoreboard(m_sid, m_config->max_warps_per_shader, gpu); //scedulers //must currently occur after all inputs have been initialized. @@ -767,7 +767,7 @@ void shader_core_ctx::fetch() m_inst_fetch_buffer = ifetch_buffer_t(m_warp[mf->get_wid()].get_pc(), mf->get_access_size(), mf->get_wid()); assert( m_warp[mf->get_wid()].get_pc() == (mf->get_addr()-PROGRAM_MEM_START)); // Verify that we got the instruction we were expecting. m_inst_fetch_buffer.m_valid = true; - m_warp[mf->get_wid()].set_last_fetch(gpu_sim_cycle); + m_warp[mf->get_wid()].set_last_fetch(m_gpu->gpu_sim_cycle); delete mf; } else { @@ -815,17 +815,19 @@ void shader_core_ctx::fetch() warp_id, m_sid, m_tpc, - m_memory_config ); + m_memory_config, + m_gpu->gpu_tot_sim_cycle+m_gpu->gpu_sim_cycle + ); std::list<cache_event> events; - enum cache_request_status status = m_L1I->access( (new_addr_type)ppc, mf, gpu_sim_cycle+gpu_tot_sim_cycle,events); + enum cache_request_status status = m_L1I->access( (new_addr_type)ppc, mf, m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle,events); if( status == MISS ) { m_last_warp_fetched=warp_id; m_warp[warp_id].set_imiss_pending(); - m_warp[warp_id].set_last_fetch(gpu_sim_cycle); + m_warp[warp_id].set_last_fetch(m_gpu->gpu_sim_cycle); } else if( status == HIT ) { m_last_warp_fetched=warp_id; m_inst_fetch_buffer = ifetch_buffer_t(pc,nbytes,warp_id); - m_warp[warp_id].set_last_fetch(gpu_sim_cycle); + m_warp[warp_id].set_last_fetch(m_gpu->gpu_sim_cycle); delete mf; } else { m_last_warp_fetched=warp_id; @@ -859,7 +861,7 @@ void shader_core_ctx::issue_warp( register_set& pipe_reg_set, const warp_inst_t* m_warp[warp_id].ibuffer_free(); assert(next_inst->valid()); **pipe_reg = *next_inst; // static instruction information - (*pipe_reg)->issue( active_mask, warp_id, gpu_tot_sim_cycle + gpu_sim_cycle, m_warp[warp_id].get_dynamic_warp_id(), sch_id ); // dynamic instruction information + (*pipe_reg)->issue( active_mask, warp_id, m_gpu->gpu_tot_sim_cycle + m_gpu->gpu_sim_cycle, m_warp[warp_id].get_dynamic_warp_id(), sch_id ); // dynamic instruction information m_stats->shader_cycle_distro[2+(*pipe_reg)->active_count()]++; func_exec_inst( **pipe_reg ); if( next_inst->op == BARRIER_OP ){ @@ -1514,7 +1516,7 @@ void shader_core_ctx::warp_inst_complete(const warp_inst_t &inst) m_stats->m_num_sim_winsn[m_sid]++; m_gpu->gpu_sim_insn += inst.active_count(); - inst.completed(gpu_tot_sim_cycle + gpu_sim_cycle); + inst.completed(m_gpu->gpu_tot_sim_cycle + m_gpu->gpu_sim_cycle); } void shader_core_ctx::writeback() @@ -1552,9 +1554,9 @@ void shader_core_ctx::writeback() m_warp[warp_id].dec_inst_in_pipeline(); warp_inst_complete(*pipe_reg); m_gpu->gpu_sim_insn_last_update_sid = m_sid; - m_gpu->gpu_sim_insn_last_update = gpu_sim_cycle; - m_last_inst_gpu_sim_cycle = gpu_sim_cycle; - m_last_inst_gpu_tot_sim_cycle = gpu_tot_sim_cycle; + m_gpu->gpu_sim_insn_last_update = m_gpu->gpu_sim_cycle; + m_last_inst_gpu_sim_cycle = m_gpu->gpu_sim_cycle; + m_last_inst_gpu_tot_sim_cycle = m_gpu->gpu_tot_sim_cycle; pipe_reg->clear(); preg = m_pipeline_reg[EX_WB].get_ready(); pipe_reg = (preg==NULL)? NULL:*preg; @@ -1633,9 +1635,9 @@ mem_stage_stall_type ldst_unit::process_memory_access_queue( cache_t *cache, war return DATA_PORT_STALL; //const mem_access_t &access = inst.accessq_back(); - mem_fetch *mf = m_mf_allocator->alloc(inst,inst.accessq_back()); + mem_fetch *mf = m_mf_allocator->alloc(inst,inst.accessq_back(),m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); std::list<cache_event> events; - enum cache_request_status status = cache->access(mf->get_addr(),mf,gpu_sim_cycle+gpu_tot_sim_cycle,events); + enum cache_request_status status = cache->access(mf->get_addr(),mf,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle,events); return process_cache_access( cache, mf->get_addr(), inst, events, mf, status ); } @@ -1645,7 +1647,7 @@ mem_stage_stall_type ldst_unit::process_memory_access_queue_l1cache( l1_cache *c if( inst.accessq_empty() ) return result; - mem_fetch *mf = m_mf_allocator->alloc(inst,inst.accessq_back()); + mem_fetch *mf = m_mf_allocator->alloc(inst,inst.accessq_back(),m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); if(m_config->m_L1D_config.l1_latency > 0) { @@ -1675,7 +1677,7 @@ mem_stage_stall_type ldst_unit::process_memory_access_queue_l1cache( l1_cache *c else { std::list<cache_event> events; - enum cache_request_status status = cache->access(mf->get_addr(),mf,gpu_sim_cycle+gpu_tot_sim_cycle,events); + enum cache_request_status status = cache->access(mf->get_addr(),mf,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle,events); return process_cache_access( cache, mf->get_addr(), inst, events, mf, status ); } } @@ -1687,7 +1689,7 @@ void ldst_unit::L1_latency_queue_cycle() { mem_fetch* mf_next = l1_latency_queue[0]; std::list<cache_event> events; - enum cache_request_status status = m_L1D->access(mf_next->get_addr(),mf_next,gpu_sim_cycle+gpu_tot_sim_cycle,events); + enum cache_request_status status = m_L1D->access(mf_next->get_addr(),mf_next,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle,events); bool write_sent = was_write_sent(events); bool read_sent = was_read_sent(events); @@ -1804,7 +1806,7 @@ bool ldst_unit::memory_cycle( warp_inst_t &inst, mem_stage_stall_type &stall_rea if( m_icnt->full(size, inst.is_store() || inst.isatomic()) ) { stall_cond = ICNT_RC_FAIL; } else { - mem_fetch *mf = m_mf_allocator->alloc(inst,access); + mem_fetch *mf = m_mf_allocator->alloc(inst,access,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); m_icnt->push(mf); inst.accessq_pop_back(); //inst.clear_active( access.get_warp_mask() ); @@ -1840,7 +1842,7 @@ bool ldst_unit::response_buffer_full() const void ldst_unit::fill( mem_fetch *mf ) { - mf->set_status(IN_SHADER_LDST_RESPONSE_FIFO,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_SHADER_LDST_RESPONSE_FIFO,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); m_response_fifo.push_back(mf); } @@ -2115,7 +2117,8 @@ ldst_unit::ldst_unit( mem_fetch_interface *icnt, get_shader_normal_cache_id(), m_icnt, m_mf_allocator, - IN_L1D_MISS_QUEUE ); + IN_L1D_MISS_QUEUE, + core->get_gpu()); if(m_config->m_L1D_config.l1_latency > 0) { @@ -2202,8 +2205,8 @@ void ldst_unit::writeback() m_core->warp_inst_complete(m_next_wb); } m_next_wb.clear(); - m_last_inst_gpu_sim_cycle = gpu_sim_cycle; - m_last_inst_gpu_tot_sim_cycle = gpu_tot_sim_cycle; + m_last_inst_gpu_sim_cycle = m_core->get_gpu()->gpu_sim_cycle; + m_last_inst_gpu_tot_sim_cycle = m_core->get_gpu()->gpu_tot_sim_cycle; } } @@ -2311,13 +2314,13 @@ void ldst_unit::cycle() mem_fetch *mf = m_response_fifo.front(); if (mf->get_access_type() == TEXTURE_ACC_R) { if (m_L1T->fill_port_free()) { - m_L1T->fill(mf,gpu_sim_cycle+gpu_tot_sim_cycle); + m_L1T->fill(mf,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); m_response_fifo.pop_front(); } } else if (mf->get_access_type() == CONST_ACC_R) { if (m_L1C->fill_port_free()) { - mf->set_status(IN_SHADER_FETCHED,gpu_sim_cycle+gpu_tot_sim_cycle); - m_L1C->fill(mf,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_SHADER_FETCHED,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); + m_L1C->fill(mf,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); m_response_fifo.pop_front(); } } else { @@ -2337,13 +2340,13 @@ void ldst_unit::cycle() } if( bypassL1D ) { if ( m_next_global == NULL ) { - mf->set_status(IN_SHADER_FETCHED,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_SHADER_FETCHED,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); m_response_fifo.pop_front(); m_next_global = mf; } } else { if (m_L1D->fill_port_free()) { - m_L1D->fill(mf,gpu_sim_cycle+gpu_tot_sim_cycle); + m_L1D->fill(mf,m_core->get_gpu()->gpu_sim_cycle+m_core->get_gpu()->gpu_tot_sim_cycle); m_response_fifo.pop_front(); } } @@ -2432,7 +2435,7 @@ void shader_core_ctx::register_cta_thread_exit( unsigned cta_num, kernel_info_t shader_CTA_count_unlog(m_sid, 1); SHADER_DPRINTF(LIVENESS, "GPGPU-Sim uArch: Finished CTA #%d (%lld,%lld), %u CTAs running\n", - cta_num, gpu_sim_cycle, gpu_tot_sim_cycle, m_n_active_cta); + cta_num, m_gpu->gpu_sim_cycle, m_gpu->gpu_tot_sim_cycle, m_n_active_cta); if( m_n_active_cta == 0 ) { SHADER_DPRINTF(LIVENESS, "GPGPU-Sim uArch: Empty (last released kernel %u \'%s\').\n", @@ -2823,7 +2826,7 @@ void shader_core_ctx::display_pipeline(FILE *fout, int print_mem, int mask ) con { fprintf(fout, "=================================================\n"); fprintf(fout, "shader %u at cycle %Lu+%Lu (%u threads running)\n", m_sid, - gpu_tot_sim_cycle, gpu_sim_cycle, m_not_completed); + m_gpu->gpu_tot_sim_cycle, m_gpu->gpu_sim_cycle, m_not_completed); fprintf(fout, "=================================================\n"); dump_warp_state(fout); @@ -3221,7 +3224,7 @@ void barrier_set_t::warp_reaches_barrier(unsigned cta_id,unsigned warp_id,warp_i cta_to_warp_t::iterator w=m_cta_to_warps.find(cta_id); if( w == m_cta_to_warps.end() ) { // cta is active - printf("ERROR ** cta_id %u not found in barrier set on cycle %llu+%llu...\n", cta_id, gpu_tot_sim_cycle, gpu_sim_cycle ); + printf("ERROR ** cta_id %u not found in barrier set on cycle %llu+%llu...\n", cta_id, m_shader->get_gpu()->gpu_tot_sim_cycle, m_shader->get_gpu()->gpu_sim_cycle ); dump(); abort(); } @@ -3394,8 +3397,8 @@ bool shader_core_ctx::fetch_unit_response_buffer_full() const void shader_core_ctx::accept_fetch_response( mem_fetch *mf ) { - mf->set_status(IN_SHADER_FETCHED,gpu_sim_cycle+gpu_tot_sim_cycle); - m_L1I->fill(mf,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_SHADER_FETCHED,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); + m_L1I->fill(mf,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); } bool shader_core_ctx::ldst_unit_response_buffer_full() const @@ -3957,7 +3960,7 @@ void simt_core_cluster::icnt_inject_request_packet(class mem_fetch *mf) } m_stats->m_outgoing_traffic_stats->record_traffic(mf, packet_size); unsigned destination = mf->get_sub_partition_id(); - mf->set_status(IN_ICNT_TO_MEM,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_ICNT_TO_MEM,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); if (!mf->get_is_write() && !mf->isatomic()) ::icnt_push(m_cluster_id, m_config->mem2device(destination), (void*)mf, mf->get_ctrl_size() ); else @@ -3996,7 +3999,7 @@ void simt_core_cluster::icnt_cycle() // - For write-ack, the packet only has control metadata unsigned int packet_size = (mf->get_is_write())? mf->get_ctrl_size() : mf->size(); m_stats->m_incoming_traffic_stats->record_traffic(mf, packet_size); - mf->set_status(IN_CLUSTER_TO_SHADER_QUEUE,gpu_sim_cycle+gpu_tot_sim_cycle); + mf->set_status(IN_CLUSTER_TO_SHADER_QUEUE,m_gpu->gpu_sim_cycle+m_gpu->gpu_tot_sim_cycle); //m_memory_stats->memlatstat_read_done(mf,m_shader_config->max_warps_per_shader); m_response_fifo.push_back(mf); m_stats->n_mem_to_simt[m_cluster_id] += mf->get_num_flits(false); diff --git a/src/gpgpu-sim/shader.h b/src/gpgpu-sim/shader.h index a0c2b63..fde87b6 100644 --- a/src/gpgpu-sim/shader.h +++ b/src/gpgpu-sim/shader.h @@ -1730,7 +1730,7 @@ public: m_cluster_id = cluster_id; m_memory_config = config; } - mem_fetch *alloc( new_addr_type addr, mem_access_type type, unsigned size, bool wr ) const + mem_fetch *alloc( new_addr_type addr, mem_access_type type, unsigned size, bool wr, unsigned long long cycle ) const { mem_access_t access( type, addr, size, wr ); mem_fetch *mf = new mem_fetch( access, @@ -1739,11 +1739,12 @@ public: -1, m_core_id, m_cluster_id, - m_memory_config ); + m_memory_config, + cycle); return mf; } - mem_fetch *alloc( const warp_inst_t &inst, const mem_access_t &access ) const + mem_fetch *alloc( const warp_inst_t &inst, const mem_access_t &access, unsigned long long cycle ) const { warp_inst_t inst_copy = inst; mem_fetch *mf = new mem_fetch(access, @@ -1752,7 +1753,8 @@ public: inst.warp_id(), m_core_id, m_cluster_id, - m_memory_config); + m_memory_config, + cycle); return mf; } diff --git a/src/gpgpu-sim/shader_trace.h b/src/gpgpu-sim/shader_trace.h index de3e059..ac4e894 100644 --- a/src/gpgpu-sim/shader_trace.h +++ b/src/gpgpu-sim/shader_trace.h @@ -44,7 +44,7 @@ #define SHADER_DPRINTF(x, ...) do {\ if (SHADER_DTRACE(x)) {\ printf( SHADER_PRINT_STR,\ - gpu_sim_cycle + gpu_tot_sim_cycle,\ + m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle,\ Trace::trace_streams_str[Trace::x],\ get_sid() );\ printf(__VA_ARGS__);\ @@ -56,7 +56,7 @@ #define SCHED_DPRINTF(...) do {\ if (SHADER_DTRACE(WARP_SCHEDULER)) {\ printf( SCHED_PRINT_STR,\ - gpu_sim_cycle + gpu_tot_sim_cycle,\ + m_shader->get_gpu()->gpu_sim_cycle + m_shader->get_gpu()->gpu_tot_sim_cycle,\ Trace::trace_streams_str[Trace::WARP_SCHEDULER],\ get_sid(),\ m_id );\ diff --git a/src/gpgpusim_entrypoint.cc b/src/gpgpusim_entrypoint.cc index 9e2bfa2..de937b0 100644 --- a/src/gpgpusim_entrypoint.cc +++ b/src/gpgpusim_entrypoint.cc @@ -36,31 +36,25 @@ #include "gpgpu-sim/icnt_wrapper.h" #include "stream_manager.h" -#include <pthread.h> -#include <semaphore.h> - #define MAX(a,b) (((a)>(b))?(a):(b)) +struct GPGPUsim_ctx* the_gpgpusim = 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; - -gpgpu_sim_config g_the_gpu_config; -gpgpu_sim *g_the_gpu; -stream_manager *g_stream_manager; - - +struct GPGPUsim_ctx* GPGPUsim_ctx_ptr(){ + if(the_gpgpusim == NULL) + the_gpgpusim = new GPGPUsim_ctx(); -static int sg_argc = 3; -static const char *sg_argv[] = {"", "-config","gpgpusim.config"}; + return the_gpgpusim; +} +class gpgpu_sim* g_the_gpu() { + return GPGPUsim_ctx_ptr()->g_the_gpu; +} +class stream_manager* g_stream_manager() { + return GPGPUsim_ctx_ptr()->g_stream_manager; +} static void print_simulation_time(); @@ -69,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() { @@ -108,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 @@ -132,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); @@ -204,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); } @@ -226,36 +217,37 @@ gpgpu_sim *gpgpu_ptx_sim_init_perf() ptx_opcocde_latency_options(opp); icnt_reg_options(opp); - 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); } } } @@ -264,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; @@ -274,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)(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 bf03f03..406dd00 100644 --- a/src/gpgpusim_entrypoint.h +++ b/src/gpgpusim_entrypoint.h @@ -29,15 +29,64 @@ #define GPGPUSIM_ENTRYPOINT_H_INCLUDED #include "abstract_hardware_model.h" - +#include <pthread.h> +#include <semaphore.h> #include <time.h> -extern time_t g_simulation_starttime; +//extern time_t g_simulation_starttime; + + +struct GPGPUsim_ctx { + + 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 ); diff --git a/src/intersim2/Makefile b/src/intersim2/Makefile index 7d10b3f..3eeeb70 100644 --- a/src/intersim2/Makefile +++ b/src/intersim2/Makefile @@ -48,6 +48,7 @@ CPPFLAGS += -O3 endif CPPFLAGS += -g CPPFLAGS += -fPIC +CPPFLAGS += -I$(CUDA_INSTALL_PATH)/include LFLAGS += diff --git a/src/stream_manager.cc b/src/stream_manager.cc index 6cd62a2..e07f4e4 100644 --- a/src/stream_manager.cc +++ b/src/stream_manager.cc @@ -190,7 +190,7 @@ bool stream_operation::do_operation( gpgpu_sim *gpu ) case stream_event: { printf("event update\n"); time_t wallclock = time((time_t *)NULL); - m_event->update( gpu_tot_sim_cycle, wallclock ); + m_event->update( gpu->gpu_tot_sim_cycle, wallclock ); m_stream->record_next_done(); } break; diff --git a/src/trace.h b/src/trace.h index a79b4a0..0b96dcf 100644 --- a/src/trace.h +++ b/src/trace.h @@ -31,9 +31,6 @@ #ifndef __TRACE_H__ #define __TRACE_H__ -extern unsigned long long gpu_sim_cycle; -extern unsigned long long gpu_tot_sim_cycle; - namespace Trace { #define TS_TUP_BEGIN(X) enum X { @@ -63,17 +60,26 @@ namespace Trace { #define DPRINTF(x, ...) do {\ if (DTRACE(x)) {\ printf( SIM_PRINT_STR,\ - gpu_sim_cycle + gpu_tot_sim_cycle,\ + m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle,\ Trace::trace_streams_str[Trace::x] );\ printf(__VA_ARGS__);\ }\ } while (0) +#define DPRINTFG(x, ...) do {\ + if (DTRACE(x)) {\ + printf( SIM_PRINT_STR,\ + gpu_sim_cycle + gpu_tot_sim_cycle,\ + Trace::trace_streams_str[Trace::x] );\ + printf(__VA_ARGS__);\ + }\ +} while (0) #else #define DTRACE(x) (false) #define DPRINTF(x, ...) do {} while (0) +#define DPRINTFG(x, ...) do {} while (0) #endif |