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
|
// See LICENSE for license details.
#include "sim.h"
#include "htif.h"
#include <map>
#include <iostream>
#include <climits>
#include <cstdlib>
#include <cassert>
#include <signal.h>
volatile bool ctrlc_pressed = false;
static void handle_signal(int sig)
{
if (ctrlc_pressed)
exit(-1);
ctrlc_pressed = true;
signal(sig, &handle_signal);
}
sim_t::sim_t(const char* isa, size_t nprocs, size_t mem_mb,
const std::vector<std::string>& args)
: htif(new htif_isasim_t(this, args)), procs(std::max(nprocs, size_t(1))),
rtc(0), current_step(0), current_proc(0), debug(false)
{
signal(SIGINT, &handle_signal);
// allocate target machine's memory, shrinking it as necessary
// until the allocation succeeds
size_t memsz0 = (size_t)mem_mb << 20;
size_t quantum = 1L << 20;
if (memsz0 == 0)
memsz0 = 1L << (sizeof(size_t) == 8 ? 32 : 30);
memsz = memsz0;
while ((mem = (char*)calloc(1, memsz)) == NULL)
memsz = memsz*10/11/quantum*quantum;
if (memsz != memsz0)
fprintf(stderr, "warning: only got %lu bytes of target mem (wanted %lu)\n",
(unsigned long)memsz, (unsigned long)memsz0);
debug_mmu = new mmu_t(mem, memsz);
for (size_t i = 0; i < procs.size(); i++)
procs[i] = new processor_t(isa, this, i);
}
sim_t::~sim_t()
{
for (size_t i = 0; i < procs.size(); i++)
delete procs[i];
delete debug_mmu;
free(mem);
}
void sim_t::send_ipi(reg_t who)
{
if (who < procs.size())
procs[who]->deliver_ipi();
}
reg_t sim_t::get_scr(int which)
{
switch (which)
{
case 0: return procs.size();
case 1: return memsz >> 20;
default: return -1;
}
}
int sim_t::run()
{
if (!debug && log)
set_procs_debug(true);
while (htif->tick())
{
if (debug || ctrlc_pressed)
interactive();
else
step(INTERLEAVE);
}
return htif->exit_code();
}
void sim_t::step(size_t n)
{
for (size_t i = 0, steps = 0; i < n; i += steps)
{
steps = std::min(n - i, INTERLEAVE - current_step);
procs[current_proc]->step(steps);
current_step += steps;
if (current_step == INTERLEAVE)
{
current_step = 0;
procs[current_proc]->yield_load_reservation();
if (++current_proc == procs.size()) {
current_proc = 0;
rtc += INTERLEAVE / INSNS_PER_RTC_TICK;
}
htif->tick();
}
}
}
bool sim_t::running()
{
for (size_t i = 0; i < procs.size(); i++)
if (procs[i]->running())
return true;
return false;
}
void sim_t::stop()
{
procs[0]->state.tohost = 1;
while (htif->tick())
;
}
void sim_t::set_debug(bool value)
{
debug = value;
}
void sim_t::set_log(bool value)
{
log = value;
}
void sim_t::set_histogram(bool value)
{
histogram_enabled = value;
for (size_t i = 0; i < procs.size(); i++) {
procs[i]->set_histogram(histogram_enabled);
}
}
void sim_t::set_procs_debug(bool value)
{
for (size_t i=0; i< procs.size(); i++)
procs[i]->set_debug(value);
}
bool sim_t::mmio_load(reg_t addr, size_t len, uint8_t* bytes)
{
return false;
}
bool sim_t::mmio_store(reg_t addr, size_t len, const uint8_t* bytes)
{
return false;
}
|
