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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
#include "sharedres.h"
#include "blocking.h"
#include "rw-blocking.h"
#include "stl-helper.h"
static Interference pf_writer_fifo(
const TaskInfo& tsk, const ClusterResources& writes,
const unsigned int num_writes,
const unsigned int num_reads,
const unsigned int res_id,
const unsigned int procs_per_cluster,
const int dedicated_irq)
{
const unsigned int per_src_wlimit = num_reads + num_writes;
const unsigned long interval = tsk.get_response();
ClusterLimits limits;
int idx;
limits.reserve(writes.size());
enumerate(writes, ct, idx)
{
unsigned int total, parallelism = procs_per_cluster;
if (idx == dedicated_irq)
parallelism--;
if (parallelism && (int) tsk.get_cluster() == idx)
parallelism--;
// At most one blocking request per remote CPU in
// cluster per request.
if (parallelism)
total = num_reads + num_writes * parallelism;
else
// No interference from writers if we are hogging
// the only available CPU.
total = 0;
limits.push_back(ClusterLimit(total, per_src_wlimit));
}
Interference blocking;
blocking = bound_blocking_all_clusters(writes,
limits,
res_id,
interval,
&tsk);
return blocking;
}
static Interference pf_reader_all(
const TaskInfo& tsk,
const Resources& all_reads,
const unsigned int num_writes,
const unsigned int num_wblock,
const unsigned int num_reads,
const unsigned int res_id,
const unsigned int procs_per_cluster,
const unsigned int num_procs)
{
const unsigned long interval = tsk.get_response();
Interference blocking;
unsigned int rlimit = std::min(num_wblock + num_writes,
num_reads + num_writes * (num_procs - 1));
blocking = bound_blocking(all_reads[res_id],
interval,
rlimit,
rlimit,
// exclude all if c == 1
procs_per_cluster == 1,
&tsk);
return blocking;
}
BlockingBounds* clustered_rw_omlp_bounds(const ResourceSharingInfo& info,
unsigned int procs_per_cluster,
int dedicated_irq)
{
// split everything by partition
Clusters clusters;
split_by_cluster(info, clusters);
// split each partition by resource
ClusterResources resources;
split_by_resource(clusters, resources);
// split all by resource
Resources all_task_reqs, all_reads, __all_writes;
split_by_resource(info, all_task_reqs);
split_by_type(all_task_reqs, all_reads, __all_writes);
// sort each contention set by request length
sort_by_request_length(resources);
sort_by_request_length(all_reads);
// split by type --- sorted order is maintained
ClusterResources __reads, writes;
split_by_type(resources, __reads, writes);
// We need for each task the maximum request span. We also need the
// maximum direct blocking from remote partitions for each request. We
// can determine both in one pass.
const unsigned int num_procs = procs_per_cluster * clusters.size();
unsigned int i;
// direct blocking results
BlockingBounds* _results = new BlockingBounds(info);
BlockingBounds& results = *_results;
for (i = 0; i < info.get_tasks().size(); i++)
{
const TaskInfo& tsk = info.get_tasks()[i];
RWCounts rwcounts;
Interference bterm;
merge_rw_requests(tsk, rwcounts);
foreach(rwcounts, jt)
{
const RWCount& rw = *jt;
// skip placeholders
if (!rw.num_reads && !rw.num_writes)
continue;
Interference wblocking, rblocking;
wblocking = pf_writer_fifo(tsk, writes, rw.num_writes,
rw.num_reads, rw.res_id,
procs_per_cluster,
dedicated_irq);
rblocking = pf_reader_all(tsk, all_reads, rw.num_writes,
wblocking.count, rw.num_reads,
rw.res_id, procs_per_cluster,
num_procs);
//**** SINGLE WRITE
Interference rblocking_w1, wblocking_w1;
// Keep track of maximum request span.
// Is this already a single-issue request?
if (rw.num_writes &&
(rw.num_writes != 1 || rw.num_reads != 0))
{
wblocking_w1 = pf_writer_fifo(tsk, writes, 1, 0,
rw.res_id, procs_per_cluster,
dedicated_irq);
rblocking_w1 = pf_reader_all(
tsk, all_reads, 1,
wblocking_w1.count, 0,
rw.res_id, procs_per_cluster,
num_procs);
}
else if (rw.num_writes)
{
wblocking_w1 = wblocking;
rblocking_w1 = rblocking;
}
// else: zero, nothing to do
//**** SINGLE READ
Interference rblocking_r1, wblocking_r1;
if (rw.num_reads &&
(rw.num_reads != 1 || rw.num_writes != 0))
{
wblocking_r1 = pf_writer_fifo(tsk, writes, 0, 1,
rw.res_id, procs_per_cluster,
dedicated_irq);
rblocking_r1 = pf_reader_all(
tsk, all_reads, 0,
wblocking_r1.count, 1,
rw.res_id, procs_per_cluster,
num_procs);
}
else if (rw.num_reads)
{
wblocking_r1 = wblocking;
rblocking_r1 = rblocking;
}
// else: zero, nothing to do
// The span includes our own request.
if (rw.num_writes)
{
wblocking_w1.total_length += rw.wlength;
wblocking_w1.count += 1;
}
if (rw.num_reads)
{
rblocking_r1.total_length += rw.rlength;
wblocking_r1.count += 1;
}
// combine
wblocking_w1 += rblocking_w1;
wblocking_r1 += rblocking_r1;
wblocking += rblocking;
results.raise_request_span(i, wblocking_w1);
results.raise_request_span(i, wblocking_r1);
bterm += wblocking;
}
results[i] = bterm;
}
// This is the initial delay due to priority donation.
charge_arrival_blocking(info, results);
return _results;
}
BlockingBounds* phase_fair_rw_bounds(const ResourceSharingInfo& info,
unsigned int procs_per_cluster,
int dedicated_irq)
{
// These are structurally equivalent. Therefore, no need to reimplement
// everything from scratch.
return clustered_rw_omlp_bounds(info, procs_per_cluster, dedicated_irq);
}
|
