Removed memalign crap (just use the malloc hooks).

icculus · Nov 19, 2005 · 5ad03d9 · 5ad03d9
1 parent 43fab47
commit 5ad03d9
Show file tree

Hide file tree

Showing 8 changed files with 1 addition and 76 deletions.
diff --git a/TODO b/TODO
@@ -2,5 +2,4 @@
 - The "[file]" hostname is a bit of a hack.
 - The file/socket seperation is a bit messy.
 - Pause/Unpause memory pattern logging programmatically.
-- Get rid of memalign tracking.
 
diff --git a/monitor_client/malloc_hook_glibc.c b/monitor_client/malloc_hook_glibc.c
@@ -85,7 +85,7 @@ static void *override_memalign_hook(size_t a, size_t s, const void *caller)
     retval = memalign(a, s);  /* call glibc version. */
     save_glibc_hooks();  /* update in case glibc changed them. */
 
-    if (MALLOCMONITOR_put_memalign(a, s, retval))
+    if (MALLOCMONITOR_put_malloc(a, s, retval))
         set_override_hooks(); /* only restore hooks if daemon is listening */
 
     return(retval);

diff --git a/monitor_client/malloc_monitor.h b/monitor_client/malloc_monitor.h
@@ -127,17 +127,6 @@ int MALLOCMONITOR_put_malloc(size_t s, void *rc);
  */
 int MALLOCMONITOR_put_realloc(void *p, size_t s, void *rc);
 
-/*
- * Tell the monitoring daemon that the application just called memalign()
- *  or some variation, like posix_memalign() or valloc().
- *
- *     params : b == multiple of boundary that app wants to align on.
- *              s == number of bytes app wanted to allocate.
- *              rc == what C runtime's memalign() returned.
- *    returns : non-zero if reported to monitor daemon, zero on failure.
- */
-int MALLOCMONITOR_put_memalign(size_t b, size_t s, void *rc);
-
 /*
  * Tell the monitoring daemon that the application just called free()
  *

diff --git a/monitor_client/malloc_monitor_client.c b/monitor_client/malloc_monitor_client.c
@@ -534,19 +534,6 @@ int MALLOCMONITOR_put_realloc(void *p, size_t s, void *rc)
 } /* MALLOCMONITOR_put_realloc */
 
 
