need modify thirdparty hashmap

.env

@@ -1,3 +1,3 @@
-LD_LIBRARY_PATH=/home/hai/sledge-serverless-framework/runtime/bin
+LD_LIBRARY_PATH=/home/hai/sledge-old/runtime/bin
 SLEDGE_SCHEDULER=EDF
 SLEDGE_SANDBOX_PERF_LOG=/home/hai/sledge-serverless-framework/debuglog.txt

.gitmodules

@@ -11,6 +11,9 @@ url = https://github.com/gwsystems/ck.git
 [submodule "jsmn"]
 path = runtime/thirdparty/jsmn
 url = https://github.com/gwsystems/jsmn.git
+[submodule "hash"]
+path = runtime/thirdparty/hashmap
+url = https://github.com/tidwall/hashmap.c.git
 [submodule "runtime/tests/gocr"]
 path = runtime/tests/gocr
 url = https://github.com/gwsystems/gocr.git

.vscode/launch.json

@@ -47,6 +47,29 @@
 					"ignoreFailures": true
 				}
 			]
+		},
+		{
+			"name": "graph",
+			"type": "cppdbg",
+			"request": "launch",
+			"program": "${workspaceFolder}/runtime/bin/sledgert",
+			"args": [
+				"${workspaceFolder}/runtime/tests/graph.json"
+			],
+			"stopAtEntry": false,
+			"cwd": "${workspaceFolder}",
+			"sourceFileMap": {"/sledge/runtime": "${workspaceFolder}/runtime"},
+			"environment": [],
+			"externalConsole": false,
+			"MIMode": "gdb",
+			"envFile": "${workspaceFolder}/.env",
+			"setupCommands": [
+				{
+					"description": "Enable pretty-printing for gdb",
+					"text": "-enable-pretty-printing",
+					"ignoreFailures": true
+				}
+			]
 		}
 	]
-}
+}

.vscode/settings.json

@@ -95,7 +95,15 @@
     "compare": "c",
     "cstdint": "c",
     "format": "c",
-    "jsmn.h": "c"
+    "jsmn.h": "c",
+    "__bit_reference": "c",
+    "algorithm": "c",
+    "lock_time.h": "c",
+    "mcs.h": "c",
+    "map.h": "c",
+    "stdio.h": "c",
+    "hashmap.h": "c",
+    "mutex": "cpp"
   },
   "files.exclude": {
     "**/.git": true,
@@ -144,6 +152,7 @@
     "**/runtime/thirdparty/http-parser/**": true,
     "**/runtime/thirdparty/jsmn/**": true,
     "**/runtime/thirdparty/dist/**": true,
+	"**/runtime/thirdparty/hashmap/**": true,
     "*.o": true,
     "*.bc": true,
     "*.wasm": true
@@ -207,4 +216,4 @@
   "C_Cpp_Runner.msvcSecureNoWarnings": false,
   "git.detectSubmodules": true,
   "git.enabled": true
-}
+}

runtime/Makefile

@@ -10,10 +10,10 @@ PAGE_SIZE := $(shell getconf PAGESIZE)
 
 # Compiler Settings
 CC=clang
-CC_OPTIONS = -O3 -flto -g -pthread -D_GNU_SOURCE
+# CC_OPTIONS = -O3 -flto -g -pthread -D_GNU_SOURCE
 
 # CC_OPTIONS for Debugging
-# CC_OPTIONS = -O0 -g -pthread -D_GNU_SOURCE
+CC_OPTIONS = -O0 -g -pthread -D_GNU_SOURCE
 
 # CFI Sanitizer
 # CC_OPTIONS = -O0 -g -pthread -D_GNU_SOURCE -flto -fvisibility=default -fsanitize=cfi 
@@ -59,8 +59,8 @@ CFLAGS += -DLOG_TO_FILE
 # CFLAGS += -DLOG_PREEMPTION
 # CFLAGS += -DLOG_MODULE_LOADING
 # CFLAGS += -DOPT_AVOID_GLOBAL_QUEUE
