[IMPROVE] malloc call optimization

Change-Id: Ieee2262d8a070a38449459c0aaaa25ddfdf7b042
Signed-off-by: Vitaliy Cherepanov <v.cherepanov@samsung.com>

diff --git a/helper/dacollection.c b/helper/dacollection.c
index d46d574741908f352bf3c25214029069e3a12a28..b807238864ae90c45f0ca6be456e92d6ff5fc4ac 100755 (executable)
--- a/helper/dacollection.c
+++ b/helper/dacollection.c
@@ -226,7 +226,7 @@ int add_symbol_hash(void* ptr, const char* str, int strlen)
        k = kh_put(symbol, SYMBOLHASH, (uint32_t)ptr, &rethash);
        if (likely(rethash != 0))       // succeed to add in hash table
        {
-               char* tlast = (char*)malloc(strlen);
+               char* tlast = (char*)real_malloc(strlen);
                if (likely(tlast != NULL))
                {
                        memcpy(tlast, str, strlen);
@@ -409,7 +409,7 @@ int add_uiobject_hash_class(void* ptr, const char* classname)
                {
                        if (kh_value(UIOBJECTHASH, k)->name == NULL)
                        {
-                               char* tlast = (char*)malloc(str_len);
+                               char* tlast = (char*)real_malloc(str_len);
                                if (likely(tlast != NULL))
                                {
                                        memcpy(tlast, classname, str_len);
@@ -469,7 +469,7 @@ int add_uiobject_hash_type(void* ptr, const char* type)
                {
                        kh_value(UIOBJECTHASH, k) = newentry;
 
-                       tlast = (char*)malloc(str_len);
+                       tlast = (char*)real_malloc(str_len);
                        if (likely(tlast != NULL))
                        {
                                memcpy(tlast, type, str_len);
@@ -748,11 +748,11 @@ int add_to_glist(char* key, void* data)
        elm = find_element(key);
        if (elm == NULL)
        {
-               elm = (element_t*)malloc(sizeof(element_t));
+               elm = (element_t*)real_malloc(sizeof(element_t));
                if (likely(elm != NULL))
                {
                        elm->keylen = strlen(key);
-                       elm->keystr = (char*)malloc(elm->keylen + 1);
+                       elm->keystr = (char*)real_malloc(elm->keylen + 1);
                        if (likely(elm->keystr != NULL))
                        {
                                strcpy(elm->keystr, key);

diff --git a/helper/libdaprobe.c b/helper/libdaprobe.c
index 815c84c81fae5cb202d1895e6e350818c8068409..b670c6182f5fd2a0a790b1a425f978a78b1170e0 100755 (executable)
--- a/helper/libdaprobe.c
+++ b/helper/libdaprobe.c
@@ -78,6 +78,9 @@ int log_fd = 0;
 int getExecutableMappingAddress();
 
 bool printLog(log_t* log, int msgType);
+
+void *(*real_malloc)(size_t) = NULL;
+
 /******************************************************************************
  * internal functions
    (this means that these functions do not need to set enter/exit flag)
@@ -381,6 +384,9 @@ static int create_recv_thread()
 void _init_(void)
 {
        char msg[DA_LOG_MAX];
+
+       rtdl_next_set_once(real_malloc, "malloc");
+
        probeBlockStart();
 
        init_exec_fork();
@@ -826,3 +832,21 @@ int update_heap_memory_size(bool isAdd, size_t size)
 
        return 0;
 }
+
+/* rtdl_next */
+void *rtdl_next(const char *symname)
+{
+       void *symbol;
+
+       probeBlockStart();
+
+       symbol = dlsym(RTLD_NEXT, symname);
+       if (symbol == NULL || dlerror() != NULL) {
+               fprintf(stderr, "dlsym failed <%s>\n", symname);
+               exit(41);
+       }
+
+       probeBlockEnd();
+
+       return symbol;
+}

diff --git a/include/binproto.h b/include/binproto.h
index ca06132a4f5940472a1a3d3499128e91916422fb..3761efc057da702f47c92dd4a2bec34a02a938bf 100644 (file)
--- a/include/binproto.h
+++ b/include/binproto.h
@@ -488,7 +488,7 @@ static char __attribute__((used)) *pack_ret(char *to, char ret_type, ...)
 /* TODO maloc/free for each event turns out expensive: think of buffer
  * allocator implementation */
 #define PREPARE_LOCAL_BUF()                    \
-               char *LOCAL_BUF = (char *)malloc(MAX_LOCAL_BUF_SIZE);   \
+               char *LOCAL_BUF = (char *)(*real_malloc)(MAX_LOCAL_BUF_SIZE);   \
                char *BUF_PTR = LOCAL_BUF;                      \
                char *RET_PTR = NULL
 

diff --git a/include/dahelper.h b/include/dahelper.h
index c136dfc1e9b5e9ed98c9a17d735806d441829194..e2b16b46199945046cd4fa7dd79d01931e93fec1 100755 (executable)
--- a/include/dahelper.h
+++ b/include/dahelper.h
@@ -206,6 +206,9 @@ int get_map_address(void* symbol, void** map_start, void** map_end);
 char** da_backtrace_symbols (void* const* array, int size);
 char** cached_backtrace_symbols (void* const* array, int size);
 
+/* real malloc function pointer */
+extern void *(*real_malloc)(size_t);
+
 /* pid/tid values */
 pid_t _getpid();
 pid_t _gettid();

diff --git a/include/daprobe.h b/include/daprobe.h
index 1c012496e724a9bef353be925572a2e7f9a66e6e..cfe14e800af3c7d808bcc7e86ce4977dd7ce8f5e 100644 (file)
--- a/include/daprobe.h
+++ b/include/daprobe.h
@@ -121,6 +121,8 @@ bool printLog(log_t* log, int msgType);
 int __appendTypeLog(log_t* log, int nInput, char* token, ...);
 int getBacktraceString(log_t* log, int bufsize);
 
+void *rtdl_next(const char *symname);
+
 //char* captureScreenShotX(int* width, int* height);
 //void releaseScreenShotX();
 
@@ -138,6 +140,17 @@ int getBacktraceString(log_t* log, int bufsize);
  * helper macros
  ***************************************************************************/
 
+// ============================ rtdl ===============================
+
+#define rtdl_next_set_once(symbol, sname)              \
+       do {                                            \
+               if (symbol == NULL)                     \
+                       symbol = rtdl_next(sname);      \
+       } while (0)
+
+#define rtdl_next_current_set_once(symbol)     \
+       rtdl_next_set_once(symbol, __func__)
+
 // ========================= print log =====================================
 #define PRINTMSG(...)  print_log_fmt(MSG_MSG, __FUNCTION__, __LINE__, __VA_ARGS__)
 #define PRINTWRN(...)  print_log_fmt(MSG_WARNING, __FUNCTION__, __LINE__, __VA_ARGS__)

diff --git a/probe_memory/libdamemalloc.c b/probe_memory/libdamemalloc.c
index 1e4fa99b52953458031159212c2b67cdd3912667..4086a24749d8721007a982f825e0a716d4cfb400 100755 (executable)
--- a/probe_memory/libdamemalloc.c
+++ b/probe_memory/libdamemalloc.c
@@ -48,39 +48,13 @@
 
 static enum DaOptions _sopt = OPT_ALLOC;
 
-static void *rtdl_next(const char *symname)
-{
-       void *symbol;
-
-       probeBlockStart();
-
-       symbol = dlsym(RTLD_NEXT, symname);
-       if (symbol == NULL || dlerror() != NULL) {
-               fprintf(stderr, "dlsym failed <%s>\n", symname);
-               exit(41);
-       }
-
-       probeBlockEnd();
-
-       return symbol;
-}
-
-static void rtdl_next_set_once(void **symbol, const char *symname)
-{
-       if (*symbol)
-               return;
-       *symbol = rtdl_next(symname);
-}
-#define rtdl_next_current_set_once(symbol) \
-       rtdl_next_set_once((void **)(symbol), __func__)
-
 void *malloc(size_t size)
 {
        static void* (*mallocp)(size_t);
        DECLARE_VARIABLE_STANDARD;
        void *pret;
 
-       rtdl_next_current_set_once(&mallocp);
+       rtdl_next_current_set_once(mallocp);
 
        PRE_PROBEBLOCK();
 
@@ -110,7 +84,7 @@ void free(void *ptr)
        static void (*freep)(void *);
        DECLARE_VARIABLE_STANDARD;
 
-       rtdl_next_current_set_once(&freep);
+       rtdl_next_current_set_once(freep);
 
        PRE_PROBEBLOCK();
 
@@ -137,7 +111,7 @@ void *realloc(void *memblock, size_t size)
        DECLARE_VARIABLE_STANDARD;
        void *pret;
 
-       rtdl_next_current_set_once(&reallocp);
+       rtdl_next_current_set_once(reallocp);
        PRE_PROBEBLOCK();
 
        if(memblock != NULL && gProbeBlockCount == 0)