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 }