-# CFLAGS += -DLOG_RUNTIME_FILE_LOG
+CFLAGS += -DLOG_RUNTIME_FILE_LOG
- CFLAGS += -DLOG_RUNTIME_MEM_LOG
+CFLAGS += -DLOG_RUNTIME_MEM_LOG
 
 # This dumps per module *.csv files containing the cycle a sandbox has been in RUNNING when each
 # page is allocated. This helps understand the relationship to memory allocation and execution time.

runtime/include/hash.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "hashmap.h"
+#include "lock.h"
+#include "xmalloc.h"
+
+typedef struct 
+{
+    struct hashmap* map;
+    lock_t lock;
+}lockhashmap;
+
+static inline lockhashmap
+*hashmap_lock_new(
+    size_t elsize, size_t cap, uint64_t seed0, 
+    uint64_t seed1, 
+    uint64_t (*hash)(const void *item, uint64_t seed0, uint64_t seed1),
+    int (*compare)(const void *a, const void *b, void *udata),
+    void (*elfree)(void *item),
+    void *udata
+)
+{
+    lockhashmap* node = (lockhashmap *)xmalloc(sizeof(lockhashmap));
+    node->map = hashmap_new(elsize, cap, seed0, seed1, hash, compare, elfree, udata);
+    LOCK_INIT(&node->lock);
+    return node;
+}
+
+/*void threadsafe_hashmap_free(ThreadSafeHashmap *thm) {
+    if (thm) {
+        spinlock_acquire(&thm->lock);
+        hashmap_free(thm->map);
+        spinlock_release(&thm->lock);
+        spinlock_destroy(&thm->lock);
+        free(thm);
+    }
+}
+
+bool threadsafe_hashmap_set(ThreadSafeHashmap *thm, const void *item) {
+    spinlock_acquire(&thm->lock);
+    const void *result = hashmap_set(thm->map, item);
+    spinlock_release(&thm->lock);
+    return result != NULL;
+}
+
+const void *threadsafe_hashmap_get(ThreadSafeHashmap *thm, const void *item) {
+    spinlock_acquire(&thm->lock);
+    const void *result = hashmap_get(thm->map, item);
+    spinlock_release(&thm->lock);
+    return result;
+}
+*/

runtime/include/map.h

