Merge pull request #17 from echoedit/dev

Dev

8 files changed, 71 insertions, 63 deletions

diff --git a/libcuda/cuda_runtime_api.cc b/libcuda/cuda_runtime_api.cc
index f3b1113..f46d9f1 100644
--- a/libcuda/cuda_runtime_api.cc
+++ b/libcuda/cuda_runtime_api.cc
@@ -642,7 +642,7 @@ void** cudaRegisterFatBinaryInternal( void *fatCubin, gpgpu_context* gpgpu_ctx =
 			} else {
 				symtab=ctx->gpgpu_ptx_sim_load_ptx_from_string(ptx,source_num);
 				context->add_binary(symtab,fat_cubin_handle);
-				gpgpu_ptxinfo_load_from_string( ptx, source_num, max_capability, context->no_of_ptx );
+				ctx->gpgpu_ptxinfo_load_from_string( ptx, source_num, max_capability, context->no_of_ptx );
 			}
 			source_num++;
 			ctx->api->load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu());
diff --git a/libcuda/gpgpu_context.h b/libcuda/gpgpu_context.h
index 16626eb..fa5d02b 100644
--- a/libcuda/gpgpu_context.h
+++ b/libcuda/gpgpu_context.h
@@ -1,19 +1,31 @@
 #ifndef __gpgpu_context_h__
 #define __gpgpu_context_h__
 #include "cuda_api_object.h"
+#include "../src/cuda-sim/ptx_loader.h"
+#include "../src/cuda-sim/ptx_parser.h"
 
 class gpgpu_context {
     public:
 	gpgpu_context() {
+	    g_global_allfiles_symbol_table = NULL;
 	    api = new cuda_runtime_api();
+	    ptxinfo = new ptxinfo_data();
+	    ptx_parser = new ptx_recognizer();
 	}
 	// global list
+	symbol_table *g_global_allfiles_symbol_table;
 	// objects pointers for each file
 	cuda_runtime_api* api;
+	ptxinfo_data* ptxinfo;
+	ptx_recognizer* ptx_parser;
 	// member function list
 	void cuobjdumpParseBinary(unsigned int handle);
 	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_ptx_info_load_from_filename( const char *filename, unsigned sm_version);
+	void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version=20, int no_of_ptx=0 );
+	void print_ptx_file( const char *p, unsigned source_num, const char *filename );
+	class symbol_table* init_parser(const char*);
 };
 gpgpu_context* GPGPU_Context();
 
diff --git a/libopencl/opencl_runtime_api.cc b/libopencl/opencl_runtime_api.cc
index 0ec635e..50a02fa 100644
--- a/libopencl/opencl_runtime_api.cc
+++ b/libopencl/opencl_runtime_api.cc
@@ -580,7 +580,7 @@ void _cl_program::Build(const char *options)
       }
       info.m_asm = tmp;
       info.m_symtab = ctx->gpgpu_ptx_sim_load_ptx_from_string( tmp, source_num );
-      gpgpu_ptxinfo_load_from_string( tmp, source_num );
+      ctx->gpgpu_ptxinfo_load_from_string( tmp, source_num );
       free(tmp);
    }
    printf("GPGPU-Sim OpenCL API: finished compiling OpenCL kernels.\n"); 
diff --git a/src/cuda-sim/ptx.l b/src/cuda-sim/ptx.l
index 2546a99..18952a9 100644
--- a/src/cuda-sim/ptx.l
+++ b/src/cuda-sim/ptx.l
@@ -452,14 +452,13 @@ breakaddr  TC; yylval->int_value = BREAKADDR_OP; return OPCODE;
 <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( 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, yylineno );
diff --git a/src/cuda-sim/ptx_loader.cc b/src/cuda-sim/ptx_loader.cc
index 9857741..921d1e6 100644
--- a/src/cuda-sim/ptx_loader.cc
+++ b/src/cuda-sim/ptx_loader.cc
@@ -81,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);
@@ -170,10 +170,9 @@ symbol_table *gpgpu_context::gpgpu_ptx_sim_load_ptx_from_string( const char *p,
        fclose(fp);
     }
     symbol_table *symtab=init_parser(buf);
-    ptx_recognizer recognizer;
-    ptx_lex_init(&(recognizer.scanner));
-    ptx__scan_string(p, recognizer.scanner);
-    int errors = ptx_parse (recognizer.scanner, &recognizer);
+    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");
@@ -186,7 +185,7 @@ symbol_table *gpgpu_context::gpgpu_ptx_sim_load_ptx_from_string( const char *p,
         abort();
         exit(40);
     }
-    ptx_lex_destroy(recognizer.scanner);
+    ptx_lex_destroy(ptx_parser->scanner);
 
     if ( g_debug_execution >= 100 ) 
        print_ptx_file(p,source_num,buf);
