commit some useful debug stuff all turned off until needed, trying to get workspace...
authorjjenista <jjenista>
Fri, 29 Oct 2010 18:55:48 +0000 (18:55 +0000)
committerjjenista <jjenista>
Fri, 29 Oct 2010 18:55:48 +0000 (18:55 +0000)
Robust/src/IR/Flat/BuildCode.java
Robust/src/Runtime/memPool.h
Robust/src/Runtime/mlp_runtime.c
Robust/src/Runtime/mlp_runtime.h

index 19e884d6855a79a09234c5a58c5ff4e012fc04ff..a4644c6c8bfc5a262ab860e2bb681af9fb525b29 100644 (file)
@@ -3934,6 +3934,7 @@ public class BuildCode {
       output.println("     "+
                      fsen.getSESErecordName()+"* seseToIssue = ("+
                      fsen.getSESErecordName()+"*) poolalloc( runningSESE->taskRecordMemPool );");
+      output.println("     CHECK_RECORD( seseToIssue );");
     } else {
       output.println("     "+
                      fsen.getSESErecordName()+"* seseToIssue = ("+
index 0662e5fcca5949df2ca016f0910c46edd8b9e566..6c75f647a9f3f85027085d5f2ccbe5b5df5985d5 100644 (file)
@@ -133,6 +133,9 @@ static inline void poolfreeinto( MemPool* p, void* ptr ) {
       printf( "mprotect failed, errno=%d.\n", errno );
     } 
 
+    printf( "itemSize is 0x%x, allocSize is 0x%x, protectSize is 0x%x.\n", (INTPTR)p->itemSize, (INTPTR)p->allocSize, (INTPTR)p->protectSize );
+    printf( "Intended to protect 0x%x to 0x%x,\n\n", (INTPTR)ptr, (INTPTR)ptr + (INTPTR)(p->protectSize) );
+
     exit( -1 );
   }
 }
@@ -148,6 +151,7 @@ static inline void poolfreeinto( MemPool* p, void* ptr ) {
   // set up the now unneeded record to as the tail of the
   // free list by treating its first bytes as next pointer,
   MemPoolItem* tailNew = (MemPoolItem*) ptr;
+
   tailNew->next = NULL;
 
   while( 1 ) {
@@ -180,12 +184,13 @@ static inline void* poolalloc( MemPool* p ) {
   // put the memory we intend to expose to client
   // on a page-aligned boundary, always return
   // new memory
+
   INTPTR nonAligned = (INTPTR) RUNMALLOC( p->allocSize );
 
   void* newRec = (void*)((nonAligned + pageSize-1) & ~(pageSize-1));
 
   //printf( "PageSize is %d or 0x%x.\n", (INTPTR)pageSize, (INTPTR)pageSize );
-  //printf( "itemSize is 0x%x and allocSize is 0x%x.\n", (INTPTR)p->itemSize, (INTPTR)p->allocSize );
+  //printf( "itemSize is 0x%x, allocSize is 0x%x, protectSize is 0x%x.\n", (INTPTR)p->itemSize, (INTPTR)p->allocSize, (INTPTR)p->protectSize );
   //printf( "Allocation returned 0x%x to 0x%x,\n",   (INTPTR)nonAligned, (INTPTR)nonAligned + (INTPTR)(p->allocSize) );
   //printf( "Intend to use       0x%x to 0x%x,\n\n", (INTPTR)newRec,     (INTPTR)newRec     + (INTPTR)(p->itemSize)  );
   
@@ -195,8 +200,6 @@ static inline void* poolalloc( MemPool* p ) {
   topOfRec += p->protectSize - 1;
   ((char*)topOfRec)[0] = 0x1;
 
-
-
   if( p->initFreshlyAllocated != NULL ) {
     p->initFreshlyAllocated( newRec );
   }
index 79be46fbd700e36e4d19f1a96a38725fbdf127ae..9c29d0cec92bfd099cc3e12737dd76944dd3332b 100644 (file)
@@ -25,9 +25,8 @@ void freshTaskRecordInitializer( void* seseRecord ) {
   SESEcommon* c = (SESEcommon*) seseRecord;
   pthread_cond_init( &(c->runningChildrenCond), NULL );
   pthread_mutex_init( &(c->lock), NULL );
-
-  // no need to use return value yet, future maybe
-  //return NULL;
+  c->refCount = 0;
+  //c->fresh = 1;
 }
 
 
index 8af7cfbe1e15c524177a0ff70e8e8805b4b82992..9e9bc98827b9a08ec81b4401e09e39e0cbdaee9d 100644 (file)
@@ -2,6 +2,10 @@
 #define __MLP_RUNTIME__
 
 
+#include <stdlib.h>
+#include <stdio.h>
+
+
 #include <pthread.h>
 #include "runtime.h"
 #include "mem.h"
@@ -10,6 +14,8 @@
 #include "mlp_lock.h"
 #include "memPool.h"
 
+
+
 #ifndef FALSE
 #define FALSE 0
 #endif
@@ -113,7 +119,6 @@ typedef struct SESEcommon_t {
   struct REntry_t* rentryArray[NUMRENTRY];
   struct REntry_t* unresolvedRentryArray[NUMRENTRY];
 
-
 #ifdef RCR
   int offsetToParamRecords;
   volatile int rcrstatus;
@@ -262,16 +267,45 @@ MemoryQueue* createMemoryQueue();
 void rehashMemoryQueue(SESEcommon* seseParent);
 
 
+
+
 static inline void ADD_REFERENCE_TO( SESEcommon* seseRec ) {
   atomic_inc( &(seseRec->refCount) );
 }
 
-static inline void RELEASE_REFERENCE_TO( SESEcommon* seseRec ) {
+static inline int RELEASE_REFERENCE_TO( SESEcommon* seseRec ) {
   if( atomic_sub_and_test( 1, &(seseRec->refCount) ) ) {
     poolfreeinto( seseRec->parent->taskRecordMemPool, seseRec );
+    return 1;
   }
+  return 0;
 }
 
+#define CHECK_RECORD(x) ;
+
+
+////////////////////////////////////////////////
+// 
+//  Some available debug versions of the above
+//  pool allocation-related helpers.  The lower
+//  'x' appended to names means they are not hooked
+//  up, but check em in so we can switch names and
+//  use them for debugging
+//
+////////////////////////////////////////////////
+#define ADD_REFERENCE_TOx(x) atomic_inc( &((x)->refCount) ); printf("0x%x ADD 0x%x on %d\n",(INTPTR)runningSESE,(INTPTR)(x),__LINE__);
+
+#define RELEASE_REFERENCE_TOx(x) if (atomic_sub_and_test(1, &((x)->refCount))) {poolfreeinto(x->parent->taskRecordMemPool, x);printf("0x%x REL 0x%x on %d\n",(INTPTR)runningSESE,(INTPTR)(x),__LINE__);}
+
+#define CHECK_RECORDx(x) { \
+  if( ((SESEcommon*)(x))->refCount != 0 ) {                             \
+    printf( "Acquired 0x%x from poolalloc, with refCount=%d\n", (INTPTR)(x), ((SESEcommon*)(x))->refCount ); } \
+  if( ((SESEcommon*)(x))->fresh != 1 ) {                              \
+    printf("0x%x reclaimed 0x%x on %d\n",(INTPTR)runningSESE,(INTPTR)(x),__LINE__); } \
+  ((SESEcommon*)(x))->fresh = 0; \
+}
+
+
 
 // this is for using a memPool to allocate task records,
 // pass this into the poolcreate so it will run your