Changeset 416 for trunk/libs

Timestamp:

Jan 4, 2018, 10:05:47 AM (7 years ago)

Author:

alain

Message:

Improve sys_exec.

Location:

trunk/libs

Files:

• malloc.c (modified) (4 diffs)
• malloc.h (modified) (4 diffs)
• stdlib.c (modified) (1 diff)

trunk/libs/malloc.c

@@ -107 +107 @@
 // It uses the mmap( MAP_REMOTE ) syscall to allocate a new vseg mapped in cluster (cxy).
 ////////////////////////////////////////////////////////////////////i//////////////////////
-// @ cxy       : target cluster identifier (fixed format).
-// @ size      : store size (bytes).
+// @ cxy        : target cluster identifier (fixed format).
+// @ store_size : store size (bytes).
 // # return without setting the initialized field in store(cxy) if failure.
 ////////////////////////////////////////////////////////////////////i//////////////////////
@@ -185 +185 @@
     }
 
-    // reset the alloc_size array
+    // DEPRECATED: we don't reset the alloc_size array 
+    // because we don't want to allocate the physical memory
+    // when the heap is created  [AG]
     // memset( (void *)alloc_base , 0 , alloc_size ); 
  
@@ -216 +218 @@
     store[cxy].initialized = MALLOC_INITIALIZED;
 
+
 #if MALLOC_DEBUG
-printf("\n[MALLOC] %s completes store[%x] initialisation\n",
+printf("\n[MALLOC] %s : completes store[%x] initialisation\n",
 __FUNCTION__, cxy );
+
+display_free_array( cxy );
 #endif
 
@@ -344 +349 @@
     unsigned char * ptr    = (unsigned char*)(store[cxy].alloc_base + offset);
 
-    // check the alloc[] array
-    if ( *ptr != 0 )
-    {
-        pthread_mutex_unlock( &store[cxy].mutex );
-        printf("\n[PANIC] in %s : allocate an already allocated block...\n",
-        __FUNCTION__ );
-        return NULL;
-    }
+    // DEPRECATED : we don't check the alloc[] array,
+    // because it has not been initialised, to avoid 
+    // physical memory allocation at heap creation [AG]
+    // if ( *ptr != 0 )
+    // {
+    //    pthread_mutex_unlock( &store[cxy].mutex );
+    //    printf("\n[PANIC] in %s : allocate an already allocated block...\n",
+    //    __FUNCTION__ );
+    //    return NULL;
+    // }
 
     // update alloc_array

trunk/libs/malloc.h

@@ -24 +24 @@
 ////////////////////////////////////////////////////////////////////////////////
 // General principles:
-// - In user space this HEAP zone has a fixed size, that spread between the
-//   ELF zone and the STACK zone.
+// - In user space the HEAP zone spread between the ELF zone and the STACK zone,
+//   as defined in the kernel_config.h file.
 // - The malloc library uses the mmap() syscall to create - on demand -
-//   up to one vseg per cluster. The size of these vsegs is defined by the
-//   MALLOC_LOCAL_STORAGE_SIZE parameter.
-// - For a standard malloc(), the target cluster is the cluster of the client
-//   thread. For a remote_malloc(), the target cluster is explicitely defined
-//   by the arguments.
+//   one vseg in a given cluster. The size of this vseg is defined below
+//   by the MALLOC_LOCAL_STORE_SIZE parameter.
+// - For a standard malloc(), the target cluster is the cluster containing
+//   the core running the client thread.
+// - For a remote_malloc(), the target cluster is explicitely defined
+//   by the argument.
 // - In each cluster, the available storage in virtual space is handled by a
 //   local allocator using the buddy algorithm.
-// TODO : introduce the possibility to use a list of vsegs in each cluster...  
+//
+// TODO : In this first implementation one single - fixed size - vseg 
+//        is allocated on demand in each cluster.
+//        We should introduce the possibility to dynamically allocate
+//        several vsegs in each cluster, using several mmap when required. 
 ////////////////////////////////////////////////////////////////////////////////
 // Free blocks organisation in each cluster :
@@ -43 +48 @@
 //   given list have the same size. 
 // - The NEXT pointer implementing those linked lists is written 
-//   in the 4 first bytes of the block itself, using the unsigned int type.
+//   in the first bytes of the block itself, using the unsigned int type.
 // - The pointers on the first free block for each size are stored in an
-//   array of pointers free[32] in the stotrage(x,y) descriptor.
+//   array of pointers free[32] in the storage(x,y) descriptor.
 ////////////////////////////////////////////////////////////////////////////////
 // Allocation policy:
@@ -56 +61 @@
 //   and returns the block B if the list[actual_size] is not empty.
 // - If the list[actual_size] is empty, it pop the list[actual_size * 2].
-//   If a block B' is found, it break this block in 2 B/2 blocks, returns 
+//   If a block B' is found, it breaks this block in 2 B/2 blocks, returns 
 //   the first B/2 block and push the other B/2 block into list[actual_size].
 // - If the list[actual_size * 2] is empty, it pop the list[actual_size * 4].
@@ -73 +78 @@
 //   of the allocated block must be obtained from the base address of the block.  
 // - The number of entries in this array is equal to the max number
-//   of allocated block : MALLOC_LOCAL_STORAGE_SIZE / MALLOC_MIN_BLOCK_SIZE.
+//   of allocated block : MALLOC_LOCAL_STORE_SIZE / MALLOC_MIN_BLOCK_SIZE.
 // - For each allocated block, the value registered in the alloc[] array
 //   is log2( size_of_allocated_block ).

trunk/libs/stdlib.c

@@ -36 +36 @@
         __FUNCTION__ , __LINE__ , __FILE__ );
 
-        pthread_exit( NULL );
+        exit( 0 );
     }
 }