1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
// developed by Mahmoud Khairy, Purdue Univ
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef TRACE_DRIVEN_H
#define TRACE_DRIVEN_H
#include "../abstract_hardware_model.h"
#include "../gpgpu-sim/shader.h"
#include "ISA_Def/trace_opcode.h"
class trace_function_info : public function_info {
public:
trace_function_info(const struct gpgpu_ptx_sim_info& info,
gpgpu_context* m_gpgpu_context)
: function_info(0, m_gpgpu_context) {
m_kernel_info = info;
}
virtual const struct gpgpu_ptx_sim_info* get_kernel_info() const {
return &m_kernel_info;
}
virtual const void set_kernel_info(const struct gpgpu_ptx_sim_info& info) {
m_kernel_info = info;
}
virtual ~trace_function_info() {}
};
class trace_warp_inst_t : public warp_inst_t {
public:
trace_warp_inst_t() {
m_gpgpu_context = NULL;
m_opcode = 0;
m_tconfig = NULL;
should_do_atomic = false;
}
trace_warp_inst_t(const class core_config* config,
gpgpu_context* gpgpu_context, class trace_config* tconfig)
: warp_inst_t(config) {
m_gpgpu_context = gpgpu_context;
m_opcode = 0;
m_tconfig = tconfig;
should_do_atomic = false;
}
bool parse_from_string(
std::string trace,
const std::unordered_map<std::string, OpcodeChar>* OpcodeMap);
private:
gpgpu_context* m_gpgpu_context;
class trace_config* m_tconfig;
unsigned m_opcode;
bool check_opcode_contain(const std::vector<std::string>& opcode,
std::string param);
unsigned get_datawidth_from_opcode(const std::vector<std::string>& opcode);
};
class trace_kernel_info_t : public kernel_info_t {
public:
trace_kernel_info_t(dim3 gridDim, dim3 blockDim, unsigned m_binary_verion,
trace_function_info* m_function_info,
std::ifstream* inputstream, gpgpu_sim* gpgpu_sim,
gpgpu_context* gpgpu_context, class trace_config* config);
bool get_next_threadblock_traces(
std::vector<std::vector<trace_warp_inst_t>*> threadblock_traces);
private:
std::ifstream* ifs;
gpgpu_sim* m_gpgpu_sim;
gpgpu_context* m_gpgpu_context;
trace_config* m_tconfig;
unsigned binary_verion;
const std::unordered_map<std::string, OpcodeChar>* OpcodeMap;
};
class trace_config {
public:
trace_config();
void set_latency(unsigned category, unsigned& latency,
unsigned& initiation_interval);
void parse_config();
void reg_options(option_parser_t opp);
char* get_traces_filename() { return g_traces_filename; }
private:
unsigned int_latency, fp_latency, dp_latency, sfu_latency, tensor_latency;
unsigned int_init, fp_init, dp_init, sfu_init, tensor_init;
char* g_traces_filename;
char* trace_opcode_latency_initiation_int;
char* trace_opcode_latency_initiation_sp;
char* trace_opcode_latency_initiation_dp;
char* trace_opcode_latency_initiation_sfu;
char* trace_opcode_latency_initiation_tensor;
};
class trace_parser {
public:
trace_parser(const char* kernellist_filepath, gpgpu_sim* m_gpgpu_sim,
gpgpu_context* m_gpgpu_context);
std::vector<std::string> parse_kernellist_file();
trace_kernel_info_t* parse_kernel_info(
const std::string& kerneltraces_filepath, trace_config* config);
void parse_memcpy_info(const std::string& memcpy_command, size_t& add,
size_t& count);
void kernel_finalizer(trace_kernel_info_t* kernel_info);
private:
std::string kernellist_filename;
std::ifstream ifs;
gpgpu_sim* m_gpgpu_sim;
gpgpu_context* m_gpgpu_context;
};
class trace_shd_warp_t : public shd_warp_t {
public:
trace_shd_warp_t(class shader_core_ctx* shader, unsigned warp_size)
: shd_warp_t(shader, warp_size) {
trace_pc = 0;
}
std::vector<trace_warp_inst_t> warp_traces;
const trace_warp_inst_t* get_next_trace_inst();
void clear();
bool trace_done();
address_type get_start_trace_pc();
virtual address_type get_pc();
private:
unsigned trace_pc;
};
class trace_gpgpu_sim : public gpgpu_sim {
public:
trace_gpgpu_sim(const gpgpu_sim_config& config, gpgpu_context* ctx)
: gpgpu_sim(config, ctx) {
createSIMTCluster();
}
virtual void createSIMTCluster();
};
class trace_simt_core_cluster : public simt_core_cluster {
public:
trace_simt_core_cluster(class gpgpu_sim* gpu, unsigned cluster_id,
const shader_core_config* config,
const memory_config* mem_config,
class shader_core_stats* stats,
class memory_stats_t* mstats)
: simt_core_cluster(gpu, cluster_id, config, mem_config, stats, mstats) {
create_shader_core_ctx();
}
virtual void create_shader_core_ctx();
};
class trace_shader_core_ctx : public shader_core_ctx {
public:
trace_shader_core_ctx(class gpgpu_sim* gpu, class simt_core_cluster* cluster,
unsigned shader_id, unsigned tpc_id,
const shader_core_config* config,
const memory_config* mem_config,
shader_core_stats* stats)
: shader_core_ctx(gpu, cluster, shader_id, tpc_id, config, mem_config,
stats) {
create_front_pipeline();
create_shd_warp();
create_schedulers();
create_exec_pipeline();
}
virtual void checkExecutionStatusAndUpdate(warp_inst_t& inst, unsigned t,
unsigned tid);
virtual void init_warps(unsigned cta_id, unsigned start_thread,
unsigned end_thread, unsigned ctaid, int cta_size,
kernel_info_t& kernel);
virtual void func_exec_inst(warp_inst_t& inst);
virtual unsigned sim_init_thread(kernel_info_t& kernel,
ptx_thread_info** thread_info, int sid,
unsigned tid, unsigned threads_left,
unsigned num_threads, core_t* core,
unsigned hw_cta_id, unsigned hw_warp_id,
gpgpu_t* gpu);
virtual void create_shd_warp();
virtual const warp_inst_t* get_next_inst(unsigned warp_id, address_type pc);
virtual void updateSIMTStack(unsigned warpId, warp_inst_t* inst);
virtual void get_pdom_stack_top_info(unsigned warp_id, const warp_inst_t* pI,
unsigned* pc, unsigned* rpc);
virtual const active_mask_t& get_active_mask(unsigned warp_id,
const warp_inst_t* pI);
private:
void init_traces(unsigned start_warp, unsigned end_warp,
kernel_info_t& kernel);
};
#endif
|