@@ -0,0 +1,193 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "lock.h"
+#include "xmalloc.h"
+
+/* Simple K-V store based on The Practice of Programming by Kernighan and Pike */
+
+/* Bucket count is sized to be a prime that is approximately 20% larger than the desired capacity (6k keys) */
+#define MAP_BUCKET_COUNT 7907
+#define MAP_HASH         jenkins_hash
+
+struct map_node {
+	struct map_node *next;
+	char            *key;
+	void            *value;
+	uint32_t         key_len;
+	uint32_t         value_len;
+	uint32_t         hash;
+};
+
+struct map_bucket {
+	lock_t           lock;
+	struct map_node *head;
+};
+
+struct hashmap {
+	struct map_bucket buckets[MAP_BUCKET_COUNT];
+};
+
+static inline void
+map_init(struct hashmap *restrict map)
+{
+	for (int i = 0; i < MAP_BUCKET_COUNT; i++) {
+		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)
+{
+	uint32_t i    = 0;
+	uint32_t hash = 0;
+	while (i != key_len) {
+		hash += key[i++];
+		hash += hash << 10;
+		hash ^= hash >> 6;
+	}
+	hash += hash << 3;
+	hash ^= hash >> 11;
+	hash += hash << 15;
+	return hash;
+}
+
+static inline void *
+map_get(struct hashmap *map, char *key, uint32_t key_len, uint32_t *ret_value_len)
+{
+	void *value = NULL;
+
+	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) {
+			value          = node->value;
+			*ret_value_len = node->value_len;
+			goto DONE;
+		}
+	}
+
+	if (value == NULL) *ret_value_len = 0;
+
+DONE:
+	LOCK_UNLOCK(&bucket->lock);
+	return value;
+}
+
+static inline bool
+map_set(struct hashmap *map, char *key, uint32_t key_len, void *value, uint32_t value_len)
+{
+	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;
+	}
+
+	struct map_node *new_node = (struct map_node *)xmalloc(sizeof(struct map_node));
+	*(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);
+
+	bucket->head = new_node;
+	did_set      = true;
+
+DONE:
+	LOCK_UNLOCK(&bucket->lock);
+	return did_set;
+}
+
+/**
+ * @returns boolean if node was deleted or not
+ */
+static inline bool
+map_delete(struct hashmap *map, char *key, uint32_t key_len)
+{
+	bool did_delete = false;
+
+	uint32_t           hash   = MAP_HASH(key, key_len);
+	struct map_bucket *bucket = &map->buckets[hash % MAP_BUCKET_COUNT];
+	LOCK_LOCK(&bucket->lock);
+
+	struct map_node *prev = bucket->head;
+	if (prev != NULL && prev->hash == hash) {
+		bucket->head = prev->next;
+		free(prev->key);
+		//free(prev->value);
+		free(prev);
+		did_delete = true;
+		goto DONE;
+	}
+
+	for (struct map_node *node = prev->next; node != NULL; prev = node, node = node->next) {
+		prev->next = node->next;
+		free(node->key);
+		//free(node->value);
+		free(node);
+		did_delete = true;
+		goto DONE;
+	}
+
+DONE:
+	LOCK_UNLOCK(&bucket->lock);
+	return did_delete;
+}
+
+/* static inline void
+map_upsert(struct hashmap *map, char *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];
+	LOCK_LOCK(&bucket->lock);
+
+	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;
+			assert(node->value);
+			//memcpy(node->value, value, value_len);
+			goto DONE;
+		}
+	}
+
+	struct map_node *new_node = (struct map_node *)xmalloc(sizeof(struct map_node));
+
+	*(new_node) = (struct map_node){ .hash      = hash,
+		                         .key       = xmalloc(key_len),
+		                         .key_len   = key_len,
+		                         .value     = xmalloc(value_len),
+		                         .value_len = value_len,
+		                         .next      = bucket->head };
+
+	assert(new_node->key);
+	assert(new_node->value);
+
+	// Copy Key and Value
+	memcpy(new_node->key, key, key_len);
+	new_node->value = value;
+	//memcpy(new_node->value, value, value_len);
+
+	bucket->head = new_node;
+
+DONE:
+	LOCK_UNLOCK(&bucket->lock);
+} */

runtime/include/module.h

