From 10d965917256f157f2ff515227d2c3d9ea1c4d08 Mon Sep 17 00:00:00 2001 From: hwwang Date: Sun, 27 Oct 2024 18:46:07 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E6=9C=BA=E5=99=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E8=B0=83=E5=BA=A6=E6=A1=86=E6=9E=B6=EF=BC=8C=E8=80=83?= =?UTF-8?q?=E8=99=91=E5=A6=82=E4=BD=95=E8=AE=AD=E7=BB=83=E6=95=B0=E6=8D=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- runtime/include/sandbox_functions.h | 8 +++ runtime/include/scheduler.h | 53 ++++++++++++++++++- .../src/global_request_scheduler_minheap.c | 10 ++++ runtime/src/local_runqueue_minheap.c | 5 ++ runtime/src/main.c | 4 +- runtime/src/software_interrupt.c | 12 +++-- runtime/tests/Makefile | 2 +- runtime/tests/start.sh | 4 +- 8 files changed, 90 insertions(+), 8 deletions(-) diff --git a/runtime/include/sandbox_functions.h b/runtime/include/sandbox_functions.h index bb2a8d9..829725a 100644 --- a/runtime/include/sandbox_functions.h +++ b/runtime/include/sandbox_functions.h @@ -115,6 +115,14 @@ sandbox_get_srsf_priority(void *element) return remaining_slack; }; +static inline uint64_t +sandbox_get_mdl_priority(void *element) +{ + struct sandbox *sandbox = (struct sandbox *)element; + //uint64_t now = __getcycles(); + return sandbox->absolute_deadline; +}; + /** * Maps a sandbox fd to an underlying host fd * Returns error condition if the file_descriptor to set does not contain sandbox preopen magic diff --git a/runtime/include/scheduler.h b/runtime/include/scheduler.h index fbc9e4b..4c468ff 100644 --- a/runtime/include/scheduler.h +++ b/runtime/include/scheduler.h @@ -28,7 +28,8 @@ enum SCHEDULER { SCHEDULER_FIFO = 0, SCHEDULER_EDF = 1, - SCHEDULER_SRSF = 2 + SCHEDULER_SRSF = 2, + SCHEDULER_MDL = 3 }; extern enum SCHEDULER scheduler; @@ -112,6 +113,47 @@ err_allocate: request = NULL; goto done; } + +static inline struct sandbox * +scheduler_MDL_get_next() +{ + /* Get the deadline of the sandbox at the head of the local request queue */ + struct sandbox * local = local_runqueue_get_next(); + uint64_t local_remaining_MDL = local == NULL ? UINT64_MAX : local->absolute_deadline; + struct sandbox_request *request = NULL; + + uint64_t global_remaining_slack = global_request_scheduler_peek(); + + /* Try to pull and allocate from the global queue if earlier + * This will be placed at the head of the local runqueue */ + if (global_remaining_slack < local_remaining_MDL && (local_workload_count <=2 || local_runqueue_count == 0)) { + //if (global_remaining_slack < local_remaining_slack) { + if (global_request_scheduler_remove_if_earlier(&request, local_remaining_MDL) == 0) { + + //uint64_t pop_time = __getcycles() - system_start_timestamp; + //mem_log("time %lu remove from GQ, request id:%d name %s remaining slack %lu\n", pop_time, + // request->id, request->module->name, request->remaining_slack); + + assert(request != NULL); + struct sandbox *global = sandbox_allocate(request); + if (!global) goto err_allocate; + + assert(global->state == SANDBOX_INITIALIZED); + sandbox_set_as_runnable(global, SANDBOX_INITIALIZED); + } + } + +/* Return what is at the head of the local runqueue or NULL if empty */ +done: + return local_runqueue_get_next(); +err_allocate: + client_socket_send(request->socket_descriptor, 503); + client_socket_close(request->socket_descriptor, &request->socket_address); + free(request); + request = NULL; + goto done; +} + static inline struct sandbox * scheduler_fifo_get_next() { @@ -156,6 +198,8 @@ scheduler_get_next() return scheduler_srsf_get_next(); case SCHEDULER_FIFO: return scheduler_fifo_get_next(); + case SCHEDULER_MDL: + return scheduler_MDL_get_next(); default: panic("Unimplemented\n"); } @@ -171,6 +215,9 @@ scheduler_initialize() case SCHEDULER_SRSF: global_request_scheduler_minheap_initialize(SCHEDULER_SRSF); break; + case SCHEDULER_MDL: + global_request_scheduler_minheap_initialize(SCHEDULER_MDL); + break; case SCHEDULER_FIFO: global_request_scheduler_deque_initialize(); break; @@ -189,6 +236,8 @@ scheduler_runqueue_initialize() case SCHEDULER_SRSF: local_runqueue_minheap_initialize(SCHEDULER_SRSF); break; + case SCHEDULER_MDL: + local_runqueue_minheap_initialize(SCHEDULER_MDL); case SCHEDULER_FIFO: local_runqueue_list_initialize(); break; @@ -291,6 +340,8 @@ scheduler_print(enum SCHEDULER variant) return "FIFO"; case SCHEDULER_EDF: return "EDF"; + case SCHEDULER_MDL: + return "MDL"; case SCHEDULER_SRSF: return "SRSF"; } diff --git a/runtime/src/global_request_scheduler_minheap.c b/runtime/src/global_request_scheduler_minheap.c index 7dcbac3..51cbda2 100644 --- a/runtime/src/global_request_scheduler_minheap.c +++ b/runtime/src/global_request_scheduler_minheap.c @@ -80,6 +80,14 @@ sandbox_request_get_priority_srsf_fn(void *element) return remaining_slack; }; +uint64_t +sandbox_request_get_priority_mdl_fn(void *element) +{ + struct sandbox_request *sandbox_request = (struct sandbox_request *)element; + //uint64_t now = __getcycles(); + return sandbox_request->absolute_deadline; +}; + /** * Initializes the variant and registers against the polymorphic interface */ @@ -90,6 +98,8 @@ global_request_scheduler_minheap_initialize(enum SCHEDULER scheduler) global_request_scheduler_minheap = priority_queue_initialize(40960, true, sandbox_request_get_priority_fn); } else if (scheduler == SCHEDULER_SRSF) { global_request_scheduler_minheap = priority_queue_initialize(40960, true, sandbox_request_get_priority_srsf_fn); + } else if (scheduler == SCHEDULER_MDL) { + global_request_scheduler_minheap = priority_queue_initialize(40960, true, sandbox_request_get_priority_mdl_fn); } struct global_request_scheduler_config config = { diff --git a/runtime/src/local_runqueue_minheap.c b/runtime/src/local_runqueue_minheap.c index ac6579a..583d6d6 100644 --- a/runtime/src/local_runqueue_minheap.c +++ b/runtime/src/local_runqueue_minheap.c @@ -82,6 +82,11 @@ local_runqueue_minheap_initialize(enum SCHEDULER scheduler) local_runqueue_minheap = priority_queue_initialize(10240, false, sandbox_get_priority); } else if (scheduler == SCHEDULER_SRSF) { local_runqueue_minheap = priority_queue_initialize(10240, false, sandbox_get_srsf_priority); + } else if (scheduler == SCHEDULER_MDL) { + local_runqueue_minheap = priority_queue_initialize(10240, false, sandbox_get_mdl_priority); + } else { + panic("Invalid scheduler type %d\n", scheduler); + } /* Register Function Pointers for Abstract Scheduling API */ diff --git a/runtime/src/main.c b/runtime/src/main.c index 7645a9f..bd443b2 100644 --- a/runtime/src/main.c +++ b/runtime/src/main.c @@ -186,6 +186,8 @@ runtime_configure() scheduler = SCHEDULER_FIFO; } else if (strcmp(scheduler_policy, "SRSF") == 0) { scheduler = SCHEDULER_SRSF; + } else if (strcmp(scheduler_policy, "MDL") == 0) { + scheduler = SCHEDULER_MDL; } else { panic("Invalid scheduler policy: %s. Must be {EDF|FIFO}\n", scheduler_policy); } @@ -197,7 +199,7 @@ runtime_configure() if (strcmp(sigalrm_policy, "BROADCAST") == 0) { runtime_sigalrm_handler = RUNTIME_SIGALRM_HANDLER_BROADCAST; } else if (strcmp(sigalrm_policy, "TRIAGED") == 0) { - if (unlikely(scheduler != SCHEDULER_EDF && scheduler != SCHEDULER_SRSF)) panic("triaged sigalrm handlers are only valid with EDF and SRSF\n"); + if (unlikely(scheduler != SCHEDULER_EDF && scheduler != SCHEDULER_SRSF && scheduler != SCHEDULER_MDL)) panic("triaged sigalrm handlers are only valid with EDF and SRSF\n"); runtime_sigalrm_handler = RUNTIME_SIGALRM_HANDLER_TRIAGED; } else { panic("Invalid sigalrm policy: %s. Must be {BROADCAST|TRIAGED}\n", sigalrm_policy); diff --git a/runtime/src/software_interrupt.c b/runtime/src/software_interrupt.c index f3c7243..b0894e2 100644 --- a/runtime/src/software_interrupt.c +++ b/runtime/src/software_interrupt.c @@ -94,6 +94,11 @@ sigalrm_propagate_workers(siginfo_t *signal_info) uint64_t global_slack = global_request_scheduler_peek(); if (global_slack < local_remaining_slack) pthread_kill(runtime_worker_threads[i], SIGALRM); continue; + } else if (scheduler == SCHEDULER_MDL) { + uint64_t local_deadline = runtime_worker_threads_deadline[i]; + uint64_t global_deadline = global_request_scheduler_peek(); + if (global_deadline < local_deadline) pthread_kill(runtime_worker_threads[i], SIGALRM); + continue; } } case RUNTIME_SIGALRM_HANDLER_BROADCAST: { @@ -253,12 +258,13 @@ done: void software_interrupt_arm_timer(void) { - if (!runtime_preemption_enabled) return; - - /* if preemption disabled, broadcast sig alarm to all other threads to record the queuelength info */ + /* if preemption disabled, broadcast sig alarm to all other threads to record the queuelength info */ if (!runtime_preemption_enabled) { runtime_sigalrm_handler = RUNTIME_SIGALRM_HANDLER_BROADCAST; } + + if (!runtime_preemption_enabled) return; + struct itimerval interval_timer; memset(&interval_timer, 0, sizeof(struct itimerval)); diff --git a/runtime/tests/Makefile b/runtime/tests/Makefile index 6090a18..4d15231 100644 --- a/runtime/tests/Makefile +++ b/runtime/tests/Makefile @@ -43,7 +43,7 @@ sod: @make dir samples.so -C ./sod/ @cp ./sod/bin/license_plate_detection.so ${SLEDGE_BIN_DIR}/lpd_wasm.so @cp ./sod/bin/resize_image.so ${SLEDGE_BIN_DIR}/resize_wasm.so - @cp ./sod/bin/reverse.so ${SLEDGE_BIN_DIR}/reverse_wasm.so +# @cp ./sod/bin/reverse.so ${SLEDGE_BIN_DIR}/reverse_wasm.so C-Image-Manip: @echo "Making and Installing pngPlay" diff --git a/runtime/tests/start.sh b/runtime/tests/start.sh index ace06a3..c19224c 100755 --- a/runtime/tests/start.sh +++ b/runtime/tests/start.sh @@ -21,8 +21,8 @@ echo $project_path path=`pwd` #export SLEDGE_DISABLE_PREEMPTION=true export SLEDGE_CPU_SPEED=2400 -export SLEDGE_SCHEDULER=SRSF -export SLEDGE_SIGALRM_HANDLER=BROADCAST +export SLEDGE_SCHEDULER=MDL +export SLEDGE_SIGALRM_HANDLER=TRIAGED #export SLEDGE_SIGALRM_HANDLER=TRIAGED #export SLEDGE_NWORKERS=1 #export SLEDGE_SCHEDULER=EDF