-int MALLOCMONITOR_put_memalign(size_t b, size_t s, void *rc)
-{
-    if (!verify_connection()) return(0);
-    if (!daemon_write_operation(MONITOR_OP_MEMALIGN)) return(0);
-    if (!daemon_write_timestamp()) return(0);
-    if (!daemon_write_sizet(b)) return(0);
-    if (!daemon_write_sizet(s)) return(0);
-    if (!daemon_write_ptr(rc)) return(0);
-    if (!daemon_write_callstack()) return(0);
-    return(1);
-} /* MALLOCMONITOR_put_memalign */
-
-
 int MALLOCMONITOR_put_free(void *p)
 {
     if (!verify_connection()) return(0);

diff --git a/monitor_daemon/malloc_monitor_daemon.pl b/monitor_daemon/malloc_monitor_daemon.pl
@@ -373,17 +373,6 @@ sub do_realloc_operation {
     return 1;
 }
 
-sub do_memalign_operation {
-    debug(' + MEMALIGN operation.');
-    my $t = read_ticks(); return 0 if (not defined $t);
-    my $b = read_sizet(); return 0 if (not defined $b);
-    my $s = read_sizet(); return 0 if (not defined $s);
-    my $rc = read_ptr(); return 0 if (not defined $rc);
-    my $c = read_callstack(); return 0 if (not defined $c);
-    # !!! FIXME: do something.
-    return 1;
-}
-
 sub do_free_operation {
     debug(' + FREE operation.');
     my $t = read_ticks(); return 0 if (not defined $t);
@@ -401,7 +390,6 @@ sub do_operation {
     return do_goodbye_operation() if ($op == MONITOR_OP_GOODBYE);
     return do_malloc_operation() if ($op == MONITOR_OP_MALLOC);
     return do_realloc_operation() if ($op == MONITOR_OP_REALLOC);
-    return do_memalign_operation() if ($op == MONITOR_OP_MEMALIGN);
     return do_free_operation() if ($op == MONITOR_OP_FREE);
 
     debug("Unknown operation $op");

diff --git a/visualize/dumpfile.cpp b/visualize/dumpfile.cpp
@@ -198,7 +198,6 @@ void FragMapManager::walk_fragmap(DumpFile *df, size_t startop, size_t endop)
         {
             case DUMPFILE_OP_MALLOC: hash_malloc(op); break;
             case DUMPFILE_OP_REALLOC: hash_realloc(op); break;
-            case DUMPFILE_OP_MEMALIGN: hash_memalign(op); break;
             case DUMPFILE_OP_FREE: hash_free(op); break;
             default: assert(0 && "unknown dumpfile operation!"); break;
         } // switch
@@ -528,12 +527,6 @@ inline void FragMapManager::hash_realloc(DumpFileOperation *op)
 } // FragMapManager::hash_realloc
 
 
-inline void FragMapManager::hash_memalign(DumpFileOperation *op)
-{
-    insert_block(op->op_memalign.retval, op->op_memalign.size);
-} // FragMapManager::hash_memalign
-
-
 inline void FragMapManager::hash_free(DumpFileOperation *op)
 {
     remove_block(op->op_free.ptr);
@@ -555,13 +548,6 @@ void FragMapManager::add_realloc(DumpFileOperation *op)
 } // FragMapManager::add_realloc
 
 
-void FragMapManager::add_memalign(DumpFileOperation *op)
-{
-    hash_memalign(op);
-    increment_operations();
-} // FragMapManager::add_memalign
-
-
 void FragMapManager::add_free(DumpFileOperation *op)
 {
     hash_free(op);
@@ -838,14 +824,6 @@ void DumpFile::parse(const char *fn, ProgressNotify &pn) throw (const char *)
                         fragmapManager.add_realloc(op);
                         break;
 
-                    case DUMPFILE_OP_MEMALIGN:
-                        //printf("memalign\n");
-                        read_sizet(op->op_memalign.boundary);
-                        read_sizet(op->op_memalign.size);
-                        read_ptr(op->op_memalign.retval);
-                        fragmapManager.add_memalign(op);
-                        break;
-
                     case DUMPFILE_OP_FREE:
                         //printf("free\n");
                         read_sizet(op->op_free.ptr);

diff --git a/visualize/dumpfile.h b/visualize/dumpfile.h
@@ -127,13 +127,6 @@ class DumpFileOperation
             dumpptr retval;
         } op_realloc;
 
-        struct
-        {
-            dumpptr boundary;
-            dumpptr size;
-            dumpptr retval;
-        } op_memalign;
-
         struct
         {
             dumpptr ptr;
@@ -245,7 +238,6 @@ class FragMapManager
     ~FragMapManager();
     void add_malloc(DumpFileOperation *op);
     void add_realloc(DumpFileOperation *op);
-    void add_memalign(DumpFileOperation *op);
     void add_free(DumpFileOperation *op);
     void done_adding(ProgressNotify &pn);
     FragMapNode **get_fragmap(DumpFile *df, size_t operation_index, size_t &nodecount);
@@ -263,7 +255,6 @@ class FragMapManager
     inline void hash_snapshot(FragMapSnapshot *snapshot);
     inline void hash_malloc(DumpFileOperation *op);
     inline void hash_realloc(DumpFileOperation *op);
-    inline void hash_memalign(DumpFileOperation *op);
     inline void hash_free(DumpFileOperation *op);
     void walk_fragmap(DumpFile *df, size_t startop, size_t endop);
 

diff --git a/visualize/stats.cpp b/visualize/stats.cpp
@@ -85,13 +85,6 @@ int main(int argc, char **argv)
                                (int) op->op_realloc.retval);
                         break;
 
-                    case DUMPFILE_OP_MEMALIGN:
-                        printf("memalign(%d, %d), returned 0x%X\n",
-                               (int) op->op_memalign.boundary,
-                               (int) op->op_memalign.size,
-                               (int) op->op_memalign.retval);
-                        break;
-
                     case DUMPFILE_OP_FREE:
                         printf("free(0x%X)\n",
                                (int) op->op_free.ptr);