Changeset 31591 for branches/eam_branches/ipp-20110505/Ohana

Timestamp:

May 31, 2011, 3:50:46 PM (15 years ago)

Author:

eugene

Message:

added test for ohana_memory functions; updated CommandOps to fix interaction between ohana and readline; ohana memory seems to work

Location:

branches/eam_branches/ipp-20110505/Ohana/src

Files:

• libohana/Makefile (modified) (1 diff)
• libohana/include/ohana.h (modified) (1 diff)
• libohana/include/ohana_allocate.h (modified) (2 diffs)
• libohana/src/ohana_allocate.c (modified) (6 diffs)
• libohana/test/memtest.c (added)
• opihi/lib.shell/CommandOps.c (modified) (2 diffs)

branches/eam_branches/ipp-20110505/Ohana/src/libohana/Makefile

@@ -50 +50 @@
 
 TEST = \
-$(TESTDIR)/string.$(ARCH)
+$(TESTDIR)/memtest.$(ARCH)
+# $(TESTDIR)/string.$(ARCH)
 
 testcode: install $(TEST)
 test:
         make testcode
+        for i in $(TEST); do $$i; done
+
+quicktest: 
         for i in $(TEST); do $$i; done
 

branches/eam_branches/ipp-20110505/Ohana/src/libohana/include/ohana.h

@@ -19 +19 @@
 # include <readline/readline.h>
 
+// comment this out to avoid the internal Ohana memory management code
 # define OHANA_MEMORY
 

branches/eam_branches/ipp-20110505/Ohana/src/libohana/include/ohana_allocate.h

@@ -1 +1 @@
 # ifndef OHANA_ALLOCATE
 # define OHANA_ALLOCATE
+
+typedef struct {
+  int    exists; // has the memory management system been created?
+  size_t Ntotal; // number of blocks currently allocated
+  size_t Nbytes; // number of bytes currently allocated
+  size_t Ngood;  // number of good blocks
+  size_t Nbad;   // number of bad blocks
+} OhanaMemstats;
+
+OhanaMemstats ohana_memstats (int mode);
 
 /* default is to use basic system memory functions */
 # ifdef OHANA_MEMORY
 
-void *ohana_malloc (char *file, int line, char *func, int Nelem, size_t esize);
-void *ohana_realloc (char *file, int line, char *func, void *in, int Nelem, size_t esize);
-void  ohana_free (char *file, int line, char *func, void *in);
+void *ohana_malloc (const char *file, int line, const char *func, int Nelem, size_t esize);
+void *ohana_realloc (const char *file, int line, const char *func, void *in, int Nelem, size_t esize);
+void  ohana_free (const char *file, int line, const char *func, void *in);
 void  ohana_memdump_func (int mode);
 void  ohana_memcheck_func (int mode);
+void  real_free (void *in);
 
 # define ohana_memcheck(X) ohana_memcheck_func (X);
 # define ohana_memdump(X) ohana_memdump_func (X);
 
-# define ALLOCATE(PTR,TYPE,SIZE) \
-  { PTR = (TYPE *) ohana_malloc (__FILE__, __LINE__, __func__, (SIZE), sizeof(TYPE)) }
-# define ALLOCATE_ZERO(PTR,TYPE,SIZE)                                   \
-  { PTR = (TYPE *) ohana_malloc (__FILE__, __LINE__, __func__, (SIZE), sizeof(TYPE)); memset (PTR, 0, (SIZE)*sizeof(TYPE)); }
-# define REALLOCATE(PTR,TYPE,SIZE) \
-  { PTR = (TYPE *) ohana_realloc(__FILE__, __LINE__, __func__, PTR, (SIZE), sizeof(TYPE)); }
-# define CHECK_REALLOCATE(PTR,TYPE,SIZE,NCURR,DELTA) {                  \
-  if ((NCURR) >= (SIZE)) { SIZE += DELTA;                               \
-    PTR = (TYPE *) ohana_realloc(__FILE__, __LINE__, __func__, PTR, (SIZE), sizeof(TYPE)); } }
+# define ALLOCATE(PTR,TYPE,SIZE) { \
+    PTR = (TYPE *) ohana_malloc (__FILE__, __LINE__, __func__, (SIZE), sizeof(TYPE)); \
+  }
+
+# define ALLOCATE_ZERO(PTR,TYPE,SIZE) { \
+    PTR = (TYPE *) ohana_malloc (__FILE__, __LINE__, __func__, (SIZE), sizeof(TYPE)); \
+    memset (PTR, 0, (SIZE)*sizeof(TYPE)); \
+  }
+
+# define REALLOCATE(PTR,TYPE,SIZE) { \
+    PTR = (TYPE *) ohana_realloc(__FILE__, __LINE__, __func__, PTR, (SIZE), sizeof(TYPE)); \
+  }
+
+# define CHECK_REALLOCATE(PTR,TYPE,SIZE,NCURR,DELTA) { \
+  if ((NCURR) >= (SIZE)) { \
+    SIZE += DELTA; \
+    PTR = (TYPE *) ohana_realloc(__FILE__, __LINE__, __func__, PTR, (SIZE), sizeof(TYPE)); \
+  } }
+
 # define FREE(PTR) { if (PTR != NULL) { ohana_free (__FILE__, __LINE__, __func__, PTR); } }