@@ -332,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];
@@ -352,17 +351,16 @@ void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_versio
 	}
 
     FILE *ptxinfo_in;
-    ptxinfo_data ptxinfo;
-    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);
+    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, int no_of_ptx )
+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];
@@ -420,14 +418,13 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num
     if( result != 0 ) {
     	// 65280 = duplicate errors
     	if (result == 65280) {
-		ptxinfo_data ptxinfo;
 		FILE *ptxinfo_in;
     		ptxinfo_in = fopen(tempfile_ptxinfo,"r");
-		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);
+		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);
@@ -507,18 +504,17 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num
         }
     }	
 
-    ptxinfo_data ptxinfo;
     if(no_of_ptx>0)
-        ptxinfo.g_ptxinfo_filename = final_tempfile_ptxinfo;
+        ptxinfo->g_ptxinfo_filename = final_tempfile_ptxinfo;
     else
-	ptxinfo.g_ptxinfo_filename = tempfile_ptxinfo;
+	ptxinfo->g_ptxinfo_filename = tempfile_ptxinfo;
     FILE *ptxinfo_in;
-    ptxinfo_in = fopen(ptxinfo.g_ptxinfo_filename,"r");
+    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);
+    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");
diff --git a/src/cuda-sim/ptx_loader.h b/src/cuda-sim/ptx_loader.h
index c3ce888..ee09e16 100644
--- a/src/cuda-sim/ptx_loader.h
+++ b/src/cuda-sim/ptx_loader.h
@@ -29,12 +29,12 @@
 #define PTX_LOADER_H_INCLUDED
 #include <string>
 
-#define LINEBUF_SIZE 1024
+#define PTXINFO_LINEBUF_SIZE 1024
 typedef void * yyscan_t;
 class ptxinfo_data{
     public:
 	yyscan_t scanner;
-	char linebuf[LINEBUF_SIZE];
+	char linebuf[PTXINFO_LINEBUF_SIZE];
 	unsigned col;
 	const char *g_ptxinfo_filename;
 
@@ -44,8 +44,6 @@ class ptxinfo_data{
 extern bool g_override_embedded_ptx;
 extern int no_of_ptx; //counter to track number of ptx files to be extracted in an application.
  
-void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version=20, int no_of_ptx=0 );
-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 897beaf..2872b84 100644
--- a/src/cuda-sim/ptx_parser.cc
+++ b/src/cuda-sim/ptx_parser.cc
@@ -27,6 +27,7 @@
 
 #include "ptx_parser.h"
 #include "ptx_ir.h"
+#include "../../libcuda/gpgpu_context.h"
 
 typedef void * yyscan_t;
 #include "ptx.tab.h"
@@ -51,15 +52,7 @@ static bool g_debug_ir_generation=false;
 const char *g_filename;
 
 // 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;
-
 
 #define PTX_PARSE_DPRINTF(...) \
    if( g_debug_ir_generation ) { \
@@ -70,10 +63,7 @@ int g_error_detected = 0;
       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 )
 {
@@ -122,12 +112,12 @@ void ptx_recognizer::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);
@@ -151,19 +141,18 @@ symbol_table *init_parser( const char *ptx_filename )
    g_ptx_token_decode[generic_space] = "generic_space";
    g_ptx_token_decode[instruction_space] = "instruction_space";
 
-   ptx_recognizer recognizer;
-   ptx_lex_init(&(recognizer.scanner));
-   recognizer.init_directive_state();
-   recognizer.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_set_in(ptx_in, recognizer.scanner);
-   ptx_parse(recognizer.scanner, &recognizer);
-   ptx_in = ptx_get_in(recognizer.scanner);
-   ptx_lex_destroy(recognizer.scanner);
+   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;
@@ -331,7 +320,7 @@ void ptx_recognizer::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 );
diff --git a/src/cuda-sim/ptx_parser.h b/src/cuda-sim/ptx_parser.h
index c52fe20..25c01fe 100644
--- a/src/cuda-sim/ptx_parser.h
+++ b/src/cuda-sim/ptx_parser.h
@@ -34,7 +34,6 @@ 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
 
@@ -57,11 +56,17 @@ class ptx_recognizer {
 	    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 LINEBUF_SIZE (4*1024)
-	char linebuf[LINEBUF_SIZE];
+#define PTX_LINEBUF_SIZE (4*1024)
+	char linebuf[PTX_LINEBUF_SIZE];
 	unsigned col;
 	int g_size;
 	char *g_add_identifier_cached__identifier;
@@ -90,6 +95,14 @@ class ptx_recognizer {
 	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();
@@ -155,6 +168,7 @@ class ptx_recognizer {
 	//Jin: handle instructino group for cdp
 	void start_inst_group();
 	void end_inst_group();
+	bool check_for_duplicates( const char *identifier );
 
 };