添加机器学习调度框架，考虑如何训练数据

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

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";
 	}

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 = {

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 */

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);

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));

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"

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_SCHEDULER=MDL
-export SLEDGE_SIGALRM_HANDLER=BROADCAST
+export SLEDGE_SIGALRM_HANDLER=TRIAGED
 #export SLEDGE_SIGALRM_HANDLER=TRIAGED
 #export SLEDGE_NWORKERS=1
 #export SLEDGE_SCHEDULER=EDF