git.barrelfish.org Git - barrelfish/blob - 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/proc_mgmt_client.h>
  19 #include <barrelfish/spawn_client.h>
  20 #include <bench/bench.h>
  21
  22 #define PROC_MGMT_BENCH 1
  23 #define PROC_MGMT_BENCH_MIN_RUNS 20
  24 // int total_ids;
  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 static inline cycles_t calculate_time(cycles_t tsc_start, cycles_t tsc_end)
  66 {
  67     cycles_t result;
  68     if (tsc_end < tsc_start) {
  69         result = (LONG_MAX - tsc_start) + tsc_end - bench_tscoverhead();
  70     } else {
  71         result = (tsc_end - tsc_start - bench_tscoverhead());
  72     }
  73     return result;
  74 }
  75
  76 static void run_benchmark_spawn(coreid_t target_core)
  77 {
  78     bench_init();
  79
  80     cycles_t tsc_start, tsc_end;
  81     cycles_t result;
  82     uint64_t tscperus;
  83
  84     bench_ctl_t *ctl = calloc(1, sizeof(*ctl));
  85     ctl->mode = BENCH_MODE_FIXEDRUNS;
  86     ctl->result_dimensions = 1;
  87     ctl->min_runs = PROC_MGMT_BENCH_MIN_RUNS;
  88     ctl->data = calloc(ctl->min_runs * ctl->result_dimensions,
  89                        sizeof(*ctl->data));
  90
  91     errval_t err = sys_debug_get_tsc_per_ms(&tscperus);
  92     assert(err_is_ok(err));
  93     tscperus /= 1000;
  94
  95     struct capref domain_cap;
  96
  97     char *spawn_argv[] = { "proc_mgmt_test", "0", "norun", NULL};
  98     do {
  99         tsc_start = bench_tsc();
 100
 101         test_spawn(target_core, spawn_argv, &domain_cap);
 102
 103         tsc_end = bench_tsc();
 104         result = calculate_time(tsc_start, tsc_end);
 105     } while (!bench_ctl_add_run(ctl, &result));
 106
 107     cap_destroy(domain_cap);
 108     bench_ctl_dump_analysis(ctl, 0, "client", tscperus);
 109
 110     bench_ctl_destroy(ctl);
 111 }
 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     /*
 236     printf("Running benchmarks core 0 \n");
 237     run_benchmark_spawn(0);
 238     printf("Running benchmarks core 3 \n");
 239     run_benchmark_spawn(3);
 240     */
 241     printf("TEST DONE\n");
 242     return 0;
 243 }