@@ -78,7 +78,11 @@ struct module {
 
 	/* Entry Function to invoke serverless function */
 	mod_main_fn_t main;
-	struct module *next_module; /* the next module in the chain */
+	struct module **next_module; /* the next module in the DAG */
+	struct module **pre_module; /* the previous module in the DAG */
+	char **next_module_names; /* the next modules name in the DAG */
+	uint32_t next_module_count;
+	uint32_t pre_module_count;
 };
 
 /*************************

runtime/include/xmalloc.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stdlib.h>
+
+#include "likely.h"
+#include "panic.h"
+
+static inline void *
+xmalloc(size_t size)
+{
+	void *allocation = malloc(size);
+	if (unlikely(allocation == NULL)) panic("xmalloc failed!\n");
+	return allocation;
+}

runtime/src/current_sandbox.c

@@ -8,6 +8,8 @@
 #include "scheduler.h"
 #include "module.h"
 #include "software_interrupt.h"
+#include "map.h"
+#include "hashmap.h"
 
 extern uint64_t system_start_timestamp;
 
@@ -70,7 +72,17 @@ current_sandbox_start(void)
 	char *error_message = "";
 
 	sandbox_initialize_stdio(sandbox);
-	struct module * next_module = sandbox->module->next_module;
+	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));
+		assert(sandbox_req_map != NULL);
+	    map_init(sandbox_req_map);
+	}
+	
+
+	
+	struct module **next_module = sandbox->module->next_module;
 
 	/* 
 	 * Add the client fd to epoll if it is the first or last sandbox in the chain because they 
@@ -131,9 +143,15 @@ current_sandbox_start(void)
 		//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 =
+		assert(next_module_idx);
-                                  sandbox_request_allocate(next_module, false, sandbox->request_length, 
+		assert(next_module);
-							   next_module->name, sandbox->client_socket_descriptor,
+		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);
@@ -166,6 +184,8 @@ current_sandbox_start(void)
 			sandbox_remove_from_epoll(sandbox);
 		}
 		sandbox_set_as_returned(sandbox, SANDBOX_RUNNING);
+
+		}
 	} else {
 		/* Retrieve the result, construct the HTTP response, and send to client */
 		if (sandbox_send_response(sandbox) < 0) {

runtime/src/module.c

@@ -19,6 +19,7 @@
 
 const int JSON_MAX_ELEMENT_COUNT = 16;
 const int JSON_MAX_ELEMENT_SIZE  = 1024;
+const int PRE_MODULE_COUNT = 4;
 
 /*************************
  * Private Static Inline *
@@ -374,7 +375,11 @@ module_new_from_json(char *file_name)
 	int   	module_count		= 0;
 	char 	*request_headers 	= NULL;
 	char 	*reponse_headers 	= NULL;
-	struct 	module *tail_module 	= NULL;
+	//struct 	module *tail_module 	= NULL;
+	struct module **nodes = malloc(JSON_MAX_ELEMENT_COUNT * sizeof(struct module*));
+	if (nodes == NULL) {
+        fprintf(stderr, "Memory allocation failed for nodes array\n");
+    }
 	for (int i = 0; i < total_tokens; i++) {
 		assert(tokens[i].type == JSMN_OBJECT);
 
@@ -397,6 +402,8 @@ module_new_from_json(char *file_name)
 		}
 		memset(reponse_headers, 0, HTTP_MAX_HEADER_LENGTH * HTTP_MAX_HEADER_COUNT);
 
+		uint32_t next_module_count                                   = 0;
+		uint32_t pre_module_count                                    = 0;
 		int32_t  request_size                                        = 0;
 		int32_t  response_size                                       = 0;
 		int32_t  argument_count                                      = 0;
@@ -412,6 +419,7 @@ module_new_from_json(char *file_name)
 		int      ntoks                                               = 2 * tokens[i].size;
 		char     request_content_type[HTTP_MAX_HEADER_VALUE_LENGTH]  = { 0 };
 		char     response_content_type[HTTP_MAX_HEADER_VALUE_LENGTH] = { 0 };
+		char 	 **next_module_names                                    = NULL;
 
 		for (; j < ntoks;) {
 			int  ntks     = 1;
@@ -445,6 +453,28 @@ module_new_from_json(char *file_name)
 				argument_count = atoi(val);
 				if (argument_count < 0 || argument_count > 127)
 					panic("Expected argument count between 0 and 127, saw %d\n", argument_count);
+			} else if (strcmp(key, "pre_module_count") == 0)
+			{
+				pre_module_count = atoi(val);
+				if (pre_module_count < 0)
+					panic("Expected pre_module_count to be nonnegative, saw %d\n", pre_module_count);
+			} else if (strcmp(key, "next_modules") == 0)
+			{
+    			assert(tokens[i + j + 1].type == JSMN_ARRAY);  
+    			request_count = tokens[i + j + 1].size;
+				ntks += request_count;
+				ntoks += request_count;
+    			next_module_names = malloc(request_count * sizeof(char *));  
+    			next_module_count = request_count;
+    			int array_index = 0;  
+    			for (int k = 1; k <= request_count; k++) {
+        			jsmntok_t *g = &tokens[i + j + k + 1];
+        			int name_length = g->end - g->start;
+        			next_module_names[array_index] = malloc(name_length + 1);  
+        			strncpy(next_module_names[array_index], file_buffer + g->start, name_length);
+       				next_module_names[array_index][name_length] = '\0';  
+        			array_index++;
+    			}
 			} else if (strcmp(key, "active") == 0) {
 				assert(tokens[i + j + 1].type == JSMN_PRIMITIVE);
 				if (val[0] == 't') {
@@ -566,28 +596,71 @@ module_new_from_json(char *file_name)
 			                                   relative_deadline_us, port, request_size, response_size,
 			                                   admissions_percentile, expected_execution_us);
 			if (module == NULL) goto module_new_err;
+			module->next_module_names = malloc(next_module_count * sizeof(struct module*));
+			for (int i = 0; i < next_module_count; i++) {
+    			module->next_module_names[i] = strdup(next_module_names[i]);
+    			if (module->next_module_names[i] == NULL) {
+        			fprintf(stderr, "Memory allocation failed for next_module_names[%d].\n", i);
+        			exit(EXIT_FAILURE);
+    			}
+			}
+			if (module->next_module_names == NULL)
+			{
+				panic("Failed to allocate memory for next_module_names");
+			}
 			
+			module->next_module_count = next_module_count;
+			module->pre_module_count = pre_module_count;
+			module->next_module = NULL;
+			module->pre_module = NULL;
 			assert(module);
-
-			if (tail_module != NULL) { tail_module->next_module = module; }
-			tail_module			= module;
-			tail_module->next_module 	= NULL;
-
-			/* if this is the tail module, reset tail_module to NULL to build another new chain */		
-			if (is_tail_module) {
-				tail_module = NULL;
-			}
 	
 			module_set_http_info(module, request_count, request_headers, request_content_type,
 			                     response_count, reponse_headers, response_content_type);
+			nodes[module_count] = module;
 			module_count++;
 		}
 
 		free(request_headers);
 		free(reponse_headers);
