From 3aeed6f94b0e6f0958cdcb1513b461d351f84b6c Mon Sep 17 00:00:00 2001 From: hwwang Date: Sat, 6 Jul 2024 20:03:06 +0800 Subject: [PATCH] =?UTF-8?q?=E5=B7=B2=E6=B7=BB=E5=8A=A0DAG,=E9=9C=80?= =?UTF-8?q?=E8=A6=81=E4=BF=AE=E6=94=B9=E5=90=84=E9=83=A8=E4=BB=BD=E6=97=B6?= =?UTF-8?q?=E9=97=B4=E6=B5=8B=E8=AF=95=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .vscode/launch.json | 21 ++++ .vscode/settings.json | 4 +- runtime/include/map.h | 54 +++++---- runtime/include/perf_window.h | 2 +- runtime/include/xmalloc.h | 4 +- runtime/src/current_sandbox.c | 207 ++++++++++++++++++++++++++-------- runtime/tests/graph.json | 48 ++++++++ runtime/tests/work/main | Bin 0 -> 16120 bytes runtime/tests/work/main.c | 3 +- runtime/utest/map | Bin 16696 -> 21264 bytes runtime/utest/maptest.c | 43 +++---- sledge.log | 8 +- 12 files changed, 294 insertions(+), 100 deletions(-) create mode 100755 runtime/tests/work/main diff --git a/.vscode/launch.json b/.vscode/launch.json index 84201fc..82a7df5 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -70,6 +70,27 @@ "ignoreFailures": true } ] + }, + { + "name": "utest", + "type": "cppdbg", + "request": "launch", + "program": "${workspaceFolder}/runtime/utest/map", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "sourceFileMap": {}, + "environment": [], + "externalConsole": false, + "MIMode": "gdb", + "envFile": "${workspaceFolder}/.env", + "setupCommands": [ + { + "description": "Enable pretty-printing for gdb", + "text": "-enable-pretty-printing", + "ignoreFailures": true + } + ] } ] } diff --git a/.vscode/settings.json b/.vscode/settings.json index ce4f9d8..39ad760 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -103,7 +103,9 @@ "map.h": "c", "stdio.h": "c", "hashmap.h": "c", - "mutex": "cpp" + "mutex": "cpp", + "xmalloc.h": "c", + "stddef.h": "c" }, "files.exclude": { "**/.git": true, diff --git a/runtime/include/map.h b/runtime/include/map.h index 047d716..61574b3 100644 --- a/runtime/include/map.h +++ b/runtime/include/map.h @@ -16,11 +16,12 @@ struct map_node { struct map_node *next; - char *key; + void *key; void *value; uint32_t key_len; uint32_t value_len; uint32_t hash; + bool manage_mvalue; }; struct map_bucket { @@ -39,16 +40,17 @@ map_init(struct hashmap *restrict map) map->buckets[i].head = NULL; LOCK_INIT(&map->buckets[i].lock); } -}; +} /* See https://en.wikipedia.org/wiki/Jenkins_hash_function */ static inline uint32_t -jenkins_hash(char *key, uint32_t key_len) +jenkins_hash(void *key, uint32_t key_len) { uint32_t i = 0; uint32_t hash = 0; + unsigned char *data = (unsigned char *)key; while (i != key_len) { - hash += key[i++]; + hash += data[i++]; hash += hash << 10; hash ^= hash >> 6; } @@ -59,7 +61,7 @@ jenkins_hash(char *key, uint32_t key_len) } static inline void * -map_get(struct hashmap *map, char *key, uint32_t key_len, uint32_t *ret_value_len) +map_get(struct hashmap *map, void *key, uint32_t key_len, uint32_t *ret_value_len) { void *value = NULL; @@ -84,13 +86,15 @@ DONE: } static inline bool -map_set(struct hashmap *map, char *key, uint32_t key_len, void *value, uint32_t value_len) +map_set(struct hashmap *map, void *key, uint32_t key_len, void *value, uint32_t value_len, bool manage_mvalue) { bool did_set = false; uint32_t hash = MAP_HASH(key, key_len); struct map_bucket *bucket = &map->buckets[hash % MAP_BUCKET_COUNT]; + LOCK_LOCK(&bucket->lock); + for (struct map_node *node = bucket->head; node != NULL; node = node->next) { if (node->hash == hash) goto DONE; } @@ -99,14 +103,18 @@ map_set(struct hashmap *map, char *key, uint32_t key_len, void *value, uint32_t *(new_node) = (struct map_node){ .hash = hash, .key = xmalloc(key_len), .key_len = key_len, - .value = value, .value_len = value_len, .next = bucket->head }; // Copy Key and Value memcpy(new_node->key, key, key_len); - //memcpy(new_node->value, value, value_len); - + if (manage_mvalue) { + new_node->value = xmalloc(value_len); + memcpy(new_node->value, value, value_len); + } else { + new_node->value = value; + } + new_node->manage_mvalue = manage_mvalue; bucket->head = new_node; did_set = true; @@ -119,7 +127,7 @@ DONE: * @returns boolean if node was deleted or not */ static inline bool -map_delete(struct hashmap *map, char *key, uint32_t key_len) +map_delete(struct hashmap *map, void *key, uint32_t key_len) { bool did_delete = false; @@ -131,7 +139,9 @@ map_delete(struct hashmap *map, char *key, uint32_t key_len) if (prev != NULL && prev->hash == hash) { bucket->head = prev->next; free(prev->key); - //free(prev->value); + if (prev->manage_mvalue) { + free(prev->value); + } free(prev); did_delete = true; goto DONE; @@ -140,7 +150,9 @@ map_delete(struct hashmap *map, char *key, uint32_t key_len) for (struct map_node *node = prev->next; node != NULL; prev = node, node = node->next) { prev->next = node->next; free(node->key); - //free(node->value); + if (node->manage_mvalue) { + free(node->value); + } free(node); did_delete = true; goto DONE; @@ -151,8 +163,8 @@ DONE: return did_delete; } -/* static inline void -map_upsert(struct hashmap *map, char *key, uint32_t key_len, void *value, uint32_t value_len) +static inline void +map_upsert(struct hashmap *map, void *key, uint32_t key_len, void *value, uint32_t value_len) { uint32_t hash = MAP_HASH(key, key_len); struct map_bucket *bucket = &map->buckets[hash % MAP_BUCKET_COUNT]; @@ -161,10 +173,13 @@ map_upsert(struct hashmap *map, char *key, uint32_t key_len, void *value, uint32 for (struct map_node *node = bucket->head; node != NULL; node = node->next) { if (node->hash == hash) { node->value_len = value_len; - //node->value = realloc(node->value, value_len); - node->value = value; + node->value = realloc(node->value, value_len); + //node->value = value; assert(node->value); - //memcpy(node->value, value, value_len); + if (node->manage_mvalue) + { + memcpy(node->value, value, value_len); + } goto DONE; } } @@ -183,11 +198,10 @@ map_upsert(struct hashmap *map, char *key, uint32_t key_len, void *value, uint32 // Copy Key and Value memcpy(new_node->key, key, key_len); - new_node->value = value; - //memcpy(new_node->value, value, value_len); + memcpy(new_node->value, value, value_len); bucket->head = new_node; DONE: LOCK_UNLOCK(&bucket->lock); -} */ +} diff --git a/runtime/include/perf_window.h b/runtime/include/perf_window.h index 283c02c..431efa2 100644 --- a/runtime/include/perf_window.h +++ b/runtime/include/perf_window.h @@ -149,7 +149,7 @@ perf_window_get_percentile(struct perf_window *self, int percentile, int precomp return 0; } - if (likely(size >= PERF_WINDOW_BUFFER_SIZE)) return self->by_duration[precomputed_index].execution_time; + //if (likely(size >= PERF_WINDOW_BUFFER_SIZE)) return self->by_duration[precomputed_index].execution_time; return self->by_duration[size * percentile / 100].execution_time; } diff --git a/runtime/include/xmalloc.h b/runtime/include/xmalloc.h index 8449da0..8860568 100644 --- a/runtime/include/xmalloc.h +++ b/runtime/include/xmalloc.h @@ -3,12 +3,12 @@ #include #include "likely.h" -#include "panic.h" +//#include "panic.h" static inline void * xmalloc(size_t size) { void *allocation = malloc(size); - if (unlikely(allocation == NULL)) panic("xmalloc failed!\n"); + //if (unlikely(allocation == NULL)) panic("xmalloc failed!\n"); return allocation; } diff --git a/runtime/src/current_sandbox.c b/runtime/src/current_sandbox.c index 8159c72..13f9e39 100644 --- a/runtime/src/current_sandbox.c +++ b/runtime/src/current_sandbox.c @@ -73,11 +73,21 @@ current_sandbox_start(void) sandbox_initialize_stdio(sandbox); int next_module_idx = sandbox->module->next_module_count; - static struct hashmap *sandbox_req_map = NULL; - if (sandbox_req_map == NULL) { - sandbox_req_map = malloc(sizeof(struct hashmap)); + static struct hashmap *sandbox_req_map = NULL; + static struct hashmap *sandbox_request_id = NULL; + if (sandbox_req_map == NULL || sandbox_request_id == NULL) { + if(sandbox_req_map == NULL) + { + sandbox_req_map = malloc(sizeof(struct hashmap)); + map_init(sandbox_req_map); + } + if(sandbox_request_id == NULL) + { + sandbox_request_id = malloc(sizeof(struct hashmap)); + map_init(sandbox_request_id); + } assert(sandbox_req_map != NULL); - map_init(sandbox_req_map); + assert(sandbox_request_id != NULL); } @@ -130,62 +140,163 @@ current_sandbox_start(void) */ goto err; } else if (next_module != NULL) { - /* Generate a new request, copy the current sandbox's output to the next request's buffer, and put it to the global queue */ - ssize_t output_length = sandbox->request_response_data_length - sandbox->request_length; - char * pre_func_output = (char *)malloc(output_length); - if (!pre_func_output) { - fprintf(stderr, "Failed to allocate memory for the previous output: %s\n", strerror(errno)); - goto err; - }; - - memcpy(pre_func_output, sandbox->request_response_data + sandbox->request_length, output_length); - uint64_t enqueue_timestamp = __getcycles(); - //uint64_t current_rs = enqueue_timestamp - system_start_timestamp; - //mem_log("time %lu request id:%d executing, name:%s remaining slack %lu\n", current_rs, - // sandbox->id, sandbox->module->name, sandbox->remaining_slack); assert(next_module_idx); assert(next_module); - for (size_t i = 0; i < next_module_idx; i++) - { - struct module * next_module_node = next_module[i]; - assert(next_module_node); - struct sandbox_request *sandbox_request = - sandbox_request_allocate(next_module_node, false, sandbox->request_length, - next_module_node->name, sandbox->client_socket_descriptor, + size_t next_module_pre_count_flag = next_module[0]->pre_module_count; + assert(next_module_pre_count_flag); + if (next_module_idx > 1 || (next_module_idx == 1 && next_module_pre_count_flag == 1)) + { + /* Generate a new request, copy the current sandbox's output to the next request's buffer, and put it to the global queue */ + ssize_t output_length = sandbox->request_response_data_length - sandbox->request_length; + char * pre_func_output = (char *)malloc(output_length); + if (!pre_func_output) { + fprintf(stderr, "Failed to allocate memory for the previous output: %s\n", strerror(errno)); + goto err; + }; + + memcpy(pre_func_output, sandbox->request_response_data + sandbox->request_length, output_length); + uint64_t enqueue_timestamp = __getcycles(); + //uint64_t current_rs = enqueue_timestamp - system_start_timestamp; + //mem_log("time %lu request id:%d executing, name:%s remaining slack %lu\n", current_rs, + // sandbox->id, sandbox->module->name, sandbox->remaining_slack); + + for (size_t i = 0; i < next_module_idx; i++) + { + struct module * next_module_node = next_module[i]; + assert(next_module_node); + struct sandbox_request *sandbox_request = + sandbox_request_allocate(next_module_node, false, sandbox->request_length, + next_module_node->name, sandbox->client_socket_descriptor, (const struct sockaddr *)&sandbox->client_address, sandbox->request_arrival_timestamp, enqueue_timestamp, - sandbox->remaining_slack, true, pre_func_output, output_length); - /* TODO: All sandboxs in the chain share the same request id, but sandbox_request_allocate() - * will busy-wait to generate an unique id, should we optimize it here? - */ - sandbox_request->id = sandbox->id; + sandbox->remaining_slack, true, pre_func_output, output_length); + /* TODO: All sandboxs in the chain share the same request id, but sandbox_request_allocate() + * will busy-wait to generate an unique id, should we optimize it here? + */ + sandbox_request->id = sandbox->id; #ifdef OPT_AVOID_GLOBAL_QUEUE - /* TODO: The running time of the current sandbox contains the next sandbox's initialization time, does it matter? */ - if (sandbox->absolute_deadline == sandbox_request->absolute_deadline) { - /* Put the next sandbox to the local run queue to reduce the overhead of the global queue */ - struct sandbox *next_sandbox = sandbox_allocate(sandbox_request); - if (!next_sandbox) { - free(sandbox_request); - goto err; - } + /* TODO: The running time of the current sandbox contains the next sandbox's initialization time, does it matter? */ + if (sandbox->absolute_deadline == sandbox_request->absolute_deadline) { + /* Put the next sandbox to the local run queue to reduce the overhead of the global queue */ + struct sandbox *next_sandbox = sandbox_allocate(sandbox_request); + if (!next_sandbox) { + free(sandbox_request); + goto err; + } assert(next_sandbox->state == SANDBOX_INITIALIZED); sandbox_set_as_runnable(next_sandbox, SANDBOX_INITIALIZED); - } else { - /* Add to the Global Sandbox Request Scheduler */ - global_request_scheduler_add(sandbox_request); - } + } else { + /* Add to the Global Sandbox Request Scheduler */ + global_request_scheduler_add(sandbox_request); + } #else - /* Add to the Global Sandbox Request Scheduler */ - global_request_scheduler_add(sandbox_request); + /* Add to the Global Sandbox Request Scheduler */ + global_request_scheduler_add(sandbox_request); + } #endif - /* Remove the client fd from epoll if it is the first sandbox in the chain */ - if (sandbox->request_from_outside) { - sandbox_remove_from_epoll(sandbox); - } - sandbox_set_as_returned(sandbox, SANDBOX_RUNNING); + /* Remove the client fd from epoll if it is the first sandbox in the chain */ + if (sandbox->request_from_outside) { + sandbox_remove_from_epoll(sandbox); + } + sandbox_set_as_returned(sandbox, SANDBOX_RUNNING); + }else if (next_module_idx == 1 && next_module_pre_count_flag > 1) + { + /*Before each id is put into the hash table, the key needs to add a "module handle"*/ + struct module * next_module_node = next_module[0]; + assert(next_module_node); + char *cur_request_id = NULL; + int key_len = snprintf(NULL, 0, "%s%lu", next_module_node->name, sandbox->id) + 1; + cur_request_id = (char *)malloc(key_len); + assert(cur_request_id); + snprintf(cur_request_id, key_len, "%s%lu", next_module_node->name, sandbox->id); + uint32_t ret_value_len; + + uint64_t *requet_id = (uint64_t *)map_get(sandbox_request_id, cur_request_id, strlen(cur_request_id), &ret_value_len); + if (!requet_id) { + //it means that the first sandbox is calculated, and it needs to wait for the return value of other sandboxes. + ssize_t output_length = sandbox->request_response_data_length - sandbox->request_length; + char * pre_func_output = (char *)malloc(output_length); + if (!pre_func_output) { + fprintf(stderr, "Failed to allocate memory for the previous output: %s\n", strerror(errno)); + goto err; + }; + memcpy(pre_func_output, sandbox->request_response_data + sandbox->request_length, output_length); + uint64_t enqueue_timestamp = __getcycles(); + //uint64_t current_rs = enqueue_timestamp - system_start_timestamp; + //mem_log("time %lu request id:%d executing, name:%s remaining slack %lu\n", current_rs, + // sandbox->id, sandbox->module->name, sandbox->remaining_slack); + + struct sandbox_request *sandbox_request = + sandbox_request_allocate(next_module_node, false, sandbox->request_length, + next_module_node->name, sandbox->client_socket_descriptor, + (const struct sockaddr *)&sandbox->client_address, + sandbox->request_arrival_timestamp, enqueue_timestamp, + sandbox->remaining_slack, true, pre_func_output, output_length); + /* TODO: All sandboxs in the chain share the same request id, but sandbox_request_allocate() + * will busy-wait to generate an unique id, should we optimize it here? + */ + sandbox_request->id = sandbox->id; + + uint32_t module_pre_count = next_module[0]->pre_module_count; + module_pre_count--; + assert(module_pre_count); + map_set(sandbox_request_id, cur_request_id, strlen(cur_request_id), &module_pre_count, sizeof(uint32_t), true); + map_set(sandbox_req_map, cur_request_id, strlen(cur_request_id), sandbox_request, sizeof(struct sandbox_request *), false); + }else + { + uint32_t rest_pre_count =*requet_id; + assert(rest_pre_count >= 1); + + struct sandbox_request *sandbox_request = map_get(sandbox_req_map, cur_request_id, strlen(cur_request_id), &ret_value_len); + assert(sandbox_request); + // Copy data into pre_func_output + ssize_t output_length = sandbox->request_response_data_length - sandbox->request_length; + char *pre_func_output = (char *)malloc(output_length); + if (!pre_func_output) { + fprintf(stderr, "Failed to allocate memory for the previous output: %s\n", strerror(errno)); + goto err; + } + memcpy(pre_func_output, sandbox->request_response_data + sandbox->request_length, output_length); + + uint64_t enqueue_timestamp = __getcycles(); + + const char *previous_output = sandbox_request->previous_function_output ? sandbox_request->previous_function_output : ""; + int new_output_length = strlen(previous_output) + output_length + 2; + char *new_output = (char *)malloc(new_output_length); + if (!new_output) { + fprintf(stderr, "Failed to allocate memory for the new output: %s\n", strerror(errno)); + free(pre_func_output); + goto err; + } + snprintf(new_output, new_output_length, "%s+%s", previous_output, pre_func_output); + free(sandbox_request->previous_function_output); + sandbox_request->previous_function_output = new_output; + free(pre_func_output); + sandbox_request->output_length +=output_length; + + rest_pre_count --; + if (rest_pre_count != 0) + { + map_upsert(sandbox_request_id, cur_request_id, strlen(cur_request_id), &rest_pre_count, sizeof(uint32_t)); + }else + { + global_request_scheduler_add(sandbox_request); + map_delete(sandbox_req_map, cur_request_id, strlen(cur_request_id)); + map_delete(sandbox_request_id, cur_request_id, strlen(cur_request_id)); + } + } + if (sandbox->request_from_outside) { + sandbox_remove_from_epoll(sandbox); + } + sandbox_set_as_returned(sandbox, SANDBOX_RUNNING); } + else + { + error_message = "the strcuture of DAG is not supported\n"; + goto err; + } } else { /* Retrieve the result, construct the HTTP response, and send to client */ if (sandbox_send_response(sandbox) < 0) { diff --git a/runtime/tests/graph.json b/runtime/tests/graph.json index a0d128b..15df142 100644 --- a/runtime/tests/graph.json +++ b/runtime/tests/graph.json @@ -6,6 +6,54 @@ "relative-deadline-us": 50000, "argsize": 1, "pre_module_count": 0, + "next_modules": ["work2", "work3"], + "http-req-headers": [], + "http-req-content-type": "text/plain", + "http-req-size": 1048776, + "http-resp-headers": [], + "http-resp-size": 1048776, + "http-resp-content-type": "text/plain" +}, +{ + "active": true, + "name": "work2", + "path": "work_wasm.so", + "port": 10001, + "relative-deadline-us": 50000, + "argsize": 1, + "pre_module_count": 1, + "next_modules": ["work4"], + "http-req-headers": [], + "http-req-content-type": "text/plain", + "http-req-size": 1048776, + "http-resp-headers": [], + "http-resp-size": 1048776, + "http-resp-content-type": "text/plain" +}, +{ + "active": true, + "name": "work3", + "path": "work_wasm.so", + "port": 10002, + "relative-deadline-us": 50000, + "argsize": 1, + "pre_module_count": 1, + "next_modules": ["work4"], + "http-req-headers": [], + "http-req-content-type": "text/plain", + "http-req-size": 1048776, + "http-resp-headers": [], + "http-resp-size": 1048776, + "http-resp-content-type": "text/plain" +}, +{ + "active": true, + "name": "work4", + "path": "work_wasm.so", + "port": 10003, + "relative-deadline-us": 50000, + "argsize": 1, + "pre_module_count": 2, "next_modules": [], "http-req-headers": [], "http-req-content-type": "text/plain", diff --git a/runtime/tests/work/main b/runtime/tests/work/main new file mode 100755 index 0000000000000000000000000000000000000000..f128e47ae409da7cc997b93726e43ca2fac6d554 GIT binary patch literal 16120 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 literal 16696 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 diff --git a/runtime/utest/maptest.c b/runtime/utest/maptest.c index eea9ca4..b2189f2 100644 --- a/runtime/utest/maptest.c +++ b/runtime/utest/maptest.c @@ -1,6 +1,5 @@ #include "../include/map.h" #include -#include typedef struct { int id; @@ -27,10 +26,10 @@ int main() { // 将 Employee 结构体存入哈希表 char *key1 = "employee1"; - map_set(&myMap, key1, strlen(key1), alice, sizeof(Employee*)); + map_set(&myMap, key1, strlen(key1), alice, sizeof(Employee*), false); char *key2 = "employee2"; - map_set(&myMap, key2, strlen(key2), bob, sizeof(Employee*)); + map_set(&myMap, key2, strlen(key2), bob, sizeof(Employee*), true); // 尝试从哈希表中检索 Employee uint32_t ret_value_len; @@ -42,8 +41,8 @@ int main() { printf("Employee not found.\n"); } alice->id = 12; - char *key3 = "employee1"; - strcat(alice->name, key3); + char *key = "employee1"; + strcat(alice->name, key); retrieved_employee = (Employee *)map_get(&myMap, key1, strlen(key1), &ret_value_len); if (retrieved_employee) { printf("Retrieved Employee: %s, ID: %d, Salary: %.2f\n", @@ -51,27 +50,21 @@ int main() { } else { printf("Employee not found.\n"); } - map_delete(&myMap, key1, strlen(key1)); - retrieved_employee = (Employee *)map_get(&myMap, key1, strlen(key1), &ret_value_len); - if (retrieved_employee) { - printf("Retrieved Employee: %s, ID: %d, Salary: %.2f\n", - retrieved_employee->name, retrieved_employee->id, retrieved_employee->salary); - } else { - printf("Employee not found.\n"); - } - map_set(&myMap, key1, strlen(key1), alice, sizeof(Employee*)); - retrieved_employee = (Employee *)map_get(&myMap, key1, strlen(key1), &ret_value_len); - if (retrieved_employee) { - printf("Retrieved Employee: %s, ID: %d, Salary: %.2f\n", - retrieved_employee->name, retrieved_employee->id, retrieved_employee->salary); - } else { - printf("Employee not found.\n"); - } - - // 清理 + uint64_t value1 = 20, value2 = 30; + char *key3 = "test1"; + char *key4 = "test2"; + map_set(&myMap, key3, strlen(key3), &value1, sizeof(uint64_t), true); + uint32_t *value = (uint32_t *)map_get(&myMap, key3, strlen(key3), &ret_value_len); + if (value) printf("Retrieved value: %d\n", *value); else printf("Value not found.\n"); + value1 ++; + value = (uint32_t *)map_get(&myMap, key3, strlen(key3), &ret_value_len); + if (value) printf("Retrieved value: %d\n", *value); else printf("Value not found.\n"); + map_upsert(&myMap, key3, strlen(key3), &value1, sizeof(uint64_t)); + value = (uint32_t *)map_get(&myMap, key3, strlen(key3), &ret_value_len); + if (value) printf("Retrieved value: %d\n", *value); else printf("Value not found.\n"); + + free(alice); free(bob); - - // 也许还需要遍历哈希表并释放所有节点，这里假设只是一个简单的示例 return 0; } diff --git a/sledge.log b/sledge.log index 85c256d..2a66414 100755 --- a/sledge.log +++ b/sledge.log @@ -20,5 +20,9 @@ C: 01, T: 0x7ffff7bfdd80, F: runtime_start_runtime_worker_threads> C: 01, T: 0x7ffff7bfdd80, F: module_new> Stack Size: 524288 -sledgert: src/software_interrupt.c:181: void software_interrupt_handle_signals(int, siginfo_t *, void *): Assertion `TEST_RECORDING_BUFFER_LEN > software_interrupt_SIGALRM_kernel_count + software_interrupt_SIGALRM_thread_count' failed. -sledgert: src/software_interrupt.c:181: void software_interrupt_handle_signals(int, siginfo_t *, void *): Assertion `TEST_RECORDING_BUFFER_LEN > software_interrupt_SIGALRM_kernel_count + software_interrupt_SIGALRM_thread_count' failed. +C: 01, T: 0x7ffff7bfdd80, F: module_new> + Stack Size: 524288 +C: 01, T: 0x7ffff7bfdd80, F: module_new> + Stack Size: 524288 +C: 01, T: 0x7ffff7bfdd80, F: module_new> + Stack Size: 524288