Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Let's still pass the tests with mmalloc and MC in the library
[simgrid.git] / src / mc / mc_memory.c
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include "mc/mc.h"
4 #include "xbt/sysdep.h"
5 #include "private.h"
6 #include "xbt/log.h"
7 #include <unistd.h>
8 #define _GNU_SOURCE
9
10 extern char *basename (__const char *__filename);
11
12 #define HEAP_OFFSET   20480000    /* Safety gap from the heap's break adress */
13 #define STD_HEAP_SIZE   20480000  /* Maximum size of the system's heap */
14
15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_memory, mc,
16                                 "Logging specific to MC (memory)");
17
18 /* Pointers to each of the heap regions to use */
19 void *std_heap=NULL;
20 void *raw_heap=NULL;
21 void *actual_heap=NULL;
22
23 /* Pointers to the begining and end of the .data and .bss segment of libsimgrid */
24 /* They are initialized once at memory_init */
25 void *libsimgrid_data_addr_start = NULL;
26 size_t libsimgrid_data_size = 0;
27
28 /* Initialize the model-checker memory subsystem */
29 /* It creates the heap regions and set the default one */
30 void MC_memory_init()
31 {
32 /* Create the first region HEAP_OFFSET bytes after the heap break address */
33   std_heap = mmalloc_attach(-1, (char *)sbrk(0) + HEAP_OFFSET);
34   xbt_assert(std_heap != NULL);
35
36 /* Create the sencond region a page after the first one ends */  
37 /* FIXME: do not hardcode the page size to 4096 */
38   raw_heap = mmalloc_attach(-1, (char *)(std_heap) + STD_HEAP_SIZE + 4096);
39   xbt_assert(raw_heap != NULL);
40
41   MC_SET_RAW_MEM;
42
43 /* Get the start address and size of libsimgrid's data segment */
44 /* CAVEAT: Here we are assuming several things, first that get_memory_map() */
45 /* returns an array with the maps sorted from lower addresses to higher */
46 /* ones. Second, that libsimgrid's data takes ONLY ONE page. */
47   int i;
48   char *libname, *tmp;
49
50   /* Get memory map */
51   memory_map_t maps;
52   maps = get_memory_map();
53   
54   for(i=0; i < maps->mapsize; i++){
55  
56     if(maps->regions[i].inode != 0){
57  
58       tmp = xbt_strdup(maps->regions[i].pathname);
59       libname = basename(tmp);
60  
61       if( strncmp("libsimgrid.so.2.0.0", libname, 18) == 0 && maps->regions[i].perms & MAP_WRITE){ //FIXME: do not hardcode
62         libsimgrid_data_addr_start = maps->regions[i].start_addr;
63         libsimgrid_data_size = (size_t)((char *)maps->regions[i+1].end_addr - (char *)maps->regions[i].start_addr);
64         xbt_free(tmp);
65         break;
66       }        
67       xbt_free(tmp);
68     }
69   }
70   
71   xbt_assert0(libsimgrid_data_addr_start != NULL, 
72              "Cannot determine libsimgrid's .data segment address");
73              
74   MC_UNSET_RAW_MEM;
75 }
76
77 /* Finish the memory subsystem */
78 void MC_memory_exit()
79 {
80   mmalloc_detach(std_heap);
81   mmalloc_detach(raw_heap);
82   actual_heap = NULL;
83 }
84
85 void *malloc(size_t n)
86 {
87   void *ret = mmalloc(actual_heap, n);
88    
89   DEBUG2("%zu bytes were allocated at %p",n, ret);
90   return ret;
91 }
92
93 void *calloc(size_t nmemb, size_t size)
94 {
95   size_t total_size = nmemb * size;
96   void *ret = mmalloc(actual_heap, total_size);
97    
98 /* Fill the allocated memory with zeroes to mimic calloc behaviour */
99   memset(ret,'\0', total_size);
100
101   DEBUG2("%zu bytes were mallocated and zeroed at %p",total_size, ret);
102   return ret;
103 }
104   
105 void *realloc(void *p, size_t s)
106 {
107   void *ret = NULL;
108         
109   if (s) {
110     if (p)
111       ret = mrealloc(actual_heap, p,s);
112     else
113       ret = malloc(s); /* FIXME: shouldn't this be mmalloc? */
114   } else {
115     if (p) {
116       free(p);
117     }
118   }
119
120   DEBUG2("%zu bytes were reallocated at %p",s,ret);
121   return ret;
122 }
123
124 void free(void *p)
125 {
126   DEBUG1("%p was freed",p);
127 //  xbt_assert(actual_heap != NULL); FIXME: I had to comment this
128   return mfree(actual_heap, p);
129 }
130
131 /* FIXME: Horrible hack! because the mmalloc library doesn't provide yet of */
132 /* an API to query about the status of a heap, we simply call mmstats and */
133 /* because I now how does structure looks like, then I redefine it here */
134
135 struct mstats
136   {
137     size_t bytes_total;         /* Total size of the heap. */
138     size_t chunks_used;         /* Chunks allocated by the user. */
139     size_t bytes_used;          /* Byte total of user-allocated chunks. */
140     size_t chunks_free;         /* Chunks in the free list. */
141     size_t bytes_free;          /* Byte total of chunks in the free list. */
142   };
143
144 extern struct mstats mmstats(void *);
145
146 /* Copy std_heap to "to_heap" allocating the required space for it */
147 size_t MC_save_heap(void **to_heap)
148 {  
149   size_t heap_size = mmstats(std_heap).bytes_total;
150   
151   *to_heap = calloc(heap_size, 1);
152
153   xbt_assert(*to_heap != NULL);
154   
155   memcpy(*to_heap, std_heap, heap_size);
156   
157   return heap_size;
158 }
159
160 /* Copy the data segment of libsimgrid to "data" allocating the space for it */
161 size_t MC_save_dataseg(void **data)
162 {
163   *data = calloc(libsimgrid_data_size, 1);
164   memcpy(*data, libsimgrid_data_addr_start, libsimgrid_data_size);
165   return libsimgrid_data_size;
166 }
167
168 /* Restore std_heap from "src_heap" */
169 void MC_restore_heap(void *src_heap, size_t size)
170 {  
171   memcpy(std_heap, src_heap, size);
172 }
173
174 /* Restore the data segment of libsimgrid from "src_data" */
175 void MC_restore_dataseg(void *src_data, size_t size)
176 {
177   memcpy(libsimgrid_data_addr_start, src_data, size);
178 }
179
180
181
182
183