proc_mgmt: fixed several dependency issues
[barrelfish] / usr / tests / proc_mgmt_test / main.c
1 /** \file
2  *  \brief Process Management test.
3  */
4
5 /*
6  * Copyright (c) 2017, ETH Zurich.
7  * All rights reserved.
8  *
9  * This file is distributed under the terms in the attached LICENSE file.
10  * If you do not find this file, copies can be found by writing to:
11  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
12  */
13
14 #include <stdlib.h>
15
16 #include <barrelfish/barrelfish.h>
17 #include <barrelfish/deferred.h>
18 #include <barrelfish/sys_debug.h>
19 #include <barrelfish/proc_mgmt_client.h>
20 #include <barrelfish/spawn_client.h>
21 #include <bench/bench.h>
22
23 #define PROC_MGMT_BENCH 1
24 #define PROC_MGMT_BENCH_MIN_RUNS 20
25
26 static errval_t test_spawn(coreid_t core_id, char *argv[],
27                                struct capref *ret_domain_cap)
28 {
29         assert(ret_domain_cap != NULL);
30
31         errval_t err = proc_mgmt_spawn_program(core_id,
32                                                    "/x86_64/sbin/proc_mgmt_test",
33                                                    argv, NULL, 0, ret_domain_cap);
34         if (err_is_fail(err)) {
35         return err;
36         }
37     return SYS_ERR_OK;
38 }
39
40 /*
41 static void test_span(coreid_t core_id)
42 {
43         errval_t err = proc_mgmt_span(core_id);
44         if (err_is_fail(err)) {
45     }
46 }
47
48 static void test_kill(struct capref domain_cap)
49 {
50         errval_t err = proc_mgmt_kill(domain_cap);
51         if (err_is_ok(err)) {
52         USER_PANIC("Failed killing domain")
53     }
54 }
55
56 static void test_wait(struct capref domain_cap)
57 {
58         uint8_t code;
59         errval_t err = proc_mgmt_wait(domain_cap, &code);
60         if (err_is_fail(err)) {
61         USER_PANIC("Failed waiting for domain");
62         }
63 }
64 */
65
66 static inline cycles_t calculate_time(cycles_t tsc_start, cycles_t tsc_end)
67 {
68     cycles_t result;
69     if (tsc_end < tsc_start) {
70         result = (LONG_MAX - tsc_start) + tsc_end - bench_tscoverhead();
71     } else {
72         result = (tsc_end - tsc_start - bench_tscoverhead());
73     }
74     return result;
75 }
76
77 static void run_benchmark_spawn(coreid_t target_core)
78 {
79     bench_init();
80
81     cycles_t tsc_start, tsc_end;
82     cycles_t result;
83     uint64_t tscperus;
84
85     bench_ctl_t *ctl = calloc(1, sizeof(*ctl));
86     ctl->mode = BENCH_MODE_FIXEDRUNS;
87     ctl->result_dimensions = 1;
88     ctl->min_runs = PROC_MGMT_BENCH_MIN_RUNS;
89     ctl->data = calloc(ctl->min_runs * ctl->result_dimensions,
90                        sizeof(*ctl->data));
91
92     errval_t err = sys_debug_get_tsc_per_ms(&tscperus);
93     assert(err_is_ok(err));
94     tscperus /= 1000;
95
96     struct capref domain_cap;
97
98     char *spawn_argv[] = { "proc_mgmt_test", "0", "norun", NULL};
99     do {
100         tsc_start = bench_tsc();
101
102         test_spawn(target_core, spawn_argv, &domain_cap);
103
104         tsc_end = bench_tsc();
105         result = calculate_time(tsc_start, tsc_end);
106     } while (!bench_ctl_add_run(ctl, &result));    
107
108     cap_destroy(domain_cap);
109     bench_ctl_dump_analysis(ctl, 0, "client", tscperus);
110
111     bench_ctl_destroy(ctl);
112 }
113
114 int main(int argc, char **argv)
115 {   
116     errval_t err;
117         if (argc == 3) {
118         if (strcmp("starter", argv[2]) == 0) {
119             // just continue;
120         } else if (strcmp("norun", argv[2]) == 0) {
121             // directly return
122             return 0;
123         } else if (strcmp("run", argv[2]) == 0) {   
124             // Run infinite loop
125             printf("Running infinite Loop");
126             while(true) {
127                 printf("Running infinite Loop");
128                 barrelfish_usleep(1000*1000);
129                 event_dispatch_non_block(get_default_waitset());
130             }
131         } else if (strcmp("sleeper", argv[2]) == 0) {
132             // Process that we wait for to finish
133             printf("Running for a few seconds \n");
134             barrelfish_usleep(10*1000*1000);
135             printf("Sleeper exit\n");
136             return 0;
137         } else if (strcmp("span", argv[2]) == 0) {
138             // Process that spans domains
139             if (disp_get_core_id() == 0) {
140                 proc_mgmt_span(1);
141             } else {
142                 proc_mgmt_span(0);
143             }
144             while(true) {
145                 event_dispatch(get_default_waitset());
146             }
147         } else {
148             USER_PANIC("Unknown Role \n ");
149         }
150
151         } else {
152         USER_PANIC("Not enough arguments to run test \n ");
153     }
154
155     struct capref domain_cap;
156     printf("Testing kill on same core\n");
157     char *spawn_argv[] = { "proc_mgmt_test", "0", "run", NULL};
158     err = test_spawn(2, spawn_argv, &domain_cap);
159     if (err_is_fail(err)) {
160         USER_PANIC("Failed spawning program proc_mgmt_test \n");
161     }  
162
163     //starting a process takes some time ...
164     barrelfish_usleep(5*1000*1000);
165
166     printf("Killing process \n");
167         err = proc_mgmt_kill(domain_cap);
168         if (err_is_fail(err)) {
169         USER_PANIC("Failed waiting for domain \n");
170         }
171  
172     // Killing a process takes some time ...
173     barrelfish_usleep(5*1000*1000);
174
175     printf("Testing kill on other core\n");
176     err = test_spawn(1, spawn_argv, &domain_cap);
177     if (err_is_fail(err)) {
178         USER_PANIC("Failed spawning program proc_mgmt_test \n");
179     }  
180
181     barrelfish_usleep(5*1000*1000);
182
183     printf("Killing process \n");
184         err = proc_mgmt_kill(domain_cap);
185         if (err_is_fail(err)) {
186         USER_PANIC("Failed waiting for domain \n");
187         }
188
189     // TODO check if process was killed
190     printf("Testing spaning on different core\n");
191     char *spawn_argv3[] = { "proc_mgmt_test", "0", "span", NULL};
192     err = test_spawn(0, spawn_argv3, &domain_cap);
193     if (err_is_fail(err)) {
194         USER_PANIC("Failed spawning program proc_mgmt_test \n");
195     }
196
197     printf("Testing spaning on same core\n");
198     err = test_spawn(2, spawn_argv3, &domain_cap);
199     if (err_is_fail(err)) {
200         USER_PANIC("Failed spawning program proc_mgmt_test \n");
201     }  
202
203     printf("Testing wait on different core process\n");
204     char *spawn_argv2[] = { "proc_mgmt_test", "0", "sleeper"};
205     err = test_spawn(0, spawn_argv2, &domain_cap);
206     if (err_is_fail(err)) {
207         USER_PANIC("Failed spawning program proc_mgmt_test \n");
208     }  
209  
210     barrelfish_usleep(5*1000*1000);
211     
212         uint8_t code;
213     printf("Waiting for process on different core to finish \n");
214         err = proc_mgmt_wait(domain_cap, &code);
215         if (err_is_fail(err)) {
216         USER_PANIC("Failed waiting for domain \n");
217         }
218     printf("Unblocked \n");
219
220     printf("Testing wait on same core process\n");
221     err = test_spawn(2, spawn_argv2, &domain_cap);
222     if (err_is_fail(err)) {
223         USER_PANIC("Failed spawning program proc_mgmt_test \n");
224     }  
225  
226     barrelfish_usleep(5*1000*1000);
227     
228     printf("Waiting for process on same core to finish \n");
229         err = proc_mgmt_wait(domain_cap, &code);
230         if (err_is_fail(err)) {
231         USER_PANIC("Failed waiting for domain \n");
232         }
233     printf("Unblocked \n");
234
235     printf("Running benchmarks core 0 \n");
236     run_benchmark_spawn(0);
237     printf("Running benchmarks core 3 \n");
238     run_benchmark_spawn(3);
239
240     printf("TEST DONE\n");
241     return 0;
242 }