not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include "src/internal_config.h"
#include <sys/types.h>
#include <fcntl.h> /* After sys/types.h, at least for dpx/2. */
#include <sys/stat.h>
#include <string.h>
-#ifdef HAVE_UNISTD_H
+#if HAVE_UNISTD_H
#include <unistd.h> /* Prototypes for lseek */
#endif
#include "mmprivate.h"
#include "xbt/ex.h"
-#include "xbt_modinter.h" /* declarations of mmalloc_preinit and friends that live here */
+#include "src/xbt_modinter.h" /* declarations of mmalloc_preinit and friends that live here */
#ifndef SEEK_SET
#define SEEK_SET 0
If FD is a valid file descriptor for an open file then data for the
mmalloc managed region is mapped to that file, otherwise an anonymous
map is used if supported by the underlying OS. In case of running in
- an OS without support of anonymous mappings then "/dev/zero" is used
+ an OS without support of anonymous mappings then "/dev/zero" is used
and in both cases the data will not exist in any filesystem object.
If the open file corresponding to FD is from a previous use of
the current process as the process that created the file (ignoring
the BASEADDR parameter).
- For non valid FDs or empty files ones the mapping is established
- starting at the specified address BASEADDR in the process address
+ For non valid FDs or empty files ones the mapping is established
+ starting at the specified address BASEADDR in the process address
space.
The provided BASEADDR should be choosed carefully in order to avoid
mdptr = (struct mdesc *) newmd.base;
mdptr->fd = fd;
if(!mdptr->refcount){
- sem_init(&mdptr->sem, 0, 1);
+ pthread_mutex_init(&mdptr->mutex, NULL);
mdptr->refcount++;
}
}
mdp->next_mdesc = NULL;
mdp->refcount = 1;
mdp->options = options;
-
+
/* If we have not been passed a valid open file descriptor for the file
to map to, then we go for an anonymous map */
if (mdp->fd < 0){
mdp->flags |= MMALLOC_ANONYMOUS;
}
- sem_init(&mdp->sem, 0, 1);
-
+ pthread_mutex_init(&mdp->mutex, NULL);
/* If we have not been passed a valid open file descriptor for the file
to map to, then open /dev/zero and use that to map to. */
abort();
}
- /* Add the new heap to the linked list of heaps attached by mmalloc */
+ /* Add the new heap to the linked list of heaps attached by mmalloc */
if(__mmalloc_default_mdp){
mdp = __mmalloc_default_mdp;
while(mdp->next_mdesc)
struct mdesc *mdp = md;
if(--mdp->refcount == 0){
- LOCK(mdp) ;
- sem_destroy(&mdp->sem);
+ pthread_mutex_destroy(&mdp->mutex);
}
}
/* Initialize the default malloc descriptor. */
void *mmalloc_preinit(void)
{
- int res;
if (__mmalloc_default_mdp == NULL) {
+ if(!xbt_pagesize)
+ xbt_pagesize = getpagesize();
unsigned long mask = ~((unsigned long)xbt_pagesize - 1);
void *addr = (void*)(((unsigned long)sbrk(0) + HEAP_OFFSET) & mask);
__mmalloc_default_mdp = xbt_mheap_new_options(-1, addr, XBT_MHEAP_OPTION_MEMSET);
/* Fixme? only the default mdp in protected against forks */
// This is mandated to protect the mmalloced areas through forks. Think of tesh.
// Nah, removing the mutex isn't a good idea either for tesh
- res = xbt_os_thread_atfork(mmalloc_fork_prepare,
- mmalloc_fork_parent, mmalloc_fork_child);
+ int res = xbt_os_thread_atfork(mmalloc_fork_prepare, mmalloc_fork_parent, mmalloc_fork_child);
if (res != 0)
THROWF(system_error,0,"xbt_os_thread_atfork() failed: return value %d",res);
}
xbt_assert(__mmalloc_default_mdp != NULL);
-#if defined(HAVE_GNU_LD) && defined(MMALLOC_WANT_OVERRIDE_LEGACY)
- mm_gnuld_legacy_init();
-#endif
-
return __mmalloc_default_mdp;
}
// xbt_mheap_destroy_no_free(__mmalloc_default_mdp);
}
-size_t mmalloc_get_bytes_used(xbt_mheap_t heap){
- int i = 0, j = 0;
+// This is the underlying implementation of mmalloc_get_bytes_used_remote.
+// Is it used directly in order to evaluate the bytes used from a different
+// process.
+size_t mmalloc_get_bytes_used_remote(size_t heaplimit, const malloc_info* heapinfo)
+{
int bytes = 0;
-
- while(i<=((struct mdesc *)heap)->heaplimit){
- if(((struct mdesc *)heap)->heapinfo[i].type == MMALLOC_TYPE_UNFRAGMENTED){
- if(((struct mdesc *)heap)->heapinfo[i].busy_block.busy_size > 0)
- bytes += ((struct mdesc *)heap)->heapinfo[i].busy_block.busy_size;
-
- } else if(((struct mdesc *)heap)->heapinfo[i].type > 0){
- for(j=0; j < (size_t) (BLOCKSIZE >> ((struct mdesc *)heap)->heapinfo[i].type); j++){
- if(((struct mdesc *)heap)->heapinfo[i].busy_frag.frag_size[j] > 0)
- bytes += ((struct mdesc *)heap)->heapinfo[i].busy_frag.frag_size[j];
+ for (size_t i=0; i < heaplimit; ++i){
+ if (heapinfo[i].type == MMALLOC_TYPE_UNFRAGMENTED){
+ if (heapinfo[i].busy_block.busy_size > 0)
+ bytes += heapinfo[i].busy_block.busy_size;
+ } else if (heapinfo[i].type > 0) {
+ for (size_t j=0; j < (size_t) (BLOCKSIZE >> heapinfo[i].type); j++){
+ if(heapinfo[i].busy_frag.frag_size[j] > 0)
+ bytes += heapinfo[i].busy_frag.frag_size[j];
}
}
- i++;
}
-
return bytes;
}
+size_t mmalloc_get_bytes_used(const xbt_mheap_t heap){
+ const struct mdesc* heap_data = (const struct mdesc *) heap;
+ return mmalloc_get_bytes_used_remote(heap_data->heaplimit, heap_data->heapinfo);
+}
+
ssize_t mmalloc_get_busy_size(xbt_mheap_t heap, void *ptr){
ssize_t block = ((char*)ptr - (char*)(heap->heapbase)) / BLOCKSIZE + 1;
ssize_t frag = ((uintptr_t) (ADDR2UINT (ptr) % (BLOCKSIZE))) >> heap->heapinfo[block].type;
return heap->heapinfo[block].busy_frag.frag_size[frag];
}
-
+
}
void mmcheck(xbt_mheap_t heap) {return;
