Changeset 11290355 in rtems for c/src/lib/libc

Timestamp:

09/29/95 17:19:16 (27 years ago)

Author:

Joel Sherrill <joel.sherrill@…>

Branches:

4.10, 4.11, 4.8, 4.9, 5, master

Children:

1ceface

Parents:

1039ae4

Message:

all targets compile .. tony's patches in place

Location:

c/src/lib/libc

Files:

• error.c (modified) (1 diff)
• malloc.c (modified) (14 diffs)

c/src/lib/libc/error.c

@@ -40 +40 @@
  *        if ((fd = open(pathname, O_RDNLY)) < 0)
  *        {
- *            rtems_error(FLOSS_ERROR_ERRNO, "open of '%s' failed", pathname);
+ *            rtems_error(RTEMS_ERROR_ERRNO, "open of '%s' failed", pathname);
  *            goto failed;
  *        }

c/src/lib/libc/malloc.c

@@ -15 +15 @@
 
 #include <rtems.h>
-#ifdef RTEMS_LIBC
-#include <memory.h>
-#endif
 #include "libcsupport.h"
 #ifdef RTEMS_NEWLIB
@@ -30 +27 @@
 #include <string.h>
 
-/* 
- *  XXX: Do we really need to duplicate these? It appears that they
- *       only cause typing problems.
- */
-
-#if 0
-void *malloc(size_t);
-void *calloc(size_t, size_t);
-void *realloc(void *, size_t);
-void free(void *);
-void *sbrk(size_t);
-#endif
-
 rtems_id RTEMS_Malloc_Heap;
 size_t RTEMS_Malloc_Sbrk_amount;
+
+#ifdef RTEMS_DEBUG
+#define MALLOC_STATS
+#endif
+
+#ifdef MALLOC_STATS
+#define MSBUMP(f,n)    malloc_stats.f += (n)
+
+struct {
+    unsigned32  space_available;             /* current size of malloc area */
+    unsigned32  malloc_calls;                /* # calls to malloc */
+    unsigned32  free_calls;
+    unsigned32  realloc_calls;
+    unsigned32  calloc_calls;
+    unsigned32  max_depth;                   /* most ever malloc'd at 1 time */
+    unsigned64  lifetime_allocated;
+    unsigned64  lifetime_freed;
+} malloc_stats;
+
+#else                   /* No malloc_stats */
+#define MSBUMP(f,n)
+#endif
 
 void RTEMS_Malloc_Initialize(
@@ -78 +84 @@
       u32_address = (u32_address + CPU_ALIGNMENT) & ~(CPU_ALIGNMENT-1);
 
-      /*
-       *  Adjust the length by whatever we aligned by
-       */
+       /*
+        * adjust the length by whatever we aligned by
+        */
 
       length -= u32_address - old_address;
@@ -98 +104 @@
     starting_address,
     length,
-    8,                     /* XXX : use CPU dependent RTEMS constant */
+    CPU_ALIGNMENT,
     RTEMS_DEFAULT_ATTRIBUTES,
     &RTEMS_Malloc_Heap
@@ -104 +110 @@
   if ( status != RTEMS_SUCCESSFUL )
     rtems_fatal_error_occurred( status );
+
+#ifdef MALLOC_STATS
+  /* zero all the stats */
+  (void) memset(&malloc_stats, 0, sizeof(malloc_stats));
+#endif
+  
+  MSBUMP(space_available, length);
 }
 
@@ -115 +128 @@
   rtems_unsigned32   sbrk_amount;
   rtems_status_code  status;
+
+  MSBUMP(malloc_calls, 1);
 
   if ( !size )
@@ -150 +165 @@
       return (void *) 0;
 
-    /*
-    fprintf(stderr, "Extended the C heap starting at 0x%x for %d bytes\n",
-        (unsigned32)starting_address, the_size);
-     */
-
     status = rtems_region_extend(
       RTEMS_Malloc_Heap,
@@ -162 +172 @@
     if ( status != RTEMS_SUCCESSFUL ) {
       sbrk(-the_size);
-      return(FALSE);
       errno = ENOMEM;
       return (void *) 0;
     }
+    
+    MSBUMP(space_available, the_size);
+
     status = rtems_region_get_segment(
       RTEMS_Malloc_Heap,
@@ -179 +191 @@
   }
 
+#ifdef MALLOC_STATS
+  if (return_this)
+  {
+      unsigned32 current_depth;
+      MSBUMP(lifetime_allocated, size);
+      current_depth = malloc_stats.lifetime_allocated - malloc_stats.lifetime_freed;
+      if (current_depth > malloc_stats.max_depth)
+          malloc_stats.max_depth = current_depth;
+  }
+#endif
+  
   return return_this;
 }
@@ -189 +212 @@
   register char *cptr;
   int length;
+
+  MSBUMP(calloc_calls, 1);
 
   length = nelem * elsize;
@@ -207 +232 @@
   char *new_area;
 
+  MSBUMP(realloc_calls, 1);
+
   if ( !ptr )
     return malloc( size );
 
   if ( !size ) {
+    free( ptr );
+    return (void *) 0;
+  }
+
+  new_area = malloc( size );
+  if ( !new_area ) {
     free( ptr );
     return (void *) 0;
@@ -221 +254 @@
   }
 
-  new_area = malloc( size );
-  if ( !new_area ) {
-    free( ptr );
-    return (void *) 0;
-  }
-
   memcpy( new_area, ptr, (size < old_size) ? size : old_size );
   free( ptr );
@@ -240 +267 @@
   rtems_status_code status;
 
+  MSBUMP(free_calls, 1);
+
   if ( !ptr )
     return;
 
+#ifdef MALLOC_STATS
+  {
+      unsigned32        size;
+      status = rtems_region_get_segment_size( RTEMS_Malloc_Heap, ptr, &size );
+      if ( status == RTEMS_SUCCESSFUL ) {
+          MSBUMP(lifetime_freed, size);
+      }
+  }
+#endif
+  
   status = rtems_region_return_segment( RTEMS_Malloc_Heap, ptr );
   if ( status != RTEMS_SUCCESSFUL ) {
@@ -250 +289 @@
 }
 
+#ifdef MALLOC_STATS
+/*
+ * Dump the malloc statistics
+ * May be called via atexit()  (installable by our bsp) or
+ * at any time by user
+ */
+
+void malloc_dump(void)
+{
+    unsigned32 allocated = malloc_stats.lifetime_allocated - malloc_stats.lifetime_freed;
+
+    printf("Malloc stats\n");
+    printf("  avail:%uk  allocated:%uk (%d%%) max:%uk (%d%%) lifetime:%Luk freed:%Luk\n",
+           (unsigned int) malloc_stats.space_available / 1024,
+           (unsigned int) allocated / 1024,
+           /* avoid float! */
+           (allocated * 100) / malloc_stats.space_available,
+           (unsigned int) malloc_stats.max_depth / 1024,
+           (malloc_stats.max_depth * 100) / malloc_stats.space_available,
+           (unsigned long long) malloc_stats.lifetime_allocated / 1024,
+           (unsigned long long) malloc_stats.lifetime_freed / 1024);
+    printf("  Call counts:   malloc:%d   free:%d   realloc:%d   calloc:%d\n",
+           malloc_stats.malloc_calls,
+           malloc_stats.free_calls,
+           malloc_stats.realloc_calls,
+           malloc_stats.calloc_calls);
+}        
+#endif
+
 /*
  *  "Reentrant" versions of the above routines implemented above.