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
|
// 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;
}
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;
}
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(gpgpu_sim* m_gpgpu_sim);
void set_latency(unsigned category, unsigned& latency,
unsigned& initiation_interval);
void parse_config();
private:
unsigned int_latency, fp_latency, dp_latency, sfu_latency, tensor_latency;
unsigned int_init, fp_init, dp_init, sfu_init, tensor_init;
gpgpu_sim* m_gpgpu_sim;
};
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:
trace_shd_warp_t() { trace_pc = 0; }
std::vector<trace_warp_inst_t> warp_traces;
const trace_warp_inst_t* get_next_inst();
void clear();
bool trace_done();
address_type get_start_pc();
address_type get_pc();
private:
unsigned trace_pc;
};
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) {
m_trace_warp.resize(get_config()->max_warps_per_shader);
}
virtual void checkExecutionStatusAndUpdate(warp_inst_t& inst, unsigned t,
unsigned tid);
void init_traces(unsigned start_warp, unsigned end_warp,
kernel_info_t& kernel);
unsigned trace_sim_inc_thread(kernel_info_t& kernel);
virtual void func_exec_inst(warp_inst_t& inst);
friend class shader_core_ctx;
private:
std::vector<trace_shd_warp_t> m_trace_warp;
};
#endif
|