-# define free(PTR) { ohana_free(__FILE__, __LINE__, PTR); }
-# define real_free(PTR) { if (PTR) { free(PTR); }}
+# define free(PTR) { ohana_free(__FILE__, __LINE__, __func__, PTR); }
 
-# else  /* OHANA_MEMORY */
+# else  /* below: not OHANA_MEMORY */
 
 # define ohana_memcheck(X) /* NOP */
 # define ohana_memdump(X) /* NOP */
-# define real_free(PTR) { if (PTR) { free(PTR); }}
+void  real_free (void *in);
 
-# ifndef ALLOCATE
 # define ALLOCATE(PTR,TYPE,SIZE) {                                      \
   PTR = (TYPE *) malloc ((size_t)(MAX(((SIZE)*((int)sizeof(TYPE))),1))); \
@@ -62 +81 @@
 
 # define FREE(PTR) { if (PTR != NULL) { free (PTR); } }
-# endif /* ALLOCATE */
 # endif /* OHANA_MEMORY */
 

branches/eam_branches/ipp-20110505/Ohana/src/libohana/src/ohana_allocate.c

@@ -4 +4 @@
 # include <stdint.h>
 # include <pthread.h>
+# include "ohana_allocate.h"
 
 /* need an internal version that does not use ohana_memory functions */
@@ -17 +18 @@
   struct Memblock *nextBlock; // next allocated memory
   size_t size;                // size of memory
-  char *file;                 // file (re)allocated 
-  char *func;                 // func (re)allocated 
+  const char *file;           // file (re)allocated 
+  const char *func;           // func (re)allocated 
   int line;                   // line (re)allocated
   uint32_t endblock;          // endpost marker
@@ -40 +41 @@
 }
 
-void *ohana_malloc (char *file, int line, char *func, size_t Nelem, size_t esize) {
+void *ohana_malloc (const char *file, int line, const char *func, size_t Nelem, size_t esize) {
 
   void *ptr;                  // actual user memory allocated
@@ -94 +95 @@
 }
 
-void *ohana_realloc (char *file, int line, char *func, void *in, size_t Nelem, size_t esize) {
+void *ohana_realloc (const char *file, int line, const char *func, void *in, size_t Nelem, size_t esize) {
 
   void *ptr;                  // actual user memory allocated
@@ -158 +159 @@
 }
 
+void real_free (void *in) {
+
+  if (!in) return;
+  free (in);
+  return;
+}
+
 // this is very slow.  should we speed this up by indexing on the ptr?
-void ohana_free (char *file, int line, char *func, void *in) {
+void ohana_free (const char *file, int line, const char *func, void *in) {
 
   Memblock *ref;
@@ -278 +286 @@
   return;
 }
+
+OhanaMemstats ohana_memstats (int allmemory) {
+
+  OhanaMemstats memstats;
+
+  memstats.exists = 0;
+  memstats.Ntotal = 0;
+  memstats.Nbytes = 0;
+  memstats.Ngood = 0;
+  memstats.Nbad = 0;
+  
+  Memblock *thisBlock = lastBlock;
+
+  while (thisBlock) {
+
+    memstats.exists = TRUE;
+
+    int good = TRUE;
+    
+    if (thisBlock->startblock != OHANA_MEMMAGIC) good = FALSE;
+    if (thisBlock->endblock != OHANA_MEMMAGIC) good = FALSE;
+
+    // pointer to the start of the user memory
+    char *ptr = (char *)(thisBlock + 1) + thisBlock->size;
+    uint32_t endpost = *(uint32_t *)ptr;
+    if (endpost != OHANA_MEMMAGIC) good = FALSE;
+
+    memstats.Ntotal ++;
+    memstats.Nbytes += thisBlock->size;
+
+    if (good) {
+      memstats.Ngood ++;
+    } else {
+      memstats.Nbad ++;
+    }
+
+    thisBlock = thisBlock->prevBlock;
+  }
+
+  return memstats;
+}

branches/eam_branches/ipp-20110505/Ohana/src/opihi/lib.shell/CommandOps.c

@@ -106 +106 @@
 }  
 
+/* we need a strcreate function that does NOT use the ohana memory management
+ * system to interact with some external libraries (which themselves free the memory)
+ */
+char *strcreate_sans_ohana (char *string) {
+
+  char *line;
+
+  if (string == (char *) NULL) return ((char *) NULL);
+  
+  line = malloc (MAX (1, strlen(string)) + 1);
+  line = strcpy (line, string);
+
+  return (line);
+}
+
 /* generate a command completion list for readline */
 /**** these probably do not interact well with OHANA memory!!! ****/
@@ -122 +137 @@
   for (i++; i < Ncommands; i++) {
     if (!len) 
-      return (strcreate(commands[i].name));
+
+
+      return (strcreate_sans_ohana(commands[i].name));
     if (!strncmp (commands[i].name, text, len)) {
-      return (strcreate(commands[i].name));
+      return (strcreate_sans_ohana(commands[i].name));
     }
   }