unsigned long
bg_get_stack_mem()
{
bgmemsize_t memory = 0;
Kernel_GetMemorySize( KERNEL_MEMSIZE_STACK, &memory );
return ( unsigned long ) memory;
}
unsigned long
bg_get_heap_mem()
{
bgmemsize_t memory = 0;
Kernel_GetMemorySize( KERNEL_MEMSIZE_HEAP, &memory );
return ( unsigned long ) memory;
}
// return current memory usage in bytes
size_t get_memory_usage_now()
{
size_t memory = 0;
#if defined(__APPLE__)
struct task_basic_info t_info;
mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
if (KERN_SUCCESS != task_info(mach_task_self(),
TASK_BASIC_INFO,
reinterpret_cast<task_info_t>(&t_info),
&t_info_count))
{
return 0;
}
memory = t_info.resident_size;
#elif defined(__LIBCATAMOUNT__) && defined(REDSTORM_HEAP_INFO)
size_t frags;
unsigned long total_free, largest_free, total_used;
heap_info( &frags, &total_free, &largest_free, &total_used );
memory = total_used * 1024;
#elif defined(BGQ_LWK)
uint64_t heap;
Kernel_GetMemorySize(KERNEL_MEMSIZE_HEAP, &heap);
memory = heap;
#elif defined(PROCFS)
unsigned long rss_pages = 0;
// Read memory size data from /proc/pid/stat
// see "man proc" for details.
std::ifstream proc_stat("/proc/self/stat");
if (proc_stat)
{
std::string buf;
proc_stat
>> buf >> buf >> buf >> buf >> buf
>> buf >> buf >> buf >> buf >> buf
>> buf >> buf >> buf >> buf >> buf
>> buf >> buf >> buf >> buf >> buf
>> buf >> buf >> buf
>> rss_pages;
proc_stat.close();
}
memory = rss_pages * sysconf( _SC_PAGESIZE);
#endif
/* Success */
return memory;
}
double nrn_mallinfo( void )
{
double mbs = -1.0; // -ve mem usage if mallinfo is not supported
// On BG-Q, Use kernel/memory.h to get heap statistics
#ifdef HAVE_MEMORY_H
uint64_t heap = 0;
Kernel_GetMemorySize(KERNEL_MEMSIZE_HEAP, &heap);
mbs = heap / (1024.0 * 1024.0);
// if malloc.h available, collect information from mallinfo
#elif defined HAVE_MALLOC_H
struct mallinfo m;
m = mallinfo();
mbs = ( m.hblkhd + m.uordblks ) / (1024.0 * 1024.0);
#endif
return mbs;
}
void printmeminfo( const char *msg) {
#ifdef __bgp__
unsigned int heapnew, heapavailnew, stacknew, stackavailnew;
// unsigned int sharednew, persistnew, guardnew, mmapnew;
#elif __bgq__
uint64_t heapnew, heapavailnew, stacknew, stackavailnew;
// uint64_t sharednew, persistnew, guardnew, mmapnew;
#endif
#ifdef __bgp__
// copy the same lines
#elif __bgq__
// Print info for the following ranks
if (workfc.myrank == 0 || workfc.myrank == (workfc.numpe/2) || workfc.myrank == (workfc.numpe-1) ) {
//for (int irank=0 ; irank<workfc.numpe ; irank++){
// if(irank == workfc.myrank) {
Kernel_GetMemorySize( KERNEL_MEMSIZE_HEAP, &heapnew);
Kernel_GetMemorySize( KERNEL_MEMSIZE_HEAPAVAIL, &heapavailnew);
Kernel_GetMemorySize( KERNEL_MEMSIZE_STACK, &stacknew);
Kernel_GetMemorySize( KERNEL_MEMSIZE_STACKAVAIL, &stackavailnew);
double rheapnew, rheapavailnew, rstacknew, rstackavailnew;
rheapnew = (double) heapnew*inv1024sq;
rheapavailnew = (double) heapavailnew*inv1024sq;
rstacknew = (double) stacknew*inv1024sq;
rstackavailnew = (double) stackavailnew*inv1024sq;
double rdiffheap, rdiffheapavail, rdiffstack, rdiffstackavail;
rdiffheap = rheapnew - memstats.rheap;
rdiffheapavail = rheapavailnew - memstats.rheapavail;
rdiffstack = rstacknew - memstats.rstack;
rdiffstackavail = rstackavailnew - memstats.rstackavail;
printf("MEM %s (rank %d ): allocated heap: %6.2f MB ( %6.2f MB), avail. heap: %6.2f MB (%6.2f MB), allocated stack: %6.2f MB ( %6.2f MB), avail. stack: %6.2f MB ( %6.2f MB),\n",
msg, workfc.myrank, rheapnew, rdiffheap, rheapavailnew, rdiffheapavail, rstacknew, rdiffstack, rstackavailnew, rdiffstackavail );
memstats.rheap = rheapnew;
memstats.rheapavail = rheapavailnew;
memstats.rstack = rstacknew;
memstats.rstackavail = rstackavailnew ;
/*
Kernel_GetMemorySize( KERNEL_MEMSIZE_SHARED, &sharednew);
Kernel_GetMemorySize( KERNEL_MEMSIZE_PERSIST, &persistnew);
Kernel_GetMemorySize( KERNEL_MEMSIZE_GUARD, &guardnew);
Kernel_GetMemorySize( KERNEL_MEMSIZE_MMAP, &mmapnew);
double rsharednew, rpersistnew, rguardnew, rmmapnew;
rsharednew = (double) sharednew*inv1024sq;
rpersistnew = (double) persistnew*inv1024sq;
rguardnew = (double) guardnew*inv1024sq;
rmmapnew = (double) mmapnew*inv1024sq;
double rdiffshared, rdiffpersist, rdiffguard, rdiffmmap;
rdiffshared = rsharednew - memstats.rshared;
rdiffpersist = rpersistnew - memstats.rpersist;
rdiffguard = rguardnew - memstats.rguard;
rdiffmmap = rmmapnew - memstats.rmmap;
printf("MEM %s (rank %d ): allocated heap: %6.2f MB ( %6.2f MB), avail. heap: %6.2f MB (%6.2f MB)\n",msg, workfc.myrank, rheapnew, rdiffheap, rheapavailnew, rdiffheapavail );
printf("MEM %s (rank %d ): shared: %6.2f MB, persist.: %6.2f MB ( %6.2f MB), guard: %6.2f MB ( %6.2f MB), mmap: %6.2f MB ( %6.2f MB) \n", msg, workfc.myrank, rsharednew, rdiffshared,
rpersistnew, rdiffpersist, rguardnew, rdiffguard, rmmapnew, rdiffmmap);
memstats.rshared = rsharednew;
memstats.rpersist = rpersistnew;
memstats.rguard = rguardnew;
memstats.rmmap = rmmapnew;
*/
// } // if irank == myrank
// MPI_Barrier(MPI_COMM_WORLD);
// } // for irank=1 -> numpe
} // if irank == chosen ranks
#endif
}
inline long long memusage_bgq(){
uint64_t heap;
Kernel_GetMemorySize(KERNEL_MEMSIZE_HEAP, &heap);
return heap;
}
int GPTLget_memusage (int *size, int *rss, int *share, int *text, int *datastack)
{
#if defined (BGP) || defined(BGQ)
long long alloc;
struct mallinfo m;
#if defined (BGP)
Personality pers;
#endif
#if defined (BGQ)
uint64_t shared_mem_count;
#endif
long long total;
int node_config;
/* memory available */
#if defined(BGP)
Kernel_GetPersonality(&pers, sizeof(pers));
total = BGP_Personality_DDRSizeMB(&pers);
node_config = BGP_Personality_processConfig(&pers);
if (node_config == _BGP_PERS_PROCESSCONFIG_VNM) total /= 4;
else if (node_config == _BGP_PERS_PROCESSCONFIG_2x2) total /= 2;
total *= 1024*1024;
*size = total;
#endif
#if defined(BGQ)
Kernel_GetMemorySize(KERNEL_MEMSIZE_SHARED, &shared_mem_count);
shared_mem_count *= 1024*1024;
*size = shared_mem_count;
#endif
/* total memory used - heap only (not static memory)*/
m = mallinfo();
alloc = m.hblkhd + m.uordblks;
*rss = alloc;
*share = -1;
*text = -1;
*datastack = -1;
#elif (defined HAVE_SLASHPROC)
FILE *fd; /* file descriptor for fopen */
int pid; /* process id */
static char *head = "/proc/"; /* part of path */
static char *tail = "/statm"; /* part of path */
char file[19]; /* full path to file in /proc */
int dum; /* placeholder for unused return arguments */
int ret; /* function return value */
/*
** The file we want to open is /proc/<pid>/statm
*/
pid = (int) getpid ();
if (pid > 999999) {
fprintf (stderr, "get_memusage: pid %d is too large\n", pid);
return -1;
}
sprintf (file, "%s%d%s", head, pid, tail);
if ((fd = fopen (file, "r")) < 0) {
fprintf (stderr, "get_memusage: bad attempt to open %s\n", file);
return -1;
}
/*
** Read the desired data from the /proc filesystem directly into the output
** arguments, close the file and return.
*/
ret = fscanf (fd, "%d %d %d %d %d %d %d",
size, rss, share, text, datastack, &dum, &dum);
ret = fclose (fd);
return 0;
#elif (defined __APPLE__)
FILE *fd;
char cmd[60];
int pid = (int) getpid ();
sprintf (cmd, "ps -o vsz -o rss -o tsiz -p %d | grep -v RSS", pid);
fd = popen (cmd, "r");
if (fd) {
fscanf (fd, "%d %d %d", size, rss, text);
*share = -1;
*datastack = -1;
(void) pclose (fd);
}
return 0;
#else
struct rusage usage; /* structure filled in by getrusage */
if (getrusage (RUSAGE_SELF, &usage) < 0)
return -1;
*size = -1;
*rss = usage.ru_maxrss;
*share = -1;
*text = -1;
*datastack = -1;
#ifdef IRIX64
*datastack = usage.ru_idrss + usage.ru_isrss;
#endif
return 0;
#endif
}
