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
|
// 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(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))),
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 != memsz)
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(this, new mmu_t(mem, memsz), i);
}
sim_t::~sim_t()
{
for (size_t i = 0; i < procs.size(); i++)
{
mmu_t* pmmu = &procs[i]->mmu;
delete procs[i];
delete pmmu;
}
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;
}
}
void sim_t::run()
{
while (!htif->done())
{
if (debug || ctrlc_pressed)
interactive();
else
step(INTERLEAVE, false);
}
}
void sim_t::step(size_t n, bool noisy)
{
for (size_t i = 0, steps = 0; i < n; i += steps)
{
htif->tick();
if (!running())
break;
steps = std::min(n - i, INTERLEAVE - current_step);
procs[current_proc]->step(steps, noisy);
current_step += steps;
if (current_step == INTERLEAVE)
{
current_step = 0;
procs[current_proc]->yield_load_reservation();
if (++current_proc == procs.size())
current_proc = 0;
}
}
}
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->done())
htif->tick();
}
|
