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
|
//developed by Mahmoud Khairy, Purdue Univ
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#ifndef TRACE_DRIVEN_H
#define TRACE_DRIVEN_H
#include "../abstract_hardware_model.h"
#include "../gpgpu-sim/shader.h"
#include "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;
}
trace_warp_inst_t(const class core_config *config, gpgpu_context* gpgpu_context ):warp_inst_t(config) {
m_gpgpu_context = gpgpu_context;
m_opcode=0;
}
bool parse_from_string(std::string trace, const std::unordered_map<std::string,OpcodeChar>* OpcodeMap);
private:
void set_latency(unsigned cat);
gpgpu_context* m_gpgpu_context;
unsigned m_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);
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;
unsigned binary_verion;
const std::unordered_map<std::string,OpcodeChar>* OpcodeMap;
};
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);
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
|
