[Gnash-commit] gnash libbase/gmemory.h libbase/memory.cpp test...

[Rob Savoye]

CVSROOT:        /sources/gnash
Module name:    gnash
Changes by:     Rob Savoye <rsavoye>    08/03/07 18:19:49

Modified files:
        libbase        : gmemory.h memory.cpp 
        testsuite/libbase: memtest.cpp 
        .              : ChangeLog 

Log message:
                * testsuite/libbase/memtest.cpp: Add tests for time stamps.
                * libbase/gmemory.h: Add nano resolutions timestamps.
                * libbase/memory.cpp: Add timestamps so we can test performance
                too.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/gnash/libbase/gmemory.h?cvsroot=gnash&r1=1.1&r2=1.2
http://cvs.savannah.gnu.org/viewcvs/gnash/libbase/memory.cpp?cvsroot=gnash&r1=1.2&r2=1.3
http://cvs.savannah.gnu.org/viewcvs/gnash/testsuite/libbase/memtest.cpp?cvsroot=gnash&r1=1.4&r2=1.5
http://cvs.savannah.gnu.org/viewcvs/gnash/ChangeLog?cvsroot=gnash&r1=1.5842&r2=1.5843

Patches:
Index: libbase/gmemory.h
===================================================================
RCS file: /sources/gnash/gnash/libbase/gmemory.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -b -r1.1 -r1.2
--- libbase/gmemory.h   7 Mar 2008 02:09:32 -0000       1.1
+++ libbase/gmemory.h   7 Mar 2008 18:19:46 -0000       1.2
@@ -31,6 +31,7 @@
 
 #include <stdlib.h>
 #include <malloc.h>
