nijinlong1
/
sledge-serverles-framwork
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: de-dunder runtime

Browse Source
master
Sean McBride 5 years ago
parent 4d660e666b
commit ba032a5905
9 changed files with 73 additions and 73 deletions
Show Stats Download Patch File Download Diff File

2
runtime/include/current_sandbox.h
Unescape View File

@ -4,7 +4,7 @@
#include "sandbox.h" #include "sandbox.h"
#include "types.h" #include "types.h"
extern http_parser_settings runtime__http_parser_settings; extern http_parser_settings runtime_http_parser_settings;
/** /**
* Getter for the current sandbox executing on this thread * Getter for the current sandbox executing on this thread

8
runtime/include/runtime.h
Unescape View File

@ -8,9 +8,9 @@
#include "sandbox.h" #include "sandbox.h"
#include "types.h" #include "types.h"
extern int runtime__epoll_file_descriptor; extern int runtime_epoll_file_descriptor;
extern struct deque_sandbox *runtime__global_deque; extern struct deque_sandbox *runtime_global_deque;
extern pthread_mutex_t runtime__global_deque_mutex; extern pthread_mutex_t runtime_global_deque_mutex;
extern __thread uv_loop_t worker_thread__uvio_handle; extern __thread uv_loop_t worker_thread__uvio_handle;
void alloc_linear_memory(void); void alloc_linear_memory(void);
@ -18,7 +18,7 @@ void expand_memory(void);
void free_linear_memory(void *base, u32 bound, u32 max); void free_linear_memory(void *base, u32 bound, u32 max);
INLINE char *get_function_from_table(u32 idx, u32 type_id); INLINE char *get_function_from_table(u32 idx, u32 type_id);
INLINE char *get_memory_ptr_for_runtime(u32 offset, u32 bounds_check); INLINE char *get_memory_ptr_for_runtime(u32 offset, u32 bounds_check);
void runtime__initialize(void); void runtime_initialize(void);
void listener_thread_initialize(void); void listener_thread_initialize(void);
void stub_init(i32 offset); void stub_init(i32 offset);
void * worker_thread__main(void *return_code); void * worker_thread__main(void *return_code);

14
runtime/include/sandbox_request.h
Unescape View File

@ -28,11 +28,11 @@ sandbox_request__push_to_dequeue(sandbox_request_t *sandbox_request)
// TODO: Running the runtime and listener cores on a single shared core is untested // TODO: Running the runtime and listener cores on a single shared core is untested
// We are unsure if the locking behavior is correct, so there may be deadlocks // We are unsure if the locking behavior is correct, so there may be deadlocks
#if NCORES == 1 #if NCORES == 1
pthread_mutex_lock(&runtime__global_deque_mutex); pthread_mutex_lock(&runtime_global_deque_mutex);
#endif #endif
return_code = deque_push_sandbox(runtime__global_deque, &sandbox_request); return_code = deque_push_sandbox(runtime_global_deque, &sandbox_request);
#if NCORES == 1 #if NCORES == 1
pthread_mutex_unlock(&runtime__global_deque_mutex); pthread_mutex_unlock(&runtime_global_deque_mutex);
#endif #endif
return return_code; return return_code;
@ -76,11 +76,11 @@ sandbox_request__pop_from_dequeue(sandbox_request_t **sandbox_request)
// TODO: Running the runtime and listener cores on a single shared core is untested // TODO: Running the runtime and listener cores on a single shared core is untested
// We are unsure if the locking behavior is correct, so there may be deadlocks // We are unsure if the locking behavior is correct, so there may be deadlocks
#if NCORES == 1 #if NCORES == 1
pthread_mutex_lock(&runtime__global_deque_mutex); pthread_mutex_lock(&runtime_global_deque_mutex);
#endif #endif
return_code = deque_pop_sandbox(runtime__global_deque, sandbox_request); return_code = deque_pop_sandbox(runtime_global_deque, sandbox_request);
#if NCORES == 1 #if NCORES == 1
pthread_mutex_unlock(&runtime__global_deque_mutex); pthread_mutex_unlock(&runtime_global_deque_mutex);
#endif #endif
return return_code; return return_code;
} }
@ -107,7 +107,7 @@ sandbox_request__steal_from_dequeue(void)
#if NCORES == 1 #if NCORES == 1
sandbox_request__pop_from_dequeue(&sandbox_request); sandbox_request__pop_from_dequeue(&sandbox_request);
#else #else
int r = deque_steal_sandbox(runtime__global_deque, &sandbox_request); int r = deque_steal_sandbox(runtime_global_deque, &sandbox_request);
if (r) sandbox_request = NULL; if (r) sandbox_request = NULL;
#endif #endif

8
runtime/include/types.h
Unescape View File

@ -81,7 +81,7 @@ extern __thread struct indirect_table_entry *module_indirect_table;
// for sandbox linear memory isolation // for sandbox linear memory isolation
extern __thread void *sandbox_lmbase; extern __thread void *sandbox_lmbase;
extern __thread u32 sandbox_lmbound; extern __thread u32 sandbox_lmbound;
extern i32 runtime__log_file_descriptor; // TODO: LOG_TO_FILE logic is untested extern i32 runtime_log_file_descriptor; // TODO: LOG_TO_FILE logic is untested
// functions in the module to lookup and call per sandbox. // functions in the module to lookup and call per sandbox.
typedef i32 (*mod_main_fn_t)(i32 a, i32 b); typedef i32 (*mod_main_fn_t)(i32 a, i32 b);
@ -102,13 +102,13 @@ typedef enum
/** /**
* debuglog is a macro that behaves based on the macros DEBUG and LOG_TO_FILE * debuglog is a macro that behaves based on the macros DEBUG and LOG_TO_FILE
* If DEBUG is not set, debuglog does nothing * If DEBUG is not set, debuglog does nothing
* If DEBUG is set and LOG_TO_FILE is set, debuglog prints to the logfile defined in runtime__log_file_descriptor * If DEBUG is set and LOG_TO_FILE is set, debuglog prints to the logfile defined in runtime_log_file_descriptor
* If DEBUG is set adn LOG_TO_FILE is not set, debuglog prints to STDOUT * If DEBUG is set adn LOG_TO_FILE is not set, debuglog prints to STDOUT
**/ **/
#ifdef DEBUG #ifdef DEBUG
#ifdef LOG_TO_FILE #ifdef LOG_TO_FILE
#define debuglog(fmt, ...) \ #define debuglog(fmt, ...) \
dprintf(runtime__log_file_descriptor, "(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, \ dprintf(runtime_log_file_descriptor, "(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, \
##__VA_ARGS__) ##__VA_ARGS__)
#else // !LOG_TO_FILE #else // !LOG_TO_FILE
#define debuglog(fmt, ...) printf("(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, ##__VA_ARGS__) #define debuglog(fmt, ...) printf("(%d,%lu) %s: " fmt, sched_getcpu(), pthread_self(), __func__, ##__VA_ARGS__)

76
runtime/src/main.c
Unescape View File

@ -15,14 +15,14 @@
// Conditionally used by debuglog when DEBUG is set // Conditionally used by debuglog when DEBUG is set
#ifdef DEBUG #ifdef DEBUG
i32 runtime__log_file_descriptor = -1; i32 runtime_log_file_descriptor = -1;
#endif #endif
u32 runtime__total_online_processors = 0; u32 runtime_total_online_processors = 0;
u32 runtime__total_worker_processors = 0; u32 runtime_total_worker_processors = 0;
u32 runtime__first_worker_processor = 0; u32 runtime_first_worker_processor = 0;
int runtime__worker_threads_argument[WORKER_THREAD__CORE_COUNT] = { 0 }; // The worker sets its argument to -1 on error int runtime_worker_threads_argument[WORKER_THREAD__CORE_COUNT] = { 0 }; // The worker sets its argument to -1 on error
pthread_t runtime__worker_threads[WORKER_THREAD__CORE_COUNT]; pthread_t runtime_worker_threads[WORKER_THREAD__CORE_COUNT];
/** /**
@ -30,7 +30,7 @@ pthread_t runtime__worker_threads[WORKER_THREAD__CORE_COUNT];
* @param cmd - The command the user entered * @param cmd - The command the user entered
**/ **/
static void static void
runtime__usage(char *cmd) runtime_usage(char *cmd)
{ {
printf("%s <modules_file>\n", cmd); printf("%s <modules_file>\n", cmd);
debuglog("%s <modules_file>\n", cmd); debuglog("%s <modules_file>\n", cmd);
@ -41,7 +41,7 @@ runtime__usage(char *cmd)
* (RLIMIT_NOFILE) soft limit to its hard limit (see man getrlimit) * (RLIMIT_NOFILE) soft limit to its hard limit (see man getrlimit)
**/ **/
void void
runtime__set_resource_limits_to_max() runtime_set_resource_limits_to_max()
{ {
struct rlimit resource_limit; struct rlimit resource_limit;
if (getrlimit(RLIMIT_DATA, &resource_limit) < 0) { if (getrlimit(RLIMIT_DATA, &resource_limit) < 0) {
@ -68,27 +68,27 @@ runtime__set_resource_limits_to_max()
* Check the number of cores and the compiler flags and allocate available cores * Check the number of cores and the compiler flags and allocate available cores
**/ **/
void void
runtime__allocate_available_cores() runtime_allocate_available_cores()
{ {
// Find the number of processors currently online // Find the number of processors currently online
runtime__total_online_processors = sysconf(_SC_NPROCESSORS_ONLN); runtime_total_online_processors = sysconf(_SC_NPROCESSORS_ONLN);
// If multicore, we'll pin one core as a listener and run sandbox threads on all others // If multicore, we'll pin one core as a listener and run sandbox threads on all others
if (runtime__total_online_processors > 1) { if (runtime_total_online_processors > 1) {
runtime__first_worker_processor = 1; runtime_first_worker_processor = 1;
// WORKER_THREAD__CORE_COUNT can be used as a cap on the number of cores to use // WORKER_THREAD__CORE_COUNT can be used as a cap on the number of cores to use
// But if there are few cores that WORKER_THREAD__CORE_COUNT, just use what is available // But if there are few cores that WORKER_THREAD__CORE_COUNT, just use what is available
u32 max_possible_workers = runtime__total_online_processors - 1; u32 max_possible_workers = runtime_total_online_processors - 1;
runtime__total_worker_processors = (max_possible_workers >= WORKER_THREAD__CORE_COUNT) runtime_total_worker_processors = (max_possible_workers >= WORKER_THREAD__CORE_COUNT)
? WORKER_THREAD__CORE_COUNT ? WORKER_THREAD__CORE_COUNT
: max_possible_workers; : max_possible_workers;
} else { } else {
// If single core, we'll do everything on CPUID 0 // If single core, we'll do everything on CPUID 0
runtime__first_worker_processor = 0; runtime_first_worker_processor = 0;
runtime__total_worker_processors = 1; runtime_total_worker_processors = 1;
} }
debuglog("Number of cores %u, sandboxing cores %u (start: %u) and module reqs %u\n", debuglog("Number of cores %u, sandboxing cores %u (start: %u) and module reqs %u\n",
runtime__total_online_processors, runtime__total_worker_processors, runtime__first_worker_processor, runtime_total_online_processors, runtime_total_worker_processors, runtime_first_worker_processor,
LISTENER_THREAD__CORE_ID); LISTENER_THREAD__CORE_ID);
} }
@ -99,19 +99,19 @@ runtime__allocate_available_cores()
* Otherwise, it writes to STDOUT * Otherwise, it writes to STDOUT
**/ **/
void void
runtime__process_debug_log_behavior() runtime_process_debug_log_behavior()
{ {
#ifdef LOG_TO_FILE #ifdef LOG_TO_FILE
fclose(stdout); fclose(stdout);
fclose(stderr); fclose(stderr);
fclose(stdin); fclose(stdin);
runtime__log_file_descriptor = open(RUNTIME__LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, S_IRWXU | S_IRWXG); runtime_log_file_descriptor = open(RUNTIME__LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, S_IRWXU | S_IRWXG);
if (runtime__log_file_descriptor < 0) { if (runtime_log_file_descriptor < 0) {
perror("open"); perror("open");
exit(-1); exit(-1);
} }
#else #else
runtime__log_file_descriptor = 1; runtime_log_file_descriptor = 1;
#endif // LOG_TO_FILE #endif // LOG_TO_FILE
} }
#endif // DEBUG #endif // DEBUG
@ -120,11 +120,11 @@ runtime__process_debug_log_behavior()
* Starts all worker threads and sleeps forever on pthread_join, which should never return * Starts all worker threads and sleeps forever on pthread_join, which should never return
**/ **/
void void
runtime__start_runtime__worker_threads() runtime_start_runtime_worker_threads()
{ {
for (int i = 0; i < runtime__total_worker_processors; i++) { for (int i = 0; i < runtime_total_worker_processors; i++) {
int ret = pthread_create(&runtime__worker_threads[i], NULL, worker_thread__main, int ret = pthread_create(&runtime_worker_threads[i], NULL, worker_thread__main,
(void *)&runtime__worker_threads_argument[i]); (void *)&runtime_worker_threads_argument[i]);
if (ret) { if (ret) {
errno = ret; errno = ret;
perror("pthread_create"); perror("pthread_create");
@ -133,14 +133,14 @@ runtime__start_runtime__worker_threads()
cpu_set_t cs; cpu_set_t cs;
CPU_ZERO(&cs); CPU_ZERO(&cs);
CPU_SET(runtime__first_worker_processor + i, &cs); CPU_SET(runtime_first_worker_processor + i, &cs);
ret = pthread_setaffinity_np(runtime__worker_threads[i], sizeof(cs), &cs); ret = pthread_setaffinity_np(runtime_worker_threads[i], sizeof(cs), &cs);
assert(ret == 0); assert(ret == 0);
} }
debuglog("Sandboxing environment ready!\n"); debuglog("Sandboxing environment ready!\n");
for (int i = 0; i < runtime__total_worker_processors; i++) { for (int i = 0; i < runtime_total_worker_processors; i++) {
int ret = pthread_join(runtime__worker_threads[i], NULL); int ret = pthread_join(runtime_worker_threads[i], NULL);
if (ret) { if (ret) {
errno = ret; errno = ret;
perror("pthread_join"); perror("pthread_join");
@ -156,20 +156,20 @@ int
main(int argc, char **argv) main(int argc, char **argv)
{ {
#ifdef DEBUG #ifdef DEBUG
runtime__process_debug_log_behavior(); runtime_process_debug_log_behavior();
#endif #endif
printf("Starting Awsm\n"); printf("Starting Awsm\n");
if (argc != 2) { if (argc != 2) {
runtime__usage(argv[0]); runtime_usage(argv[0]);
exit(-1); exit(-1);
} }
memset(runtime__worker_threads, 0, sizeof(pthread_t) * WORKER_THREAD__CORE_COUNT); memset(runtime_worker_threads, 0, sizeof(pthread_t) * WORKER_THREAD__CORE_COUNT);
runtime__set_resource_limits_to_max(); runtime_set_resource_limits_to_max();
runtime__allocate_available_cores(); runtime_allocate_available_cores();
runtime__initialize(); runtime_initialize();
debuglog("Parsing modules file [%s]\n", argv[1]); debuglog("Parsing modules file [%s]\n", argv[1]);
if (module_new_from_json(argv[1])) { if (module_new_from_json(argv[1])) {
@ -178,5 +178,5 @@ main(int argc, char **argv)
} }
listener_thread_initialize(); listener_thread_initialize();
runtime__start_runtime__worker_threads(); runtime_start_runtime_worker_threads();
} }

2
runtime/src/module.c
Unescape View File

@ -50,7 +50,7 @@ module_initialize_as_server(struct module *module)
struct epoll_event accept_evt; struct epoll_event accept_evt;
accept_evt.data.ptr = (void *)module; accept_evt.data.ptr = (void *)module;
accept_evt.events = EPOLLIN; accept_evt.events = EPOLLIN;
if (epoll_ctl(runtime__epoll_file_descriptor, EPOLL_CTL_ADD, module->socket_descriptor, &accept_evt) < 0) if (epoll_ctl(runtime_epoll_file_descriptor, EPOLL_CTL_ADD, module->socket_descriptor, &accept_evt) < 0)
assert(0); assert(0);
} }

26
runtime/src/runtime.c
Unescape View File

@ -28,10 +28,10 @@
* Shared Process State * * Shared Process State *
**************************/ **************************/
struct deque_sandbox *runtime__global_deque; struct deque_sandbox *runtime_global_deque;
pthread_mutex_t runtime__global_deque_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t runtime_global_deque_mutex = PTHREAD_MUTEX_INITIALIZER;
int runtime__epoll_file_descriptor; int runtime_epoll_file_descriptor;
http_parser_settings runtime__http_parser_settings; http_parser_settings runtime_http_parser_settings;
/****************************************** /******************************************
* Shared Process / Listener Thread Logic * * Shared Process / Listener Thread Logic *
@ -41,23 +41,23 @@ http_parser_settings runtime__http_parser_settings;
* Initialize runtime global state, mask signals, and init http parser * Initialize runtime global state, mask signals, and init http parser
*/ */
void void
runtime__initialize(void) runtime_initialize(void)
{ {
runtime__epoll_file_descriptor = epoll_create1(0); runtime_epoll_file_descriptor = epoll_create1(0);
assert(runtime__epoll_file_descriptor >= 0); assert(runtime_epoll_file_descriptor >= 0);
// Allocate and Initialize the global deque // Allocate and Initialize the global deque
runtime__global_deque = (struct deque_sandbox *)malloc(sizeof(struct deque_sandbox)); runtime_global_deque = (struct deque_sandbox *)malloc(sizeof(struct deque_sandbox));
assert(runtime__global_deque); assert(runtime_global_deque);
// Note: Below is a Macro // Note: Below is a Macro
deque_init_sandbox(runtime__global_deque, RUNTIME__MAX_SANDBOX_REQUEST_COUNT); deque_init_sandbox(runtime_global_deque, RUNTIME__MAX_SANDBOX_REQUEST_COUNT);
// Mask Signals // Mask Signals
software_interrupt__mask_signal(SIGUSR1); software_interrupt__mask_signal(SIGUSR1);
software_interrupt__mask_signal(SIGALRM); software_interrupt__mask_signal(SIGALRM);
// Initialize http_parser_settings global // Initialize http_parser_settings global
http_parser_settings_initialize(&runtime__http_parser_settings); http_parser_settings_initialize(&runtime_http_parser_settings);
} }
/******************************** /********************************
@ -71,7 +71,7 @@ runtime__initialize(void)
* @return NULL * @return NULL
* *
* Used Globals: * Used Globals:
* runtime__epoll_file_descriptor - the epoll file descriptor * runtime_epoll_file_descriptor - the epoll file descriptor
* *
*/ */
void * void *
@ -82,7 +82,7 @@ listener_thread_main(void *dummy)
int total_requests = 0; int total_requests = 0;
while (true) { while (true) {
int request_count = epoll_wait(runtime__epoll_file_descriptor, epoll_events, int request_count = epoll_wait(runtime_epoll_file_descriptor, epoll_events,
LISTENER_THREAD__MAX_EPOLL_EVENTS, -1); LISTENER_THREAD__MAX_EPOLL_EVENTS, -1);
u64 start_time = util__rdtsc(); u64 start_time = util__rdtsc();
for (int i = 0; i < request_count; i++) { for (int i = 0; i < request_count; i++) {

4
runtime/src/sandbox.c
Unescape View File

@ -47,14 +47,14 @@ current_sandbox_setup_arguments(i32 argument_count)
* @param length The size of the request_response_data that we want to parse * @param length The size of the request_response_data that we want to parse
* @returns 0 * @returns 0
* *
* Globals: runtime__http_parser_settings * Globals: runtime_http_parser_settings
**/ **/
int int
sandbox__parse_http_request(struct sandbox *sandbox, size_t length) sandbox__parse_http_request(struct sandbox *sandbox, size_t length)
{ {
// Why is our start address sandbox->request_response_data + sandbox->request_response_data_length? // Why is our start address sandbox->request_response_data + sandbox->request_response_data_length?
// it's like a cursor to keep track of what we've read so far // it's like a cursor to keep track of what we've read so far
http_parser_execute(&sandbox->http_parser, &runtime__http_parser_settings, http_parser_execute(&sandbox->http_parser, &runtime_http_parser_settings,
sandbox->request_response_data + sandbox->request_response_data_length, length); sandbox->request_response_data + sandbox->request_response_data_length, length);
return 0; return 0;
} }

6
runtime/src/software_interrupt.c
Unescape View File

@ -32,7 +32,7 @@ __thread volatile sig_atomic_t software_interrupt__is_disabled = 0;
* Externs * Externs
***************************************/ ***************************************/
extern pthread_t runtime__worker_threads[]; extern pthread_t runtime_worker_threads[];
/*************************************** /***************************************
* Private Static Inlines * Private Static Inlines
@ -65,11 +65,11 @@ software_interrupt__handle_signals(int signal_type, siginfo_t *signal_info, void
int rt = 0; int rt = 0;
// deliver signal to all other runtime threads.. // deliver signal to all other runtime threads..
for (int i = 0; i < WORKER_THREAD__CORE_COUNT; i++) { for (int i = 0; i < WORKER_THREAD__CORE_COUNT; i++) {
if (pthread_self() == runtime__worker_threads[i]) { if (pthread_self() == runtime_worker_threads[i]) {
rt = 1; rt = 1;
continue; continue;
} }
pthread_kill(runtime__worker_threads[i], SIGALRM); pthread_kill(runtime_worker_threads[i], SIGALRM);
} }
assert(rt == 1); assert(rt == 1);
} else { } else {

Write Preview
Loading…
Cancel
Save