Malloc hook optimization

Signed-off-by: Nzhang-cui11 <zhangcui11@huawei.com>

musl_template.gni

@@ -724,12 +724,27 @@ template("musl_libs") {
       deps += [ "//base/startup/init/services/param/base:parameterbase" ]
     }
 
+    if (use_jemalloc) {
+      defines += [ "USE_JEMALLOC" ]
+      if (use_jemalloc_dfx_intf) {
+        defines += [ "USE_JEMALLOC_DFX_INTF" ]
+      }
+      include_dirs = [ "//third_party/jemalloc/include/jemalloc" ]
+    }
+
     configs -= musl_inherited_configs
 
     configs += [
       "//build/config/compiler:compiler",
       ":soft_hook",
     ]
+
+    cflags = [
+      "-mllvm",
+      "--instcombine-max-iterations=0",
+      "-ffp-contract=fast",
+      "-O3",
+    ]
   }
 
   source_set("soft_musl_jemalloc") {

porting/linux/user/src/hook/malloc_common.c

@@ -9,26 +9,44 @@
 
 void* malloc(size_t bytes)
 {
-	volatile const struct MallocDispatchType* dispatch_table = get_current_dispatch_table();
+	volatile const struct MallocDispatchType* dispatch_table = (struct MallocDispatchType *)atomic_load_explicit(
+		&__musl_libc_globals.current_dispatch_table, memory_order_acquire);
 	if (__predict_false(dispatch_table != NULL)) {
-		void*ret = dispatch_table->malloc(bytes);
-		return ret;
+		if (__get_memleak_hook_flag()) {
+			return dispatch_table->malloc(bytes);
+		}
+		if (!__get_global_hook_flag()) {
+			return MuslFunc(malloc)(bytes);
+		}
+		else if (!__get_hook_flag()) {
+			return MuslFunc(malloc)(bytes);
 		}
-	void* result = MuslMalloc(malloc)(bytes);
-	if (__predict_false(result == NULL)) {
-		//__musl_log(__MUSL_LOG_WARN, "malloc(%zu) failed: returning null pointer\n", bytes);
+		return dispatch_table->malloc(bytes);
 	}
-	return result;
+	return  MuslFunc(malloc)(bytes);
 }
 
 void free(void* mem)
 {
-	volatile const struct MallocDispatchType* dispatch_table = get_current_dispatch_table();
+	volatile const struct MallocDispatchType* dispatch_table = (struct MallocDispatchType *)atomic_load_explicit(
+		&__musl_libc_globals.current_dispatch_table, memory_order_acquire);
 	if (__predict_false(dispatch_table != NULL)) {
+		if (__get_memleak_hook_flag()) {
 			dispatch_table->free(mem);
-	} else {
-		MuslMalloc(free)(mem);
+			return;
+		}
+		if (!__get_global_hook_flag()) {
+			MuslFunc(free)(mem);
+			return;
+		}
+		else if (!__get_hook_flag()) {
+			MuslFunc(free)(mem);
+			return;
+		}
+		dispatch_table->free(mem);
+		return;
 	}
+	MuslFunc(free)(mem);
 }
 
 void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_t offset)

porting/linux/user/src/hook/musl_malloc.h

@@ -13,12 +13,20 @@ extern "C" {
 #define MuslMalloc(func) func
 #endif
 
+#ifdef USE_JEMALLOC
+extern void* je_malloc(size_t size);
+extern void je_free(void* p);
+#define MuslFunc(func) je_ ## func
+#else
+extern void* internal_malloc(size_t size);
+extern void internal_free(void* p);
+#define MuslFunc(func) internal_ ## func
+#endif
+
 void *__libc_mmap(void*, size_t, int, int, int, off_t);
 int __libc_munmap(void*, size_t);
-void *__libc_malloc(size_t);
 void *__libc_calloc(size_t, size_t);
 void *__libc_realloc(void *, size_t);
-void __libc_free(void *);
 void *__libc_valloc(size_t);
 void *__libc_memalign(size_t, size_t);
 size_t __libc_malloc_usable_size(void *);

porting/linux/user/src/hook/musl_preinit.c

@@ -40,7 +40,7 @@ void* ohos_malloc_hook_init_function(size_t bytes);
 
 static struct MallocDispatchType __ohos_malloc_hook_init_dispatch = {
 	.malloc = ohos_malloc_hook_init_function,
-	.free = MuslMalloc(free),
+	.free = MuslFunc(free),
 	.mmap = MuslMalloc(mmap),
 	.munmap = MuslMalloc(munmap),
 	.calloc = MuslMalloc(calloc),
@@ -459,7 +459,7 @@ void* ohos_malloc_hook_init_function(size_t bytes)
 			// __musl_log(__MUSL_LOG_ERROR, "%s: ohos_malloc_hook: failed to pthread_detach\n", getprogname());
 		}
 	}
-	void*ptr = MuslMalloc(malloc)(bytes);
+	void*ptr = MuslFunc(malloc)(bytes);
 	return ptr;
 
 }

porting/linux/user/src/hook/musl_preinit_common.c

@@ -8,8 +8,8 @@
 struct musl_libc_globals __musl_libc_globals;
 
 struct MallocDispatchType __libc_malloc_default_dispatch = {
-	.malloc = MuslMalloc(malloc),
-	.free = MuslMalloc(free),
+	.malloc = MuslFunc(malloc),
+	.free = MuslFunc(free),
 	.mmap = MuslMalloc(mmap),
 	.munmap = MuslMalloc(munmap),
 	.calloc = MuslMalloc(calloc),

porting/linux/user/src/malloc/malloc.c

@@ -30,11 +30,6 @@ extern int je_mallopt(int param, int value);
 #define inline inline __attribute__((always_inline))
 #endif
 
-#ifdef HOOK_ENABLE
-void *__libc_malloc(size_t);
-void __libc_free(void *p);
-#endif
-
 static struct {
 	volatile uint64_t binmap;
 	struct bin bins[BINS_COUNT];
@@ -627,17 +622,15 @@ static void trim(struct chunk *self, size_t n)
 	__bin_chunk(split);
 }
 
-#ifdef HOOK_ENABLE
-void *__libc_malloc(size_t n)
-#else
+#ifndef HOOK_ENABLE
 void *malloc(size_t n)
-#endif
 {
 #ifdef USE_JEMALLOC
 	return je_malloc(n);
 #endif
 	return internal_malloc(n);
 }
+#endif
 
 void *internal_malloc(size_t n)
 {
@@ -1244,17 +1237,15 @@ static void quarantine_bin(struct chunk *self)
 }
 #endif
 
-#ifdef HOOK_ENABLE
-void __libc_free(void *p)
-#else
+#ifndef HOOK_ENABLE
 void free(void *p)
-#endif
 {
 #ifdef USE_JEMALLOC
 	return je_free(p);
 #endif
 	return internal_free(p);
 }
+#endif
 
 void internal_free(void *p)
 {