diff options
author | Andrea Bastoni <bastoni@cs.unc.edu> | 2010-09-22 14:18:35 -0400 |
---|---|---|
committer | Bjoern B. Brandenburg <bbb@cs.unc.edu> | 2011-01-26 18:20:24 -0500 |
commit | 688805400bb4ff86801291e3d11e4430285fc5a3 (patch) | |
tree | 47a7478829687dec79cffd9d02b27ed0476a01fd | |
parent | 128da49ce7b85ea02f98618706a52c5f73a3f1d0 (diff) |
Initialize number of slices in edf_wm_params structure.
Move parsing function in common.c
-rw-r--r-- | bin/common.c | 104 | ||||
-rw-r--r-- | bin/rt_launch_edfwm.c | 87 | ||||
-rw-r--r-- | bin/rtspin_edfwm.c | 86 | ||||
-rw-r--r-- | include/common.h | 4 |
4 files changed, 109 insertions, 172 deletions
diff --git a/bin/common.c b/bin/common.c index 452b882..1cf5be0 100644 --- a/bin/common.c +++ b/bin/common.c | |||
@@ -9,3 +9,107 @@ void bail_out(const char* msg) | |||
9 | perror(msg); | 9 | perror(msg); |
10 | exit(-1 * errno); | 10 | exit(-1 * errno); |
11 | } | 11 | } |
12 | |||
13 | /* EDF-WM helper functions to parse a custom text file format to "easily" | ||
14 | * launch tests with rtspin and rt_launch: | ||
15 | * | ||
16 | * Format for task: | ||
17 | * | ||
18 | * <task_id execution_cost period phase cpu slices_number> . | ||
19 | * | ||
20 | * If the task is split on multiple slices, slices_number is non 0 | ||
21 | * and we scan a list of slice parameters up to slices_number: | ||
22 | * | ||
23 | * Format for slices: | ||
24 | * | ||
25 | * <task_id cpu deadline(from job release) budget offset> . | ||
26 | * | ||
27 | * The offset is the start time for the slice relative to the job release. | ||
28 | * | ||
29 | * Example: | ||
30 | * 14 2.26245771754 10 0 5 2 | ||
31 | * 14 5 5.000000 1.497306 0.000000 | ||
32 | * 14 7 10.000000 0.765152 5.000000 | ||
33 | */ | ||
34 | |||
35 | #define fms_to_ns(x) (lt_t)(((x) * __NS_PER_MS)) | ||
36 | /* | ||
37 | * <task_id, cpu, deadline (from job release), budget, offset> . | ||
38 | */ | ||
39 | int parse_edfwm_slice(FILE *ts, int slices_no, int task_id, | ||
40 | struct edf_wm_params *wm) | ||
41 | { | ||
42 | int i, tid; | ||
43 | unsigned int cpu; | ||
44 | double deadline, budget, offset; | ||
45 | |||
46 | for (i = 0; i < slices_no; i++) { | ||
47 | |||
48 | if (fscanf(ts, "%d %u %lf %lf %lf\n", &tid, &cpu, | ||
49 | &deadline, &budget, &offset) != EOF) { | ||
50 | |||
51 | if (task_id != tid) { | ||
52 | fprintf(stderr, "task_id %d != tid %d\n", | ||
53 | task_id, tid); | ||
54 | return -1; | ||
55 | } | ||
56 | |||
57 | wm->slices[i].deadline = fms_to_ns(deadline); | ||
58 | wm->slices[i].budget = fms_to_ns(budget); | ||
59 | wm->slices[i].offset = fms_to_ns(offset); | ||
60 | |||
61 | printf("slice(tid, cpu, d, e, ph) = (%d, %u, %llu, %llu, %llu)\n", | ||
62 | tid, cpu, wm->slices[i].deadline, | ||
63 | wm->slices[i].budget, wm->slices[i].offset); | ||
64 | } | ||
65 | |||
66 | if (ferror(ts)) { | ||
67 | fprintf(stderr, "Cannot read file\n"); | ||
68 | return -1; | ||
69 | } | ||
70 | } | ||
71 | wm->count = slices_no; | ||
72 | printf("--- total %u slices ---\n", wm->count); | ||
73 | return 0; | ||
74 | } | ||
75 | |||
76 | /* | ||
77 | * <task_id, execution_cost, period, phase, cpu, slices_number> . | ||
78 | */ | ||
79 | int parse_edfwm_ts_file(FILE *ts, struct rt_task *rt) | ||
80 | { | ||
81 | int task_id, ret = 1; | ||
82 | unsigned int cpu, sliceno; | ||
83 | double fwcet, fperiod, fphase; | ||
84 | |||
85 | ret = fscanf(ts, "%d %lf %lf %lf %d %d\n", | ||
86 | &task_id, &fwcet, &fperiod, &fphase, &cpu, &sliceno); | ||
87 | |||
88 | if (ferror(ts)) | ||
89 | goto err; | ||
90 | |||
91 | rt->exec_cost = fms_to_ns(fwcet); | ||
92 | rt->period = fms_to_ns(fperiod); | ||
93 | rt->phase = fms_to_ns(fphase); | ||
94 | rt->cpu = cpu; | ||
95 | rt->cls = RT_CLASS_HARD; | ||
96 | rt->budget_policy = PRECISE_ENFORCEMENT; | ||
97 | |||
98 | printf("(tid, wcet, period, ph, cpu, slices) = " | ||
99 | "(%d, %llu, %llu, %llu, %u, %u)\n", | ||
100 | task_id, rt->exec_cost, rt->period, rt->phase, cpu, sliceno); | ||
101 | if (sliceno > 0) { | ||
102 | memset(&rt->semi_part, 0, sizeof(struct edf_wm_params)); | ||
103 | ret = parse_edfwm_slice(ts, sliceno, task_id, | ||
104 | (struct edf_wm_params*) &rt->semi_part); | ||
105 | if (ret < 0) | ||
106 | goto err; | ||
107 | } | ||
108 | |||
109 | return 0; | ||
110 | |||
111 | err: | ||
112 | fprintf(stderr, "Error parsing file\n"); | ||
113 | return -1; | ||
114 | } | ||
115 | |||
diff --git a/bin/rt_launch_edfwm.c b/bin/rt_launch_edfwm.c index b5a972c..9e8a322 100644 --- a/bin/rt_launch_edfwm.c +++ b/bin/rt_launch_edfwm.c | |||
@@ -7,6 +7,7 @@ | |||
7 | 7 | ||
8 | #include "litmus.h" | 8 | #include "litmus.h" |
9 | #include "common.h" | 9 | #include "common.h" |
10 | |||
10 | typedef struct { | 11 | typedef struct { |
11 | int wait; | 12 | int wait; |
12 | char * exec_path; | 13 | char * exec_path; |
@@ -36,92 +37,6 @@ void usage(char *error) { | |||
36 | exit(1); | 37 | exit(1); |
37 | } | 38 | } |
38 | 39 | ||
39 | #define fms_to_ns(x) (lt_t)(((x) * __NS_PER_MS)) | ||
40 | /* | ||
41 | * <task_id, cpu, deadline (from job release), budget, offset> . | ||
42 | */ | ||
43 | int parse_edfwm_slice(FILE *ts, int slices_no, int task_id, | ||
44 | struct edf_wm_params *wm) | ||
45 | { | ||
46 | int i, tid; | ||
47 | unsigned int cpu; | ||
48 | double deadline, budget, offset; | ||
49 | |||
50 | for (i = 0; i < slices_no; i++) { | ||
51 | |||
52 | if (fscanf(ts, "%d %u %lf %lf %lf\n", &tid, &cpu, | ||
53 | &deadline, &budget, &offset) != EOF) { | ||
54 | |||
55 | if (task_id != tid) { | ||
56 | fprintf(stderr, "task_id %d != tid %d\n", | ||
57 | task_id, tid); | ||
58 | return -1; | ||
59 | } | ||
60 | |||
61 | wm->slices[i].deadline = fms_to_ns(deadline); | ||
62 | wm->slices[i].budget = fms_to_ns(budget); | ||
63 | wm->slices[i].offset = fms_to_ns(offset); | ||
64 | printf("slice(tid, cpu, d, e, ph) = (%d, %u, %llu, %llu, %llu)\n", | ||
65 | tid, cpu, wm->slices[i].deadline, | ||
66 | wm->slices[i].budget, wm->slices[i].offset); | ||
67 | } | ||
68 | if (ferror(ts)) { | ||
69 | fprintf(stderr, "Cannot read file\n"); | ||
70 | return -1; | ||
71 | } | ||
72 | } | ||
73 | return 0; | ||
74 | } | ||
75 | |||
76 | /* Custom format to read parameters for tasks from a plain text file: | ||
77 | * <task_id, execution_cost, period, phase, cpu, slices_number> . | ||
78 | * If the task is split on multiple slices, slices_number is non 0 | ||
79 | * and we scan a list of slice parameters up to slices_number: | ||
80 | * <task_id, cpu, deadline (from job release), budget, offset> . | ||
81 | * The offset is the start time for the slice relative to the job release. | ||
82 | * | ||
83 | * FIXME: this function should go in a separate file where all the parsing | ||
84 | * funtions for the semi-part plugins are. It will help in later testing with | ||
85 | * "tasks" programs. | ||
86 | */ | ||
87 | int parse_edfwm_ts_file(FILE *ts, struct rt_task *rt) | ||
88 | { | ||
89 | int task_id, ret = 1; | ||
90 | unsigned int cpu, sliceno; | ||
91 | double fwcet, fperiod, fphase; | ||
92 | |||
93 | ret = fscanf(ts, "%d %lf %lf %lf %d %d\n", | ||
94 | &task_id, &fwcet, &fperiod, &fphase, &cpu, &sliceno); | ||
95 | |||
96 | if (ferror(ts)) | ||
97 | goto err; | ||
98 | |||
99 | rt->exec_cost = fms_to_ns(fwcet); | ||
100 | rt->period = fms_to_ns(fperiod); | ||
101 | rt->phase = fms_to_ns(fphase); | ||
102 | rt->cpu = cpu; | ||
103 | rt->cls = RT_CLASS_HARD; | ||
104 | rt->budget_policy = PRECISE_ENFORCEMENT; | ||
105 | |||
106 | printf("(tid, wcet, period, ph, cpu, slices) = " | ||
107 | "(%d, %llu, %llu, %llu, %u, %u)\n", | ||
108 | task_id, rt->exec_cost, rt->period, rt->phase, cpu, sliceno); | ||
109 | |||
110 | if (sliceno > 0) { | ||
111 | memset(&rt->semi_part, 0, sizeof(struct edf_wm_params)); | ||
112 | ret = parse_edfwm_slice(ts, sliceno, task_id, | ||
113 | (struct edf_wm_params*) &rt->semi_part); | ||
114 | if (ret < 0) | ||
115 | goto err; | ||
116 | } | ||
117 | |||
118 | return 0; | ||
119 | |||
120 | err: | ||
121 | fprintf(stderr, "Error parsing file\n"); | ||
122 | return -1; | ||
123 | } | ||
124 | |||
125 | #define OPTSTR "w" | 40 | #define OPTSTR "w" |
126 | 41 | ||
127 | int main(int argc, char** argv) | 42 | int main(int argc, char** argv) |
diff --git a/bin/rtspin_edfwm.c b/bin/rtspin_edfwm.c index 200fb4c..21a5f3b 100644 --- a/bin/rtspin_edfwm.c +++ b/bin/rtspin_edfwm.c | |||
@@ -133,92 +133,6 @@ static int job(double exec_time) | |||
133 | return 0; | 133 | return 0; |
134 | } | 134 | } |
135 | 135 | ||
136 | #define fms_to_ns(x) (lt_t)(((x) * __NS_PER_MS)) | ||
137 | /* | ||
138 | * <task_id, cpu, deadline (from job release), budget, offset> . | ||
139 | */ | ||
140 | int parse_edfwm_slice(FILE *ts, int slices_no, int task_id, | ||
141 | struct edf_wm_params *wm) | ||
142 | { | ||
143 | int i, tid; | ||
144 | unsigned int cpu; | ||
145 | double deadline, budget, offset; | ||
146 | |||
147 | for (i = 0; i < slices_no; i++) { | ||
148 | |||
149 | if (fscanf(ts, "%d %u %lf %lf %lf\n", &tid, &cpu, | ||
150 | &deadline, &budget, &offset) != EOF) { | ||
151 | |||
152 | if (task_id != tid) { | ||
153 | fprintf(stderr, "task_id %d != tid %d\n", | ||
154 | task_id, tid); | ||
155 | return -1; | ||
156 | } | ||
157 | |||
158 | wm->slices[i].deadline = fms_to_ns(deadline); | ||
159 | wm->slices[i].budget = fms_to_ns(budget); | ||
160 | wm->slices[i].offset = fms_to_ns(offset); | ||
161 | |||
162 | printf("slice(tid, cpu, d, e, ph) = (%d, %u, %llu, %llu, %llu)\n", | ||
163 | tid, cpu, wm->slices[i].deadline, | ||
164 | wm->slices[i].budget, wm->slices[i].offset); | ||
165 | } | ||
166 | if (ferror(ts)) { | ||
167 | fprintf(stderr, "Cannot read file\n"); | ||
168 | return -1; | ||
169 | } | ||
170 | } | ||
171 | return 0; | ||
172 | } | ||
173 | |||
174 | /* Custom format to read parameters for tasks from a plain text file: | ||
175 | * <task_id, execution_cost, period, phase, cpu, slices_number> . | ||
176 | * If the task is split on multiple slices, slices_number is non 0 | ||
177 | * and we scan a list of slice parameters up to slices_number: | ||
178 | * <task_id, cpu, deadline (from job release), budget, offset> . | ||
179 | * The offset is the start time for the slice relative to the job release. | ||
180 | * | ||
181 | * FIXME: this function should go in a separate file where all the parsing | ||
182 | * funtions for the semi-part plugins are. It will help in later testing with | ||
183 | * "tasks" programs. | ||
184 | */ | ||
185 | int parse_edfwm_ts_file(FILE *ts, struct rt_task *rt) | ||
186 | { | ||
187 | int task_id, ret = 1; | ||
188 | unsigned int cpu, sliceno; | ||
189 | double fwcet, fperiod, fphase; | ||
190 | |||
191 | ret = fscanf(ts, "%d %lf %lf %lf %d %d\n", | ||
192 | &task_id, &fwcet, &fperiod, &fphase, &cpu, &sliceno); | ||
193 | |||
194 | if (ferror(ts)) | ||
195 | goto err; | ||
196 | |||
197 | rt->exec_cost = fms_to_ns(fwcet); | ||
198 | rt->period = fms_to_ns(fperiod); | ||
199 | rt->phase = fms_to_ns(fphase); | ||
200 | rt->cpu = cpu; | ||
201 | rt->cls = RT_CLASS_HARD; | ||
202 | rt->budget_policy = PRECISE_ENFORCEMENT; | ||
203 | |||
204 | printf("(tid, wcet, period, ph, cpu, slices) = " | ||
205 | "(%d, %llu, %llu, %llu, %u, %u)\n", | ||
206 | task_id, rt->exec_cost, rt->period, rt->phase, cpu, sliceno); | ||
207 | if (sliceno > 0) { | ||
208 | memset(&rt->semi_part, 0, sizeof(struct edf_wm_params)); | ||
209 | ret = parse_edfwm_slice(ts, sliceno, task_id, | ||
210 | (struct edf_wm_params*) &rt->semi_part); | ||
211 | if (ret < 0) | ||
212 | goto err; | ||
213 | } | ||
214 | |||
215 | return 0; | ||
216 | |||
217 | err: | ||
218 | fprintf(stderr, "Error parsing file\n"); | ||
219 | return -1; | ||
220 | } | ||
221 | |||
222 | #define OPTSTR "wld:v" | 136 | #define OPTSTR "wld:v" |
223 | 137 | ||
224 | int main(int argc, char** argv) | 138 | int main(int argc, char** argv) |
diff --git a/include/common.h b/include/common.h index d1234ba..dbcfd34 100644 --- a/include/common.h +++ b/include/common.h | |||
@@ -1,7 +1,11 @@ | |||
1 | #ifndef COMMON_H | 1 | #ifndef COMMON_H |
2 | #define COMMON_H | 2 | #define COMMON_H |
3 | 3 | ||
4 | #include "litmus.h" | ||
4 | 5 | ||
5 | void bail_out(const char* msg); | 6 | void bail_out(const char* msg); |
6 | 7 | ||
8 | /* EDF-WM helper functions to parse task parameters from file */ | ||
9 | int parse_edfwm_ts_file(FILE *ts, struct rt_task *rt); | ||
10 | |||
7 | #endif | 11 | #endif |