+		for (int i = 0; i < next_module_count; i++) {
+    		free(next_module_names[i]); // 释放每个字符串的内存
+		}
+		free(next_module_names); // 最后释放指针数组的内存
 	}
 
 	if (module_count == 0) panic("%s contained no active modules\n", file_name);
+	
+	for (ssize_t i = 0; i < module_count; i++) {
+		assert(nodes[i]);
+    	ssize_t count = nodes[i]->next_module_count;
+		
+		if (count == 0) continue;
+		nodes[i]->next_module = (struct module**) malloc(count * sizeof(struct module*));
+		if (nodes[i]->next_module == NULL) panic("Failed to allocate memory for next_module");
+
+		for (size_t j = 0; j < count; j++) {
+        	for (size_t m = i + 1; m < module_count; m++) { 
+           		if (strcmp(nodes[i]->next_module_names[j], nodes[m]->name) == 0) {
+					assert(nodes[m]);
+					uint32_t precount = nodes[m]->pre_module_count;
+					if (nodes[m]->pre_module == NULL) {
+                		nodes[m]->pre_module = (struct module**) malloc(precount * sizeof(struct module*));
+                		if (nodes[m]->pre_module == NULL) panic("Failed to allocate memory for pre_module");
+            		}
+            		nodes[i]->next_module[j] = nodes[m];
+					int preflag = 0;
+     				while (nodes[m]->pre_module[preflag]) {
+                    	preflag++;
+						assert(preflag < precount);
+                	}
+					nodes[m]->pre_module[preflag]  = nodes[i];
+					break;
+            	}
+			}
+    	}
+	}
+	free(nodes);
 #ifdef LOG_MODULE_LOADING
 	debuglog("Loaded %d module%s!\n", module_count, module_count > 1 ? "s" : "");
 #endif

runtime/tests/Makefile

@@ -2,16 +2,17 @@ include Makefile.inc
 
 #TESTS=fibonacci fibonacci2 fibonacci3 big_fibonacci C-Image-Manip empty work work1k work10k work100k work1m forever filesys sockserver sockclient empty
 TESTS=fibonacci big_fibonacci C-Image-Manip empty work work1k work10k work100k work1m forever filesys sockserver sockclient empty
-
+TESTS2= 
 
 TESTSRT=$(TESTS:%=%_rt)
-
+TESTSRT2=$(TESTS2:%=%_rt)
-.PHONY: all clean rttests tinyekf cifar10 gocr sod
+.PHONY: all clean rttests tinyekf cifar10 gocr sod add
 
 all: rttests tinyekf cifar10 gocr sod
 	@echo "Test Compilation done!"
 
 rttests: $(TESTSRT)
