Repository navigation
Expand file tree
/
Copy pathdebug.c
More file actions
166 lines (143 loc) · 4.59 KB
/
Copy pathdebug.c
File metadata and controls
166 lines (143 loc) · 4.59 KB
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
/* This file implements kernel debugging functionality that is not included
* in the standard kernel. Available functionality includes timing of lock
* functions and sanity checking of the scheduling queues.
*/
#include "kernel.h"
#include "proc.h"
#include "debug.h"
#include <limits.h>
#if DEBUG_TIME_LOCKS /* only include code if enabled */
/* Data structures to store lock() timing data. */
struct lock_timingdata timingdata[TIMING_CATEGORIES];
static unsigned long starttimes[TIMING_CATEGORIES][2];
#define HIGHCOUNT 0
#define LOWCOUNT 1
void timer_start(int cat, char *name)
{
static int init = 0;
unsigned long h, l;
int i;
if (cat < 0 || cat >= TIMING_CATEGORIES) return;
for(i = 0; i < sizeof(timingdata[0].names) && *name; i++)
timingdata[cat].names[i] = *name++;
timingdata[0].names[sizeof(timingdata[0].names)-1] = '\0';
if (starttimes[cat][HIGHCOUNT]) { return; }
if (!init) {
int t, f;
init = 1;
for(t = 0; t < TIMING_CATEGORIES; t++) {
timingdata[t].lock_timings_range[0] = 0;
timingdata[t].resets = timingdata[t].misses =
timingdata[t].measurements = 0;
}
}
read_tsc(&starttimes[cat][HIGHCOUNT], &starttimes[cat][LOWCOUNT]);
}
void timer_end(int cat)
{
unsigned long h, l, d = 0, binsize;
int bin;
read_tsc(&h, &l);
if (cat < 0 || cat >= TIMING_CATEGORIES) return;
if (!starttimes[cat][HIGHCOUNT]) {
timingdata[cat].misses++;
return;
}
if (starttimes[cat][HIGHCOUNT] == h) {
d = (l - starttimes[cat][1]);
} else if (starttimes[cat][HIGHCOUNT] == h-1 &&
starttimes[cat][LOWCOUNT] > l) {
d = ((ULONG_MAX - starttimes[cat][LOWCOUNT]) + l);
} else {
timingdata[cat].misses++;
return;
}
starttimes[cat][HIGHCOUNT] = 0;
if (!timingdata[cat].lock_timings_range[0] ||
d < timingdata[cat].lock_timings_range[0] ||
d > timingdata[cat].lock_timings_range[1]) {
int t;
if (!timingdata[cat].lock_timings_range[0] ||
d < timingdata[cat].lock_timings_range[0])
timingdata[cat].lock_timings_range[0] = d;
if (!timingdata[cat].lock_timings_range[1] ||
d > timingdata[cat].lock_timings_range[1])
timingdata[cat].lock_timings_range[1] = d;
for(t = 0; t < TIMING_POINTS; t++)
timingdata[cat].lock_timings[t] = 0;
timingdata[cat].binsize =
(timingdata[cat].lock_timings_range[1] -
timingdata[cat].lock_timings_range[0])/(TIMING_POINTS+1);
if (timingdata[cat].binsize < 1)
timingdata[cat].binsize = 1;
timingdata[cat].resets++;
}
bin = (d-timingdata[cat].lock_timings_range[0]) /
timingdata[cat].binsize;
if (bin < 0 || bin >= TIMING_POINTS) {
int t;
/* this indicates a bug, but isn't really serious */
for(t = 0; t < TIMING_POINTS; t++)
timingdata[cat].lock_timings[t] = 0;
timingdata[cat].misses++;
} else {
timingdata[cat].lock_timings[bin]++;
timingdata[cat].measurements++;
}
return;
}
#endif /* DEBUG_TIME_LOCKS */
#if DEBUG_SCHED_CHECK /* only include code if enabled */
#define PROCLIMIT 10000
PUBLIC void
check_runqueues(char *when)
{
int q, l = 0;
register struct proc *xp;
for (xp = BEG_PROC_ADDR; xp < END_PROC_ADDR; ++xp) {
xp->p_found = 0;
if (l++ > PROCLIMIT) { panic("check error", NO_NUM); }
}
for (q=0; q < NR_SCHED_QUEUES; q++) {
if (rdy_head[q] && !rdy_tail[q]) {
kprintf("head but no tail: %s", when);
panic("scheduling error", NO_NUM);
}
if (!rdy_head[q] && rdy_tail[q]) {
kprintf("tail but no head: %s", when);
panic("scheduling error", NO_NUM);
}
if (rdy_tail[q] && rdy_tail[q]->p_nextready != NIL_PROC) {
kprintf("tail and tail->next not null; %s", when);
panic("scheduling error", NO_NUM);
}
for(xp = rdy_head[q]; xp != NIL_PROC; xp = xp->p_nextready) {
if (!xp->p_ready) {
kprintf("scheduling error: unready on runq: %s\n", when);
panic("found unready process on run queue", NO_NUM);
}
if (xp->p_priority != q) {
kprintf("scheduling error: wrong priority: %s\n", when);
panic("wrong priority", NO_NUM);
}
if (xp->p_found) {
kprintf("scheduling error: double scheduling: %s\n", when);
panic("proc more than once on scheduling queue", NO_NUM);
}
xp->p_found = 1;
if (xp->p_nextready == NIL_PROC && rdy_tail[q] != xp) {
kprintf("scheduling error: last element not tail: %s\n", when);
panic("scheduling error", NO_NUM);
}
if (l++ > PROCLIMIT) panic("loop in schedule queue?", NO_NUM);
}
}
for (xp = BEG_PROC_ADDR; xp < END_PROC_ADDR; ++xp) {
if (! isemptyp(xp) && xp->p_ready && ! xp->p_found) {
kprintf("scheduling error: ready not on queue: %s\n", when);
panic("ready proc not on scheduling queue", NO_NUM);
if (l++ > PROCLIMIT) { panic("loop in proc.t?", NO_NUM); }
}
}
}
#endif /* DEBUG_SCHED_CHECK */