Ignore:
Timestamp:
11/21/22 16:38:46 (17 months ago)
Author:
jderouillat
Message:

Clean MemCheckcer?, add memory consumption accumulators in main XIOS interfaces for clients, and in the NetCDF interface for servers.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • XIOS3/trunk/src/mem_checker.cpp

    r2425 r2426  
    2525  int CMemChecker::flush_counter_=1; 
    2626   
    27   CMemChecker::CMemChecker(const std::string& name) : name_(name)  
     27  CMemChecker::CMemChecker(const std::string& name) : name_(name) 
    2828  {  
    2929    if (first_) check() ; 
     
    3737    first_=false ; 
    3838  } 
    39   double CMemChecker::getMem(void) 
    40   { 
    41     if (first_) check() ; 
    42     if (!enabled_) return 0; 
     39   
     40  // Return vector of memories amount : 
     41  //   - vector[0] : virtual memory (vsize) from /proc/self/stat 
     42  //   - vector[1] : resident set size (rss) from /proc/self/stat 
     43  std::vector<double> CMemChecker::getMem(void) 
     44  { 
     45    std::vector<double> memories(0); 
     46    memories.clear(); 
     47     
     48    if (first_) check() ; 
     49    if (!enabled_) return memories; 
    4350    std::ifstream statStream("/proc/self/stat",std::ios_base::in); 
    4451    std::string dummy ; 
     
    4653    unsigned long vsize;  
    4754    statStream>>vsize ; 
    48     return vsize ; 
    49   } 
    50   double CMemChecker::getMemRSS(void) 
    51   { 
    52     //sleep( 1 ) ; 
    53     if (first_) check() ; 
    54     if (!enabled_) return 0; 
     55    memories.push_back(vsize); 
     56    unsigned long rss; 
     57    statStream>>rss ; 
     58    memories.push_back(rss*4096); 
     59    return memories ; 
     60  } 
     61   
     62  // Return vector of memories amount, register values (see _init) as first call as reference : 
     63  //   - vector[0] : virtual memory (vsize) from /proc/self/stat 
     64  //   - vector[1] : resident set size (rss) from /proc/self/stat 
     65  //   - vector[2] : Peak resident set size (VmHWM) from /proc/self/status 
     66  std::vector<double> CMemChecker::getMemories(void) 
     67  { 
     68    std::vector<double> memories; 
     69 
     70    if (first_) check() ; 
     71    if (!enabled_) return memories; 
    5572    std::ifstream statStream("/proc/self/stat",std::ios_base::in); 
    5673    std::string dummy ; 
    57     for(int i=1;i<=23;i++) statStream>>dummy ; 
    58     double vsize;  
     74    for(int i=1;i<=22;i++) statStream>>dummy ; 
     75 
     76    // 1 - Virtual 
     77    unsigned long vsize;  
    5978    statStream>>vsize ; 
    6079    if (vsize_init_==0) { 
     
    6382    } 
    6483    vsize -= vsize_init_; 
    65     vsize *= 4096; //getconf("PAGE_SIZE"); 
    66     return vsize ; 
    67   } 
    68    
    69   // Return vector of memories amount : 
    70   //   - vector[0] : virtual memory (vsize) from /proc/self/stat 
    71   //   - vector[1] : resident set size (rss) from /proc/self/stat 
    72   //   - vector[2] : Peak resident set size (VmHWM) from /proc/self/status 
    73   std::vector<double> CMemChecker::getMemories(void) 
    74   { 
    75     std::vector<double> memories; 
    76  
    77     if (first_) check() ; 
    78     if (!enabled_) return memories; 
    79     std::ifstream statStream("/proc/self/stat",std::ios_base::in); 
    80     std::string dummy ; 
    81     for(int i=1;i<=22;i++) statStream>>dummy ; 
    82  
    83     // 1 - Virtual 
    84     double vsize;  
    85     statStream>>vsize ; 
    86     if (vsize_init_==0) { 
    87       vsize_init_ = vsize; 
    88       time_init_=MPI_Wtime(); 
    89     } 
    90     vsize -= vsize_init_; 
    9184    memories.push_back(vsize); 
    9285 
    9386    // 2 - RSS 
    94     double rss; 
     87    unsigned long rss; 
    9588    statStream>>rss ; 
    9689    if (rss_init_==0) { 
     
    163156    if (first_) check() ; 
    164157    if (!enabled_) return ; 
    165     if (!suspended_) cumulatedMem_ += getMem() - lastMem_; 
     158    if (!suspended_) 
     159    { 
     160      vector<double> mem = getMem(); 
     161      cumulatedMem_.resize( mem.size() ); 
     162      for (int i=0;i<mem.size() ; i++) 
     163      { 
     164        cumulatedMem_[i] += mem[i] - lastMem_[i]; 
     165      } 
     166    } 
    166167    suspended_ = true; 
    167168  } 
     
    171172    if (first_) check() ; 
    172173    if (!enabled_) return ; 
    173     if (suspended_) lastMem_ = getMem(); 
     174    if (suspended_) 
     175    { 
     176      vector<double> mem = getMem(); 
     177      lastMem_.resize( mem.size() ); 
     178      for (int i=0;i<mem.size() ; i++) 
     179      { 
     180        lastMem_[i] = mem[i]; 
     181      } 
     182    } 
    174183    suspended_ = false; 
    175184  } 
    176185 
    177   void CMemChecker::suspendRSS(void) 
     186  void CMemChecker::reset(void) 
    178187  { 
    179188    if (first_) check() ; 
    180189    if (!enabled_) return ; 
    181     if (!suspended_) cumulatedMem_ += getMemRSS() - lastMem_; 
     190    cumulatedMem_.clear(); 
    182191    suspended_ = true; 
    183192  } 
    184193   
    185   void CMemChecker::resumeRSS(void) 
    186   { 
    187     if (first_) check() ; 
    188     if (!enabled_) return ; 
    189     if (suspended_) lastMem_ = getMemRSS(); 
    190     suspended_ = false; 
    191   } 
    192    
    193  
    194   void CMemChecker::reset(void) 
    195   { 
    196     if (first_) check() ; 
    197     if (!enabled_) return ; 
    198     cumulatedMem_ = 0.; 
    199     suspended_ = true; 
    200   } 
    201    
    202   double CMemChecker::getCumulatedMem(void) 
    203   { 
    204     if (first_) check() ; 
    205     if (!enabled_) return 0; 
     194  std::vector<double> CMemChecker::getCumulatedMem(void) 
     195  { 
     196    std::vector<double> memories; 
     197    memories.clear(); 
     198    if (first_) check() ; 
     199    if (!enabled_) return memories; 
    206200    return cumulatedMem_; 
    207201  } 
     
    231225    for(std::map<std::string,CMemChecker>::iterator it=allMemChecker_.begin();it!=allMemChecker_.end();++it) 
    232226    {   
    233       strOut<<"MemChecker : "<<it->first<<"    -->   consumed memory : " ; 
    234       double mem=it->second.getCumulatedMem() ; 
    235       if (mem>=Tb) strOut<< mem / Tb<<" Tb"<<std::endl ; 
    236       else if (mem>=Gb) strOut<< mem / Gb<<" Gb"<<std::endl ; 
    237       else if (mem>=Mb) strOut<< mem / Mb<<" Mb"<<std::endl ; 
    238       else if (mem>=Kb) strOut<< mem / Kb<<" Kb"<<std::endl ; 
    239       else strOut<< mem <<" bytes"<<std::endl ; 
     227      vector<double> mem=it->second.getCumulatedMem() ; 
     228      if (mem.size()>0) 
     229      { 
     230        strOut<<"MemChecker : "<<it->first<<"    -->   consumed memory : " ;       
     231        if ((fabs(mem[0])>=Tb)||(fabs(mem[1])>=Tb)) strOut<< mem[0] / Tb<<" Tb - "<<mem[1] / Tb<<" Tb"<<std::endl ; 
     232        else if ((fabs(mem[0])>=Gb)||(fabs(mem[1])>=Gb)) strOut<< mem[0] / Gb<<" Gb - "<<mem[1] / Gb<<" Gb"<<std::endl ; 
     233        else if ((fabs(mem[0])>=Mb)||(fabs(mem[1])>=Mb)) strOut<< mem[0] / Mb<<" Mb - "<<mem[1] / Mb<<" Mb"<<std::endl ; 
     234        else if ((fabs(mem[0])>=Kb)||(fabs(mem[1])>=Kb)) strOut<< mem[0] / Kb<<" Kb - "<<mem[1] / Kb<<" Kb"<<std::endl ; 
     235        else strOut<< mem[0] <<" bytes - "<<mem[1] <<" bytes"<<std::endl ; 
     236      } 
    240237    } 
    241238    return strOut.str() ; 
Note: See TracChangeset for help on using the changeset viewer.