+add: $(TESTSRT2)
 
 clean:
 	@echo "Cleaning Test Applications"

runtime/tests/graph.json

@@ -0,0 +1,16 @@
+{
+	"active": true,
+	"name": "work",
+	"path": "work_wasm.so",
+	"port": 10000,
+	"relative-deadline-us": 50000,
+	"argsize": 1,
+	"pre_module_count": 0,
+	"next_modules": [],
+	"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"
+}

runtime/thirdparty/Makefile

@@ -3,7 +3,7 @@ DIST_PREFIX=${CURR_DIR}/dist/
 
 all: clean build
 
-build: ck jsmn http-parser
+build: ck jsmn http-parser hashmap
 
 ck:
 	mkdir -p ${DIST_PREFIX}
@@ -19,8 +19,11 @@ jsmn:
 	mkdir -p ${DIST_PREFIX}/include/
 	cp jsmn/jsmn.h ${DIST_PREFIX}/include/
 
+hashmap: hashmap/hashmap.c
+	cd hashmap; $(CC) $(CFLAGS) -I. -c hashmap.c; mv hashmap.o ${DIST_PREFIX}/lib/; cp hashmap.h ${DIST_PREFIX}/include/
+
 clean:
 	make -C ck uninstall
 	rm -rf ${DIST_PREFIX}
 
-.PHONY: clean all build ck jsmn http-parser
+.PHONY: clean all build ck jsmn http-parser hashmap

runtime/thirdparty/hashmap

@@ -0,0 +1 @@
+Subproject commit 1c139923fe08f36143ecc0ba37cd674684f87f9c

runtime/utest/maptest.c

@@ -0,0 +1,77 @@
+#include "../include/map.h"
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+    int id;
+    char name[100];
+    float salary;
+} Employee;
+
+
+int main() {
+    // 初始化哈希表
+    struct hashmap myMap;
+    map_init(&myMap);
+
+    // 创建并初始化一些 Employee 结构体
+    Employee *alice = malloc(sizeof(Employee));
+    alice->id = 1;
+    strcpy(alice->name, "Alice");
+    alice->salary = 50000.0;
+
+    Employee *bob = malloc(sizeof(Employee));
+    bob->id = 2;
+    strcpy(bob->name, "Bob");
+    bob->salary = 52000.0;
+
+    // 将 Employee 结构体存入哈希表
+    char *key1 = "employee1";
+    map_set(&myMap, key1, strlen(key1), alice, sizeof(Employee*));
+
+    char *key2 = "employee2";
+    map_set(&myMap, key2, strlen(key2), bob, sizeof(Employee*));
+
+    // 尝试从哈希表中检索 Employee
+    uint32_t ret_value_len;
+    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");
+    }
+    alice->id = 12;
+    char *key3 = "employee1";
+    strcat(alice->name, key3);
+    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_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");
+    }
+    
+    // 清理
+    free(alice);
+    free(bob);
+
+    // 也许还需要遍历哈希表并释放所有节点，这里假设只是一个简单的示例
+    return 0;
+}

sledge.log

@@ -0,0 +1,24 @@
+Runtime Environment:
+	CPU Speed: 2400 MHz
+	Processor Speed: 2400 MHz
+	RLIMIT_DATA: Infinite
+	RLIMIT_NOFILE: 1048576 (Increased from 8192)
+	Core Count: 8
+	Listener core ID: 1
+	First Worker core ID: 2
+	Worker core count: 6
+	Scheduler Policy: EDF
+	Sigalrm Policy: BROADCAST
+	Preemption: Enabled
+	Quantum: 5000 us
+	Sandbox Performance Log: /home/hai/sledge-serverless-framework/debuglog.txt
+Starting listener thread
+	Listener core thread: 7ffff7a006c0
+Starting 6 worker thread(s)
+C: 01, T: 0x7ffff7bfdd80, F: runtime_start_runtime_worker_threads> 
+	Sandboxing environment ready!
+
+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.