From 1d724f04e8c17e6b0b1bce6157237812765451fa Mon Sep 17 00:00:00 2001 From: Sean McBride Date: Sun, 8 Mar 2020 16:27:14 -0400 Subject: [PATCH] refactor: Shift sandbox_request to new file --- runtime/include/sandbox.h | 99 --------------------------- runtime/include/sandbox_request.h | 108 ++++++++++++++++++++++++++++++ runtime/src/runtime.c | 2 + 3 files changed, 110 insertions(+), 99 deletions(-) create mode 100644 runtime/include/sandbox_request.h diff --git a/runtime/include/sandbox.h b/runtime/include/sandbox.h index 363563a..043b365 100644 --- a/runtime/include/sandbox.h +++ b/runtime/include/sandbox.h @@ -77,19 +77,6 @@ struct sandbox { char request_response_data[1]; // of rr_data_sz, following sandbox mem.. } PAGE_ALIGNED; -struct sandbox_request { - struct module * module; - char * arguments; - int socket_descriptor; - struct sockaddr *socket_address; - u64 start_time; // cycles -}; -typedef struct sandbox_request sandbox_request_t; - -DEQUE_PROTOTYPE(sandbox, sandbox_request_t *); - -static inline int add_sandbox_request_to_global_dequeue(sandbox_request_t *sandbox_request); - // a runtime resource, malloc on this! struct sandbox *allocate_sandbox(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, u64 start_time); // should free stack and heap resources.. also any I/O handles. @@ -101,30 +88,6 @@ extern __thread arch_context_t *next_context; typedef struct sandbox sandbox_t; -/** - * Allocates a new Sandbox Request and places it on the Global Deque - * @param module the module we want to request - * @param arguments the arguments that we'll pass to the serverless function - * @param socket_descriptor - * @param socket_address - * @param start_time the timestamp of when we receives the request from the network (in cycles) - * @return the new sandbox request - **/ -static inline sandbox_request_t * -allocate_sandbox_request(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, u64 start_time) -{ - sandbox_request_t *sandbox_request = malloc(sizeof(sandbox_request_t)); - assert(sandbox_request); - sandbox_request->module = module; - sandbox_request->arguments = arguments; - sandbox_request->socket_descriptor = socket_descriptor; - sandbox_request->socket_address = (struct sockaddr *)socket_address; - sandbox_request->start_time = start_time; - - debuglog("[%p: %s]\n", sandbox_request, sandbox_request->module->name); - add_sandbox_request_to_global_dequeue(sandbox_request); - return sandbox_request; -} /** * Getter for the current sandbox executing on this thread @@ -224,68 +187,6 @@ void sandbox_response(void); // should have been called with stack allocated and get_current_sandbox() set! void sandbox_main(void); void exit_current_sandbox(void); -extern struct deque_sandbox *global_deque; -extern pthread_mutex_t global_deque_mutex; - - -/** - * Pushes a sandbox request to the global deque - * @param sandbox_request - **/ -static inline int -add_sandbox_request_to_global_dequeue(sandbox_request_t *sandbox_request) -{ - int return_code; - -#if NCORES == 1 - pthread_mutex_lock(&global_deque_mutex); -#endif - return_code = deque_push_sandbox(global_deque, &sandbox_request); -#if NCORES == 1 - pthread_mutex_unlock(&global_deque_mutex); -#endif - - return return_code; -} - -/** - * Pops a sandbox request from the global deque - * @param sandbox_request the pointer which we want to set to the sandbox request - **/ -static inline int -pop_sandbox_request_from_global_dequeue(sandbox_request_t **sandbox_request) -{ - int return_code; - -#if NCORES == 1 - pthread_mutex_lock(&global_deque_mutex); -#endif - return_code = deque_pop_sandbox(global_deque, sandbox_request); -#if NCORES == 1 - pthread_mutex_unlock(&global_deque_mutex); -#endif - return return_code; -} - -/** - * TODO: What does this do? - * @returns A Sandbox Request or NULL - **/ -static inline sandbox_request_t * -steal_sandbox_request_from_global_dequeue(void) -{ - sandbox_request_t *sandbox_request = NULL; - -#if NCORES == 1 - pop_sandbox_request_from_global_dequeue(&sandbox_request); -#else - // TODO: check! is there a sandboxing thread on same core as udp-server thread? - int r = deque_steal_sandbox(global_deque, &sandbox_request); - if (r) sandbox_request = NULL; -#endif - - return sandbox_request; -} /** * Initializes and returns an IO handle on the current sandbox ready for use diff --git a/runtime/include/sandbox_request.h b/runtime/include/sandbox_request.h new file mode 100644 index 0000000..100b6e3 --- /dev/null +++ b/runtime/include/sandbox_request.h @@ -0,0 +1,108 @@ +#ifndef SFRT_SANDBOX_REQUEST_H +#define SFRT_SANDBOX_REQUEST_H + +#include "types.h" +#include "deque.h" + +extern struct deque_sandbox *global_deque; +extern pthread_mutex_t global_deque_mutex; + +struct sandbox_request { + struct module * module; + char * arguments; + int socket_descriptor; + struct sockaddr *socket_address; + u64 start_time; // cycles +}; +typedef struct sandbox_request sandbox_request_t; + +DEQUE_PROTOTYPE(sandbox, sandbox_request_t *); + +static inline int add_sandbox_request_to_global_dequeue(sandbox_request_t *sandbox_request); + +/** + * Allocates a new Sandbox Request and places it on the Global Deque + * @param module the module we want to request + * @param arguments the arguments that we'll pass to the serverless function + * @param socket_descriptor + * @param socket_address + * @param start_time the timestamp of when we receives the request from the network (in cycles) + * @return the new sandbox request + **/ +static inline sandbox_request_t * +allocate_sandbox_request(struct module *module, char *arguments, int socket_descriptor, const struct sockaddr *socket_address, u64 start_time) +{ + sandbox_request_t *sandbox_request = (sandbox_request_t *)malloc(sizeof(sandbox_request_t)); + assert(sandbox_request); + sandbox_request->module = module; + sandbox_request->arguments = arguments; + sandbox_request->socket_descriptor = socket_descriptor; + sandbox_request->socket_address = (struct sockaddr *)socket_address; + sandbox_request->start_time = start_time; + + debuglog("[%p: %s]\n", sandbox_request, sandbox_request->module->name); + add_sandbox_request_to_global_dequeue(sandbox_request); + return sandbox_request; +} + +/** + * Pushes a sandbox request to the global deque + * @param sandbox_request + **/ +static inline int +add_sandbox_request_to_global_dequeue(sandbox_request_t *sandbox_request) +{ + int return_code; + +#if NCORES == 1 + pthread_mutex_lock(&global_deque_mutex); +#endif + return_code = deque_push_sandbox(global_deque, &sandbox_request); +#if NCORES == 1 + pthread_mutex_unlock(&global_deque_mutex); +#endif + + return return_code; +} + +/** + * Pops a sandbox request from the global deque + * @param sandbox_request the pointer which we want to set to the sandbox request + **/ +static inline int +pop_sandbox_request_from_global_dequeue(sandbox_request_t **sandbox_request) +{ + int return_code; + +#if NCORES == 1 + pthread_mutex_lock(&global_deque_mutex); +#endif + return_code = deque_pop_sandbox(global_deque, sandbox_request); +#if NCORES == 1 + pthread_mutex_unlock(&global_deque_mutex); +#endif + return return_code; +} + + +/** + * TODO: What does this do? + * @returns A Sandbox Request or NULL + **/ +static inline sandbox_request_t * +steal_sandbox_request_from_global_dequeue(void) +{ + sandbox_request_t *sandbox_request = NULL; + +#if NCORES == 1 + pop_sandbox_request_from_global_dequeue(&sandbox_request); +#else + // TODO: check! is there a sandboxing thread on same core as udp-server thread? + int r = deque_steal_sandbox(global_deque, &sandbox_request); + if (r) sandbox_request = NULL; +#endif + + return sandbox_request; +} + +#endif /* SFRT_SANDBOX_REQUEST_H */ \ No newline at end of file diff --git a/runtime/src/runtime.c b/runtime/src/runtime.c index 0fbcbf2..f7b301e 100644 --- a/runtime/src/runtime.c +++ b/runtime/src/runtime.c @@ -11,6 +11,8 @@ #include #include +#include "sandbox_request.h" + /*************************** * Shared Process State * **************************/