+#include <time.h>
 
 namespace gnash {
   
@@ -40,6 +41,7 @@
     // Borrowed from malloc.h and trimmed down.
     struct small_mallinfo {
         int line;     // line number of this data sample
+       struct timespec stamp;  // the time stamp of this sample
         int arena;    // non-mmapped space allocated from system
         int uordblks; // total allocated space
         int fordblks; // total free space
@@ -77,6 +79,10 @@
     int diffStats();
     int diffStats(int x, int y);
     
+    // Dump the differences in the timestamp between two samples
+    int diffStamp();
+    int diffStamp(int x, int y);
+    
     // Dump the vector of stored classes
     void dump(struct mallinfo *x);
     void dump(struct small_mallinfo *x);

Index: libbase/memory.cpp
===================================================================
RCS file: /sources/gnash/gnash/libbase/memory.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -b -r1.2 -r1.3
--- libbase/memory.cpp  7 Mar 2008 02:09:33 -0000       1.2
+++ libbase/memory.cpp  7 Mar 2008 18:19:47 -0000       1.3
@@ -137,6 +137,7 @@
 //    dump(&mal);
     if ((ptr) && (_index < DATALOG_SIZE)) {
         ptr->line = line;
+       clock_gettime (CLOCK_REALTIME, &ptr->stamp);
         ptr->arena = mal.arena;
         ptr->uordblks = mal.uordblks;
         ptr->fordblks = mal.fordblks;
@@ -177,6 +178,23 @@
     return -1;
 }
     
+// Dump the differences between two samples's timestamp
+int
+Memory::diffStamp()
+{
+//    GNASH_REPORT_FUNCTION;
+    return diffStamp(_index - 1, _index - 2);
+}
+
+int
+Memory::diffStamp(int x, int y)
+{
+//    GNASH_REPORT_FUNCTION;
+    if ((_info) && (x < DATALOG_SIZE) && (y < DATALOG_SIZE)) {
+        return (_info[x].stamp.tv_nsec - _info[y].stamp.tv_nsec);
+    }
+    return -1;
+}    
 
 // Analyze memory usage
 bool
@@ -201,17 +219,37 @@
 
     if (_index > 1) {
         for (int i=1; i<_index; i++) {
-            // See what was allocated between samples
             struct small_mallinfo *ptr = _info + i;
+
+           // Get the time stamp
+            int diff_stamp_sec = (ptr->stamp.tv_sec) - (ptr - 1)->stamp.tv_sec;
+            int diff_stamp_nsec = (ptr->stamp.tv_nsec) - (ptr - 
1)->stamp.tv_nsec;
+//             if ((diff_stamp_sec > 0) || (diff_stamp_nsec > 0)) {
+//             if (ptr->line && (ptr - 1)->line) {
+//                 if (diff_stamp_sec > 0) {
+//                     cerr << "Difference in seconds is: " << diff_stamp_sec;
+//                     cerr << ", nanoseconds is: "<< diff_stamp_nsec;
+//                 }
+//                 else {
+//                     cerr << "Difference in nanoseconds is: "<< 
diff_stamp_nsec;
+//                 }
+//                 cerr << "\tbetween lines: " << (ptr - 1)->line
+//                      << " and " << ptr->line << endl;
+//             } else {
+//                 cerr << "Difference in seconds is: " << diff_stamp_sec
+//                      << ", nanoseconds is: "<< diff_stamp_nsec << endl;
+//             }
+//         }
+           // See what was allocated between samples
             int diff_allocated = (ptr->uordblks) - (ptr - 1)->uordblks;
             if (diff_allocated > 0) {
                 accumulate_allocated += diff_allocated;
                 if (ptr->line && (ptr - 1)->line) {
                     cerr << "Allocated " << diff_allocated
-                         << " bytes Between lines: " << (ptr - 1)->line
-                         << " and " << ptr->line << endl;
+                         << " bytes\tbetween lines: " << (ptr - 1)->line
+                         << " and " << ptr->line;
                 } else {
-                    cerr << "Allocated bytes: " << diff_allocated << endl;
+                    cerr << "Allocated bytes: " << diff_allocated;
                 }
 // same as diff_freed
 //             } else {
@@ -226,10 +264,10 @@
                 accumulate_freed += diff_freed;
                 if (ptr->line && (ptr - 1)->line) {
                     cerr << "Freed " << diff_freed
-                         << " bytes Between lines: " << (ptr - 1)->line
-                         << " and " << ptr->line << endl;
+                         << " bytes between lines: " << (ptr - 1)->line
+                         << " and " << ptr->line;
                 } else {
-                    cerr << "Freed bytes: " << diff_freed << endl;
+                    cerr << "Freed bytes: " << diff_freed;
                 }
 // Same as diif_allocated
 //              } else {
@@ -237,6 +275,16 @@
 //                      cerr << "\tnuked heap bytes: " << diff_freed << endl;
 //                  }
             }
+           if (diff_freed || diff_allocated) {
+               cerr << ", and took " << diff_stamp_nsec << " nanoseconds";
+           } else {
+               cerr << "no allocations, time difference is " << 
diff_stamp_nsec << " nanoseconds";
+                if (ptr->line && (ptr - 1)->line) {
+                         cerr << " between lines: " << (ptr - 1)->line
+                         << " and " << ptr->line;
+               }
+           }
+           cerr << endl;
         }
     } else {
         cerr << "Only have one sample" << endl;
@@ -278,6 +326,12 @@
 {
 //    GNASH_REPORT_FUNCTION;
     cerr << "\tLine number of sample: " << ptr->line << endl;
+    cout.fill('0');
+    cout.width(9);
+    cerr << "\tTimestamp number of sample: " << ptr->stamp.tv_sec
+        << ":" << ptr->stamp.tv_nsec << endl;
+    cout.fill(' ');
+    cout.width(1);
     cerr << "\tNon-mmapped space allocated from system is: \""
          << ptr->arena << "\"" << endl;
     cerr << "\tTotal allocated space  is: \""

Index: testsuite/libbase/memtest.cpp
===================================================================
RCS file: /sources/gnash/gnash/testsuite/libbase/memtest.cpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -b -r1.4 -r1.5
--- testsuite/libbase/memtest.cpp       7 Mar 2008 02:58:15 -0000       1.4
+++ testsuite/libbase/memtest.cpp       7 Mar 2008 18:19:47 -0000       1.5
@@ -75,15 +75,30 @@
     Memory m1;
     mem.addStats(__LINE__);             // take a sample
     diff = mem.diffStats();
-    if ((diff == 16) || (diff == 8)) {
-        runtest.pass("Memory");
+//    cerr << "Memory::Memory: " << diff << endl;
+    if ((diff >= 8) || (diff <= 16)) {
+        runtest.pass("Memory::Memory");
     } else {
-        runtest.fail("Memory");
+        runtest.fail("Memory::Memory");
+    }
+    
+    if (mem.diffStamp() > 0) {
+        runtest.pass("Memory::diffStamp()");
+    } else {
+        runtest.fail("Memory::diffStamp()");
+    }
+
+    if (mem.diffStats() > 0) {
+        runtest.pass("Memory::diffStats()");
+    } else {
+        runtest.fail("Memory::diffStats()");
     }
     
     char *x = new char[120];
     mem.addStats(__LINE__);             // take a sample
-    if ((mem.diffStats() == 104) || (mem.diffStats() == 112)) {
+    diff = mem.diffStats();
+//    cerr << "Buffer allocation: " << diff << endl;
+    if ((diff >= 104) && (diff <= 136)) {
         runtest.pass("Buffer allocation");
     } else {
         runtest.fail("Buffer allocation");
@@ -92,7 +107,9 @@
     vector<string> sv;
     sv.push_back("Hello World");
     mem.addStats(__LINE__);             // take a sample
-    if (mem.diffStats() == 64) {
+    diff = mem.diffStats();
+//    cerr << "First string allocated: " << diff << endl;
+    if ((diff >= 40) && (diff <= 48)) {
         runtest.pass("First string allocated");
     } else {
         runtest.fail("First string allocated");
@@ -101,7 +118,9 @@
     sv.push_back("Aloha");
     delete x;
     mem.addStats(__LINE__);             // take a sample
-    if ((mem.diffStats() == -104) || (mem.diffStats() == -96)) {
+    diff = mem.diffStats();
+//    cerr << "Second string allocated: " << diff << endl;
+    if ((diff >= -104) && (diff <= -96)) {
         runtest.pass("Second string allocated");
     } else {
         runtest.fail("Second string allocated");
@@ -109,7 +128,9 @@
 
     sv.push_back("Guten Tag");
     mem.addStats(__LINE__);             // take a sample
-    if ((mem.diffStats() == 40) || (mem.diffStats() == 32)){
+    diff = mem.diffStats();
+//    cerr << "Third string allocated: " << diff << endl;
+    if ((diff >= 40) && (diff <= 48)){
         runtest.pass("Third string allocated");
     } else {
         runtest.fail("Third string allocated");
@@ -123,7 +144,7 @@
         runtest.pass("leak");
     }    
     mem.addStats(__LINE__);             // take a sample
-    if (mem.diffStats() == 40) {
+    if (mem.diffStats() == 32) {
         runtest.pass("test_leak");
     } else {
         runtest.fail("test_leak");
@@ -137,13 +158,13 @@
     } else {
         runtest.fail("noleak");
     }
-    if ((mem.diffStats() == 0) || (mem.diffStats() == 8)) {
+    diff = mem.diffStats();
+    if ((diff >= 0) && (diff <= 8)) {
         runtest.pass("test_noleak");
     } else {
         runtest.fail("test_noleak");
     }
 
-    
     mem.endStats();
 
 //    mem.dump();    

Index: ChangeLog
===================================================================
RCS file: /sources/gnash/gnash/ChangeLog,v
retrieving revision 1.5842
retrieving revision 1.5843
diff -u -b -r1.5842 -r1.5843
--- ChangeLog   7 Mar 2008 17:14:04 -0000       1.5842
+++ ChangeLog   7 Mar 2008 18:19:48 -0000       1.5843
@@ -1,3 +1,10 @@
+2008-03-07  Rob Savoye  <address@hidden>
+
+       * testsuite/libbase/memtest.cpp: Add tests for time stamps.
+       * libbase/gmemory.h: Add nano resolutions timestamps.
+       * libbase/memory.cpp: Add timestamps so we can test performance
+       too.
+
 2008-03-07 Sandro Santilli <address@hidden>
 
        * server/as_value.cpp (to_debug_string): add class name