Changeset 2426


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

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

Location:
XIOS3/trunk/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • XIOS3/trunk/src/interface/c/iccalendar.cpp

    r2406 r2426  
    44#include "exception.hpp" 
    55#include "timer.hpp" 
     6#include "mem_checker.hpp" 
    67#include "context.hpp" 
    78#include "context_client.hpp" 
     
    1213  TRY 
    1314  { 
     15    CMemChecker::get("XIOS update calendar").resume(); 
    1416    CTimer::get("XIOS").resume(); 
    1517    CTimer::get("XIOS update calendar").resume(); 
     
    2325    CTimer::get("XIOS update calendar").suspend(); 
    2426    CTimer::get("XIOS").suspend(); 
     27    CMemChecker::get("XIOS update calendar").suspend(); 
    2528  } 
    2629  CATCH_DUMP_STACK 
  • XIOS3/trunk/src/interface/c/icdata.cpp

    r2406 r2426  
    2525#include "mpi.hpp" 
    2626#include "timer.hpp" 
     27#include "mem_checker.hpp" 
    2728#include "array_new.hpp" 
    2829 
     
    119120   TRY 
    120121   { 
     122     CMemChecker::get("XIOS close definition").resume(); 
     123      
    121124     CTimer::get("XIOS").resume(); 
    122125     CTimer::get("XIOS close definition").resume(); 
     
    125128     CTimer::get("XIOS close definition").suspend(); 
    126129     CTimer::get("XIOS").suspend(); 
     130 
     131     CMemChecker::get("XIOS close definition").suspend(); 
    127132   } 
    128133   CATCH_DUMP_STACK 
     
    419424   TRY 
    420425   { 
     426      CMemChecker::get("XIOS send field").resume(); 
    421427      CTimer::get("XIOS").resume(); 
    422428      CTimer::get("XIOS send field").resume(); 
     
    428434      CTimer::get("XIOS send field").suspend(); 
    429435      CTimer::get("XIOS").suspend(); 
     436      CMemChecker::get("XIOS send field").suspend(); 
    430437   } 
    431438   CATCH_DUMP_STACK 
     
    446453   TRY 
    447454   { 
     455      CMemChecker::get("XIOS send field").resume(); 
    448456      CTimer::get("XIOS").resume(); 
    449457      CTimer::get("XIOS send field").resume(); 
     
    458466      CTimer::get("XIOS send field").suspend(); 
    459467      CTimer::get("XIOS").suspend(); 
     468      CMemChecker::get("XIOS send field").suspend(); 
    460469   } 
    461470   CATCH_DUMP_STACK 
     
    476485   TRY 
    477486   { 
     487      CMemChecker::get("XIOS send field").resume(); 
    478488      CTimer::get("XIOS").resume(); 
    479489      CTimer::get("XIOS send field").resume(); 
     
    488498      CTimer::get("XIOS send field").suspend(); 
    489499      CTimer::get("XIOS").suspend(); 
     500      CMemChecker::get("XIOS send field").suspend(); 
    490501   } 
    491502   CATCH_DUMP_STACK 
     
    508519   TRY 
    509520   { 
     521      CMemChecker::get("XIOS send field").resume(); 
    510522      CTimer::get("XIOS").resume(); 
    511523      CTimer::get("XIOS send field").resume(); 
     
    520532      CTimer::get("XIOS send field").suspend(); 
    521533      CTimer::get("XIOS").suspend(); 
     534      CMemChecker::get("XIOS send field").suspend(); 
    522535   } 
    523536   CATCH_DUMP_STACK 
     
    542555   TRY 
    543556   { 
     557      CMemChecker::get("XIOS send field").resume(); 
    544558      CTimer::get("XIOS").resume(); 
    545559      CTimer::get("XIOS send field").resume(); 
     
    554568      CTimer::get("XIOS send field").suspend(); 
    555569      CTimer::get("XIOS").suspend(); 
     570      CMemChecker::get("XIOS send field").suspend(); 
    556571   } 
    557572   CATCH_DUMP_STACK 
     
    578593   TRY 
    579594   { 
     595      CMemChecker::get("XIOS send field").resume(); 
    580596      CTimer::get("XIOS").resume(); 
    581597      CTimer::get("XIOS send field").resume(); 
     
    590606      CTimer::get("XIOS send field").suspend(); 
    591607      CTimer::get("XIOS").suspend(); 
     608      CMemChecker::get("XIOS send field").suspend(); 
    592609   } 
    593610   CATCH_DUMP_STACK 
     
    613630   { 
    614631  
     632      CMemChecker::get("XIOS send field").resume(); 
    615633      CTimer::get("XIOS").resume(); 
    616634      CTimer::get("XIOS send field").resume(); 
     
    625643      CTimer::get("XIOS send field").suspend(); 
    626644      CTimer::get("XIOS").suspend(); 
     645      CMemChecker::get("XIOS send field").suspend(); 
    627646   } 
    628647   CATCH_DUMP_STACK 
     
    649668   TRY 
    650669   { 
     670      CMemChecker::get("XIOS send field").resume(); 
    651671      CTimer::get("XIOS").resume(); 
    652672      CTimer::get("XIOS send field").resume(); 
     
    661681      CTimer::get("XIOS send field").suspend(); 
    662682      CTimer::get("XIOS").suspend(); 
     683      CMemChecker::get("XIOS send field").suspend(); 
    663684   } 
    664685   CATCH_DUMP_STACK 
     
    683704   TRY 
    684705   { 
     706      CMemChecker::get("XIOS send field").resume(); 
    685707      CTimer::get("XIOS").resume(); 
    686708      CTimer::get("XIOS send field").resume(); 
     
    695717      CTimer::get("XIOS send field").suspend(); 
    696718      CTimer::get("XIOS").suspend(); 
     719      CMemChecker::get("XIOS send field").suspend(); 
    697720   } 
    698721   CATCH_DUMP_STACK 
     
    712735   TRY 
    713736   { 
     737      CMemChecker::get("XIOS send field").resume(); 
    714738      CTimer::get("XIOS").resume(); 
    715739      CTimer::get("XIOS send field").resume(); 
     
    726750      CTimer::get("XIOS send field").suspend(); 
    727751      CTimer::get("XIOS").suspend(); 
     752      CMemChecker::get("XIOS send field").suspend(); 
    728753   } 
    729754   CATCH_DUMP_STACK 
     
    742767   TRY 
    743768   { 
     769      CMemChecker::get("XIOS send field").resume(); 
    744770      CTimer::get("XIOS").resume(); 
    745771      CTimer::get("XIOS send field").resume(); 
     
    756782      CTimer::get("XIOS send field").suspend(); 
    757783      CTimer::get("XIOS").suspend(); 
     784      CMemChecker::get("XIOS send field").suspend(); 
    758785   } 
    759786   CATCH_DUMP_STACK 
     
    774801   TRY 
    775802   { 
     803      CMemChecker::get("XIOS send field").resume(); 
    776804      CTimer::get("XIOS").resume(); 
    777805      CTimer::get("XIOS send field").resume(); 
     
    788816      CTimer::get("XIOS send field").suspend(); 
    789817      CTimer::get("XIOS").suspend(); 
     818      CMemChecker::get("XIOS send field").suspend(); 
    790819    } 
    791820   CATCH_DUMP_STACK 
     
    807836   TRY 
    808837   { 
     838      CMemChecker::get("XIOS send field").resume(); 
    809839      CTimer::get("XIOS").resume(); 
    810840      CTimer::get("XIOS send field").resume(); 
     
    821851      CTimer::get("XIOS send field").suspend(); 
    822852      CTimer::get("XIOS").suspend(); 
     853      CMemChecker::get("XIOS send field").suspend(); 
    823854    } 
    824855   CATCH_DUMP_STACK 
     
    843874   TRY 
    844875   { 
     876      CMemChecker::get("XIOS send field").resume(); 
    845877      CTimer::get("XIOS").resume(); 
    846878      CTimer::get("XIOS send field").resume(); 
     
    857889      CTimer::get("XIOS send field").suspend(); 
    858890      CTimer::get("XIOS").suspend(); 
     891      CMemChecker::get("XIOS send field").suspend(); 
    859892    } 
    860893   CATCH_DUMP_STACK 
     
    878911   TRY 
    879912   { 
     913      CMemChecker::get("XIOS send field").resume(); 
    880914      CTimer::get("XIOS").resume(); 
    881915      CTimer::get("XIOS send field").resume(); 
     
    892926      CTimer::get("XIOS send field").suspend(); 
    893927      CTimer::get("XIOS").suspend(); 
     928      CMemChecker::get("XIOS send field").suspend(); 
    894929    } 
    895930   CATCH_DUMP_STACK 
     
    913948   TRY 
    914949   { 
     950      CMemChecker::get("XIOS send field").resume(); 
    915951      CTimer::get("XIOS").resume(); 
    916952      CTimer::get("XIOS send field").resume(); 
     
    927963      CTimer::get("XIOS send field").suspend(); 
    928964      CTimer::get("XIOS").suspend(); 
     965      CMemChecker::get("XIOS send field").suspend(); 
    929966    } 
    930967   CATCH_DUMP_STACK 
     
    948985   TRY 
    949986   { 
     987      CMemChecker::get("XIOS send field").resume(); 
    950988      CTimer::get("XIOS").resume(); 
    951989      CTimer::get("XIOS recv field").resume(); 
     
    960998      CTimer::get("XIOS recv field").suspend(); 
    961999      CTimer::get("XIOS").suspend(); 
     1000      CMemChecker::get("XIOS send field").suspend(); 
    9621001   } 
    9631002   CATCH_DUMP_STACK 
     
    9761015   TRY 
    9771016   { 
     1017      CMemChecker::get("XIOS send field").resume(); 
    9781018      CTimer::get("XIOS").resume(); 
    9791019      CTimer::get("XIOS recv field").resume(); 
     
    9881028      CTimer::get("XIOS recv field").suspend(); 
    9891029      CTimer::get("XIOS").suspend(); 
     1030      CMemChecker::get("XIOS send field").suspend(); 
    9901031   } 
    9911032   CATCH_DUMP_STACK 
     
    10031044   TRY 
    10041045   { 
     1046      CMemChecker::get("XIOS send field").resume(); 
    10051047      CTimer::get("XIOS").resume(); 
    10061048      CTimer::get("XIOS recv field").resume(); 
     
    10151057      CTimer::get("XIOS recv field").suspend(); 
    10161058      CTimer::get("XIOS").suspend(); 
     1059      CMemChecker::get("XIOS send field").suspend(); 
    10171060   } 
    10181061   CATCH_DUMP_STACK 
     
    10311074   TRY 
    10321075   { 
     1076      CMemChecker::get("XIOS send field").resume(); 
    10331077      CTimer::get("XIOS").resume(); 
    10341078      CTimer::get("XIOS recv field").resume(); 
     
    10431087      CTimer::get("XIOS recv field").suspend(); 
    10441088      CTimer::get("XIOS").suspend(); 
     1089      CMemChecker::get("XIOS send field").suspend(); 
    10451090   } 
    10461091   CATCH_DUMP_STACK 
     
    10611106   TRY 
    10621107   { 
     1108      CMemChecker::get("XIOS send field").resume(); 
    10631109      CTimer::get("XIOS").resume(); 
    10641110      CTimer::get("XIOS recv field").resume(); 
     
    10731119      CTimer::get("XIOS recv field").suspend(); 
    10741120      CTimer::get("XIOS").suspend(); 
     1121      CMemChecker::get("XIOS send field").suspend(); 
    10751122   } 
    10761123   CATCH_DUMP_STACK 
     
    10921139   TRY 
    10931140   { 
     1141      CMemChecker::get("XIOS send field").resume(); 
    10941142      CTimer::get("XIOS").resume(); 
    10951143      CTimer::get("XIOS recv field").resume(); 
     
    11041152      CTimer::get("XIOS recv field").suspend(); 
    11051153      CTimer::get("XIOS").suspend(); 
     1154      CMemChecker::get("XIOS send field").suspend(); 
    11061155   } 
    11071156   CATCH_DUMP_STACK 
     
    11231172   TRY 
    11241173   { 
     1174      CMemChecker::get("XIOS send field").resume(); 
    11251175      CTimer::get("XIOS").resume(); 
    11261176      CTimer::get("XIOS recv field").resume(); 
     
    11351185      CTimer::get("XIOS recv field").suspend(); 
    11361186      CTimer::get("XIOS").suspend(); 
     1187      CMemChecker::get("XIOS send field").suspend(); 
    11371188   } 
    11381189   CATCH_DUMP_STACK 
     
    11551206   TRY 
    11561207   { 
     1208      CMemChecker::get("XIOS send field").resume(); 
    11571209      CTimer::get("XIOS").resume(); 
    11581210      CTimer::get("XIOS recv field").resume(); 
     
    11671219      CTimer::get("XIOS recv field").suspend(); 
    11681220      CTimer::get("XIOS").suspend(); 
     1221      CMemChecker::get("XIOS send field").suspend(); 
    11691222   } 
    11701223   CATCH_DUMP_STACK 
     
    11901243   TRY 
    11911244   { 
     1245      CMemChecker::get("XIOS send field").resume(); 
    11921246      CTimer::get("XIOS").resume(); 
    11931247      CTimer::get("XIOS recv field").resume(); 
     
    12041258      CTimer::get("XIOS recv field").suspend(); 
    12051259      CTimer::get("XIOS").suspend(); 
     1260      CMemChecker::get("XIOS send field").suspend(); 
    12061261   } 
    12071262   CATCH_DUMP_STACK 
     
    12211276   TRY 
    12221277   { 
     1278      CMemChecker::get("XIOS send field").resume(); 
    12231279      CTimer::get("XIOS").resume(); 
    12241280      CTimer::get("XIOS recv field").resume(); 
     
    12351291      CTimer::get("XIOS recv field").suspend(); 
    12361292      CTimer::get("XIOS").suspend(); 
     1293      CMemChecker::get("XIOS send field").suspend(); 
    12371294   } 
    12381295   CATCH_DUMP_STACK 
     
    12531310   TRY 
    12541311   { 
     1312      CMemChecker::get("XIOS send field").resume(); 
    12551313      CTimer::get("XIOS").resume(); 
    12561314      CTimer::get("XIOS recv field").resume(); 
     
    12671325      CTimer::get("XIOS recv field").suspend(); 
    12681326      CTimer::get("XIOS").suspend(); 
     1327      CMemChecker::get("XIOS send field").suspend(); 
    12691328   } 
    12701329   CATCH_DUMP_STACK 
     
    12841343   TRY 
    12851344   { 
     1345      CMemChecker::get("XIOS send field").resume(); 
    12861346      CTimer::get("XIOS").resume(); 
    12871347      CTimer::get("XIOS recv field").resume(); 
     
    12981358      CTimer::get("XIOS recv field").suspend(); 
    12991359      CTimer::get("XIOS").suspend(); 
     1360      CMemChecker::get("XIOS send field").suspend(); 
    13001361    } 
    13011362   CATCH_DUMP_STACK 
     
    13161377   TRY 
    13171378   { 
     1379      CMemChecker::get("XIOS send field").resume(); 
    13181380      CTimer::get("XIOS").resume(); 
    13191381      CTimer::get("XIOS recv field").resume(); 
     
    13301392      CTimer::get("XIOS recv field").suspend(); 
    13311393      CTimer::get("XIOS").suspend(); 
     1394      CMemChecker::get("XIOS send field").suspend(); 
    13321395    } 
    13331396   CATCH_DUMP_STACK 
     
    13511414   TRY 
    13521415   { 
     1416      CMemChecker::get("XIOS send field").resume(); 
    13531417      CTimer::get("XIOS").resume(); 
    13541418      CTimer::get("XIOS recv field").resume(); 
     
    13651429      CTimer::get("XIOS recv field").suspend(); 
    13661430      CTimer::get("XIOS").suspend(); 
     1431      CMemChecker::get("XIOS send field").suspend(); 
    13671432    } 
    13681433   CATCH_DUMP_STACK 
     
    13851450   TRY 
    13861451   { 
     1452      CMemChecker::get("XIOS send field").resume(); 
    13871453      CTimer::get("XIOS").resume(); 
    13881454      CTimer::get("XIOS recv field").resume(); 
     
    13991465      CTimer::get("XIOS recv field").suspend(); 
    14001466      CTimer::get("XIOS").suspend(); 
     1467      CMemChecker::get("XIOS send field").suspend(); 
    14011468    } 
    14021469   CATCH_DUMP_STACK 
     
    14211488   TRY 
    14221489   { 
     1490      CMemChecker::get("XIOS send field").resume(); 
    14231491      CTimer::get("XIOS").resume(); 
    14241492      CTimer::get("XIOS recv field").resume(); 
     
    14351503      CTimer::get("XIOS recv field").suspend(); 
    14361504      CTimer::get("XIOS").suspend(); 
     1505      CMemChecker::get("XIOS send field").suspend(); 
    14371506    } 
    14381507   CATCH_DUMP_STACK 
  • XIOS3/trunk/src/interface/c/icmem_checker.cpp

    r2418 r2426  
    1111  void cxios_mem_checker_get(double* mem) 
    1212  { 
    13     *mem=CMemChecker::getMemRSS(); 
     13    std::vector<double> memories = CMemChecker::getMem(); 
     14    if (memories.size()>1) 
     15    { 
     16      *mem=memories[1]; //rss 
     17    } 
     18    else 
     19    { 
     20      *mem = 0.; 
     21    } 
    1422  } 
    1523 
  • XIOS3/trunk/src/io/netCdfInterface.cpp

    r1957 r2426  
    1010#include "netCdfInterface.hpp" 
    1111#include "netCdfException.hpp" 
     12#include "mem_checker.hpp" 
    1213 
    1314namespace xios 
     
    2223int CNetCdfInterface::create(const StdString& fileName, int cMode, int& ncId) 
    2324{ 
     25  CMemChecker::get("NetCDF create").resume(); 
    2426  int status = nc_create(fileName.c_str(), cMode, &ncId); 
    2527  if (NC_NOERR != status) 
     
    3436    throw CNetCdfException(e); 
    3537  } 
     38  CMemChecker::get("NetCDF create").suspend(); 
    3639 
    3740  return status; 
     
    4952int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    5053{ 
     54  CMemChecker::get("NetCDF create").resume(); 
    5155  int status = xios::nc_create_par(fileName.c_str(), cMode, comm, info, &ncId); 
    5256  if (NC_NOERR != status) 
     
    6165    throw CNetCdfException(e); 
    6266  } 
     67  CMemChecker::get("NetCDF create").suspend(); 
    6368 
    6469  return status; 
     
    7479int CNetCdfInterface::open(const StdString& fileName, int oMode, int& ncId) 
    7580{ 
     81  CMemChecker::get("NetCDF open").resume(); 
    7682  int status = nc_open(fileName.c_str(), oMode, &ncId); 
    7783  if (NC_NOERR != status) 
     
    8692    throw CNetCdfException(e); 
    8793  } 
     94  CMemChecker::get("NetCDF open").suspend(); 
    8895 
    8996  return status; 
     
    102109int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    103110{ 
     111  CMemChecker::get("NetCDF open").resume(); 
    104112  int status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId); 
    105113  if (NC_NOERR != status) 
     
    114122    throw CNetCdfException(e); 
    115123  } 
     124  CMemChecker::get("NetCDF open").suspend(); 
    116125 
    117126  return status; 
     
    125134int CNetCdfInterface::close(int ncId) 
    126135{ 
     136  CMemChecker::get("NetCDF close").resume(); 
    127137  int status = nc_close(ncId); 
    128138  if (NC_NOERR != status) 
     
    136146    throw CNetCdfException(e); 
    137147  } 
     148  CMemChecker::get("NetCDF close").suspend(); 
    138149 
    139150  return status; 
     
    147158int CNetCdfInterface::reDef(int ncId) 
    148159{ 
     160  CMemChecker::get("NetCDF other").resume(); 
    149161  int status = nc_redef(ncId); 
    150162  if (NC_NOERR != status) 
     
    158170    throw CNetCdfException(e); 
    159171  } 
     172  CMemChecker::get("NetCDF other").suspend(); 
    160173 
    161174  return status; 
     
    169182int CNetCdfInterface::endDef(int ncId) 
    170183{ 
     184  CMemChecker::get("NetCDF other").resume(); 
    171185  int status = nc_enddef(ncId); 
    172186  if (NC_NOERR != status) 
     
    181195    throw CNetCdfException(e); 
    182196  } 
     197  CMemChecker::get("NetCDF other").suspend(); 
    183198 
    184199  return status; 
     
    773788int CNetCdfInterface::setFill(int ncid, bool fill) 
    774789{ 
     790  CMemChecker::get("NetCDF other").resume(); 
    775791  int old_fill_mode; 
    776792  int status = nc_set_fill(ncid, fill ? NC_FILL: NC_NOFILL, &old_fill_mode); 
     
    786802    throw CNetCdfException(e); 
    787803  } 
     804  CMemChecker::get("NetCDF other").suspend(); 
    788805 
    789806  return status; 
     
    801818int CNetCdfInterface::defVarFill(int ncid, int varId, int noFill, void* fillValue) 
    802819{ 
     820  CMemChecker::get("NetCDF other").resume(); 
    803821  int status = nc_def_var_fill(ncid, varId, noFill, fillValue); 
    804822  if (NC_NOERR != status) 
     
    814832    throw CNetCdfException(e); 
    815833  } 
     834  CMemChecker::get("NetCDF other").suspend(); 
    816835 
    817836  return status; 
     
    829848int CNetCdfInterface::varParAccess(int ncid, int varId, int access) 
    830849{ 
     850  CMemChecker::get("NetCDF other").resume(); 
    831851  int status = nc_var_par_access(ncid, varId, access); 
    832852  if (NC_NOERR != status) 
     
    841861    throw CNetCdfException(e); 
    842862  } 
     863  CMemChecker::get("NetCDF other").suspend(); 
    843864 
    844865  return status; 
     
    852873int CNetCdfInterface::sync(int ncid) 
    853874{ 
     875  CMemChecker::get("NetCDF other").resume(); 
    854876  int status = nc_sync(ncid); 
    855877  if (NC_NOERR != status) 
     
    864886    throw CNetCdfException(e); 
    865887  } 
     888  CMemChecker::get("NetCDF other").suspend(); 
    866889 
    867890  return status; 
  • XIOS3/trunk/src/io/netCdfInterface_impl.hpp

    r1158 r2426  
    1313#include "netCdfInterface.hpp" 
    1414#include "netCdfException.hpp" 
     15#include "mem_checker.hpp" 
    1516 
    1617namespace xios 
     
    2829  int CNetCdfInterface::getAttType(int ncid, int varId, const StdString& attrName, T* data) 
    2930  { 
     31    CMemChecker::get("NetCDF get/put").resume(); 
    3032    int status = ncGetAttType(ncid, varId, attrName.c_str(), data); 
    3133    if (NC_NOERR != status) 
     
    3941      throw CNetCdfException(sstr.str()); 
    4042    } 
     43    CMemChecker::get("NetCDF get/put").suspend(); 
    4144 
    4245    return status; 
     
    5760                                   StdSize numVal, const T* data) 
    5861  { 
     62    CMemChecker::get("NetCDF get/put").resume(); 
    5963    int status = ncPutAttType(ncid, varId, attrName.c_str(), numVal, data); 
    6064    if (NC_NOERR != status) 
     
    6973      throw CNetCdfException(sstr.str()); 
    7074    } 
     75    CMemChecker::get("NetCDF get/put").suspend(); 
    7176 
    7277    return status; 
     
    8590  int CNetCdfInterface::getVaraType(int ncid, int varId, const StdSize* start, const StdSize* count, T* data) 
    8691  { 
     92    CMemChecker::get("NetCDF get/put").resume(); 
    8793    int status = ncGetVaraType(ncid, varId, start, count, data); 
    8894    if (NC_NOERR != status) 
     
    96102      throw CNetCdfException(sstr.str()); 
    97103    } 
     104    CMemChecker::get("NetCDF get/put").suspend(); 
    98105 
    99106    return status; 
     
    112119  int CNetCdfInterface::putVaraType(int ncid, int varId, const StdSize* start, const StdSize* count, const T* data) 
    113120  { 
     121    CMemChecker::get("NetCDF get/put").resume(); 
    114122    int status = ncPutVaraType(ncid, varId, start, count, data); 
    115123    if (NC_NOERR != status) 
     
    123131      throw CNetCdfException(sstr.str()); 
    124132    } 
     133    CMemChecker::get("NetCDF get/put").suspend(); 
    125134 
    126135    return status; 
  • 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() ; 
  • XIOS3/trunk/src/mem_checker.hpp

    r2425 r2426  
    1515      void suspend(void); 
    1616      void resume(void); 
    17       void suspendRSS(void); 
    18       void resumeRSS(void); 
    1917      void reset(void); 
    20       double getCumulatedMem(void); 
    21       static double getMem(void); 
    22       static double getMemRSS(void); 
     18      std::vector<double> getCumulatedMem(void); 
     19      static std::vector<double> getMem(void); 
    2320      static std::vector<double> getMemories(void); 
    2421      static void logMem( std::string id, bool finalizeLog = false ); 
     
    3027    private: 
    3128      static void check(void) ; 
    32       double cumulatedMem_; 
    33       double lastMem_; 
     29      std::vector<double> cumulatedMem_; 
     30      std::vector<double> lastMem_; 
    3431      bool suspended_; 
    3532      std::string name_; 
  • XIOS3/trunk/src/node/context.cpp

    r2419 r2426  
    20252025      if (prevStep < step) 
    20262026      { 
    2027         CMemChecker::logMem( "CContext::updateCalendar_"+std::to_string(step) ); 
    20282027        if (serviceType_==CServicesManager::CLIENT) // For now we only use server level 1 to read data 
    20292028        { 
     
    20432042          garbageCollector.invalidate(calendar->getCurrentDate()); 
    20442043        } 
     2044        CMemChecker::logMem( "CContext::updateCalendar_"+std::to_string(step) ); 
    20452045      } 
    20462046      else if (prevStep == step) 
Note: See TracChangeset for help on using the changeset viewer.