Changeset 2427


Ignore:
Timestamp:
11/22/22 12:43:52 (3 months ago)
Author:
jderouillat
Message:

Backport the system to log the memory consumption (commit ID [2418-2420,2425-2426])

Location:
XIOS3/branches/xios-3.0-beta
Files:
6 added
15 edited

Legend:

Unmodified
Added
Removed
  • XIOS3/branches/xios-3.0-beta/bld.cfg

    r2417 r2427  
    5353bld::target xios_server.exe  
    5454bld::target generic_testcase.exe  
    55 bld::target test_ugrid.exe 
     55#bld::target test_ugrid.exe 
    5656#bld::target test_regular.exe 
    5757#bld::target test_xios2_cmip6.exe 
  • XIOS3/branches/xios-3.0-beta/src/client.cpp

    r2335 r2427  
    1818#include "workflow_graph.hpp" 
    1919#include "release_static_allocation.hpp" 
     20#include "mem_checker.hpp" 
    2021 
    2122namespace xios 
     
    519520      report(0)<< " Memory report : increasing it by a factor will increase performance, depending of the volume of data wrote in file at each time step of the file"<<endl ; 
    520521      report(100)<<CTimer::getAllCumulatedTime()<<endl ; 
     522      report(100)<<CMemChecker::getAllCumulatedMem()<<endl ; 
    521523      CWorkflowGraph::drawWorkFlowGraph_client(); 
    522524 
  • XIOS3/branches/xios-3.0-beta/src/cxios.cpp

    r2335 r2427  
    5454  bool CXios::checkSumRecv=false ; 
    5555  bool CXios::checkSumSend=false ; 
     56  bool CXios::logMemory=false ; 
    5657 
    5758  CDaemonsManager*    CXios::daemonsManager_=nullptr ; 
     
    115116    checkSumSend = getin<bool>("checksum_send_fields", false); 
    116117    checkSumRecv = getin<bool>("checksum_recv_fields", false); 
     118 
     119    logMemory = getin<bool>("log_memory", false); 
    117120 
    118121    globalComm=MPI_COMM_WORLD ; 
     
    149152      CClient::openErrorStream(); 
    150153    } 
     154    CMemChecker::logMem("CXios::initClientSide"); 
    151155  } 
    152156  CATCH 
     
    154158  void CXios::clientFinalize(void) 
    155159  { 
     160     CMemChecker::logMem("CXios::clientFinalize", true); 
     161 
    156162     CClient::finalize() ; 
    157163           
     
    231237#endif 
    232238    CMemChecker::get("xios").suspend() ; 
    233     report(0)<<CMemChecker::getAllCumulatedMem() ; 
    234239    CServer::closeInfoStream(); 
    235240  } 
  • XIOS3/branches/xios-3.0-beta/src/cxios.hpp

    r2335 r2427  
    6868     static bool checkSumRecv; //!< For debugging, compute a checksum of fields received by the model through the XIOS client 
    6969 
     70     static bool logMemory; //!< Activate memory monitoring for all XIOS process 
     71 
    7072     static const string defaultPoolId ; 
    7173     static const string defaultServerId ; 
  • XIOS3/branches/xios-3.0-beta/src/filter/model_to_client_source_filter.cpp

    r2143 r2427  
    55#include <limits>  
    66#include "workflow_graph.hpp" 
     7#include "mem_checker.hpp" 
    78 
    89namespace xios 
     
    3738    packet->data.resize(connector->getDstSize()) ; 
    3839    connector->transfer(data, packet->data, nanValue) ; 
     40 
     41    CMemChecker::logMem( "CModelToClientSourceFilter::streamData" ); 
    3942 
    4043    if (hasMissingValue_) 
  • XIOS3/branches/xios-3.0-beta/src/filter/temporal_filter.cpp

    r2195 r2427  
    33#include "calendar_util.hpp" 
    44#include "workflow_graph.hpp" 
     5#include "mem_checker.hpp" 
    56 
    67namespace xios 
     
    117118          packet = data[0]; 
    118119 
     120        CMemChecker::logMem( "CTemporalFilter::apply" ); 
     121 
    119122        isFirstOperation = false; 
    120123        graphCycleCompleted = true; 
  • XIOS3/branches/xios-3.0-beta/src/interface/c/iccalendar.cpp

    r1761 r2427  
    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/branches/xios-3.0-beta/src/interface/c/icdata.cpp

    r2266 r2427  
    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/branches/xios-3.0-beta/src/interface/fortran/ixios.F90

    r2338 r2427  
    3838                  ASSIGNMENT(=) 
    3939USE itimer, ONLY : xios(timer_resume), xios(timer_suspend), xios(timer_reset), xios(timer_get_time) 
     40USE imem_checker, ONLY : xios(mem_checker_get), xios(mem_checker_log) 
    4041 
    4142USE ifield, ONLY : txios(field), txios(fieldgroup), xios(is_valid_field), xios(is_valid_fieldgroup) 
  • XIOS3/branches/xios-3.0-beta/src/io/netCdfInterface.cpp

    r1957 r2427  
    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/branches/xios-3.0-beta/src/io/netCdfInterface_impl.hpp

    r1158 r2427  
    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/branches/xios-3.0-beta/src/mem_checker.cpp

    r2235 r2427  
    11#include "mem_checker.hpp" 
     2#include "cxios.hpp" 
    23#include "mpi.hpp" 
    34#include <string> 
     
    56#include <iostream> 
    67#include <sstream> 
    7 #include <fstream> 
     8 
     9#include <fcntl.h> 
     10#include <iomanip> 
     11#include <unistd.h> 
     12#include <cstring> 
    813 
    914namespace xios 
     
    1318  bool CMemChecker::enabled_=true; 
    1419  bool CMemChecker::first_=true; 
    15  
    16   CMemChecker::CMemChecker(const std::string& name) : name_(name)  
     20  double CMemChecker::vsize_init_=0; 
     21  double CMemChecker::rss_init_=0; 
     22  double CMemChecker::vmhwm_init_=0; 
     23  double CMemChecker::time_init_=0; 
     24  std::ofstream CMemChecker::fout_; 
     25  int CMemChecker::flush_counter_=1; 
     26   
     27  CMemChecker::CMemChecker(const std::string& name) : name_(name) 
    1728  {  
    1829    if (first_) check() ; 
     
    2637    first_=false ; 
    2738  } 
    28   double CMemChecker::getMem(void) 
    29   { 
    30     if (first_) check() ; 
    31     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; 
    3250    std::ifstream statStream("/proc/self/stat",std::ios_base::in); 
    3351    std::string dummy ; 
     
    3553    unsigned long vsize;  
    3654    statStream>>vsize ; 
    37     return vsize ; 
    38   } 
     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; 
     72    std::ifstream statStream("/proc/self/stat",std::ios_base::in); 
     73    std::string dummy ; 
     74    for(int i=1;i<=22;i++) statStream>>dummy ; 
     75 
     76    // 1 - Virtual 
     77    unsigned long vsize;  
     78    statStream>>vsize ; 
     79    if (vsize_init_==0) { 
     80      vsize_init_ = vsize; 
     81      time_init_=MPI_Wtime(); 
     82    } 
     83    vsize -= vsize_init_; 
     84    memories.push_back(vsize); 
     85 
     86    // 2 - RSS 
     87    unsigned long rss; 
     88    statStream>>rss ; 
     89    if (rss_init_==0) { 
     90      rss_init_ = rss; 
     91    } 
     92    rss -= rss_init_; 
     93    rss *= 4096; //getconf("PAGE_SIZE");     
     94    memories.push_back(rss); 
     95 
     96    // 3 - Peak 
     97    char sbuf[1024]; 
     98    std::ifstream file( "/proc/self/status" ); 
     99    if( file.fail() ) { 
     100      return memories; 
     101    } 
     102    int fd = open( "/proc/self/status", O_RDONLY, 0 ); 
     103    int num_read=read( fd, sbuf, ( sizeof sbuf )-1 ); 
     104    close( fd ); 
     105    if( !num_read ) { 
     106      return memories;              
     107    } 
     108    // Peak resident set size 
     109    char *S=strstr( sbuf, "VmHWM:" )+6; 
     110    double vmhwm = ( int )atoi( S ); 
     111    if (vmhwm_init_==0) { 
     112      vmhwm_init_ = vmhwm; 
     113    } 
     114    vmhwm -= vmhwm_init_; 
     115    memories.push_back(vmhwm); 
     116     
     117    return memories; 
     118  } 
     119   
     120  void CMemChecker::logMem( std::string id, bool finalizeLog ) 
     121  { 
     122    if ( !CXios::logMemory ) return ; 
     123 
     124    int rk = 0; 
     125    MPI_Comm_rank( MPI_COMM_WORLD, &rk ); 
     126    std::string logName("xios_memory_"+std::to_string(rk)+".csv"); 
     127    vector<double> mem = getMemories(); 
     128    if (!mem[0]) { 
     129      fout_.open( logName ); 
     130      fout_ << "time,event,vsize,rss,VmHWM" << std::endl; 
     131    } 
     132 
     133    fout_.precision(4); 
     134    // Time format : YYYY-MM-DD HH:MM:SS.XXX -> seconds * 1000. 
     135    fout_ << (MPI_Wtime()-time_init_) << "," << id 
     136          << "," << mem[0]/1024./1024. 
     137          << "," << mem[1]/1024./1024. 
     138          << "," << mem[2]/1024. 
     139          << std::endl; 
     140 
     141    if ((MPI_Wtime()-time_init_)>flush_counter_*600.) 
     142    { 
     143      fout_.flush(); 
     144      flush_counter_++; 
     145    } 
     146     
     147    if (finalizeLog) 
     148    { 
     149      fout_.close(); 
     150    } 
     151  } 
     152 
    39153   
    40154  void CMemChecker::suspend(void) 
     
    42156    if (first_) check() ; 
    43157    if (!enabled_) return ; 
    44     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    } 
    45167    suspended_ = true; 
    46168  } 
     
    50172    if (first_) check() ; 
    51173    if (!enabled_) return ; 
    52     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    } 
    53183    suspended_ = false; 
    54184  } 
    55    
     185 
    56186  void CMemChecker::reset(void) 
    57187  { 
    58188    if (first_) check() ; 
    59189    if (!enabled_) return ; 
    60     cumulatedMem_ = 0.; 
     190    cumulatedMem_.clear(); 
    61191    suspended_ = true; 
    62192  } 
    63193   
    64   double CMemChecker::getCumulatedMem(void) 
    65   { 
    66     if (first_) check() ; 
    67     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; 
    68200    return cumulatedMem_; 
    69201  } 
     
    93225    for(std::map<std::string,CMemChecker>::iterator it=allMemChecker_.begin();it!=allMemChecker_.end();++it) 
    94226    {   
    95       strOut<<"MemChecker : "<<it->first<<"    -->   consumed memory : " ; 
    96       double mem=it->second.getCumulatedMem() ; 
    97       if (mem>=Tb) strOut<< mem / Tb<<" Tb"<<std::endl ; 
    98       else if (mem>=Gb) strOut<< mem / Gb<<" Gb"<<std::endl ; 
    99       else if (mem>=Mb) strOut<< mem / Mb<<" Mb"<<std::endl ; 
    100       else if (mem>=Kb) strOut<< mem / Kb<<" Kb"<<std::endl ; 
    101       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      } 
    102237    } 
    103238    return strOut.str() ; 
  • XIOS3/branches/xios-3.0-beta/src/mem_checker.hpp

    r2274 r2427  
    44#include <string> 
    55#include <map> 
     6#include <fstream> 
     7#include <vector> 
    68 
    79namespace xios 
     
    1416      void resume(void); 
    1517      void reset(void); 
    16       double getCumulatedMem(void); 
    17       static double getMem(void); 
     18      std::vector<double> getCumulatedMem(void); 
     19      static std::vector<double> getMem(void); 
     20      static std::vector<double> getMemories(void); 
     21      static void logMem( std::string id, bool finalizeLog = false ); 
    1822      static CMemChecker& get(std::string name); 
    1923      static std::string getAllCumulatedMem(void) ; 
     
    2327    private: 
    2428      static void check(void) ; 
    25       double cumulatedMem_; 
    26       double lastMem_; 
     29      std::vector<double> cumulatedMem_; 
     30      std::vector<double> lastMem_; 
    2731      bool suspended_; 
    2832      std::string name_; 
     
    3236      static bool first_ ; 
    3337      static bool enabled_ ; 
     38 
     39      static double vsize_init_; 
     40      static double rss_init_; 
     41      static double vmhwm_init_; 
     42      static double time_init_; 
     43      static std::ofstream fout_; 
     44      static int flush_counter_; 
    3445  }; 
    3546} 
  • XIOS3/branches/xios-3.0-beta/src/node/context.cpp

    r2423 r2427  
    1717#include "xios_spl.hpp" 
    1818#include "timer.hpp" 
     19#include "mem_checker.hpp" 
    1920#include "memtrack.hpp" 
    2021#include <limits> 
     
    873874   TRY 
    874875   { 
     876     CMemChecker::logMem( "CContext::closeDefinition" ); 
     877 
    875878     CTimer::get("Context : close definition").resume() ; 
    876879      
     
    11541157 
    11551158     CTimer::get("Context : close definition").suspend() ; 
     1159     CMemChecker::logMem( "CContext::closeDefinition_END" ); 
    11561160  } 
    11571161  CATCH_DUMP_ATTR 
     
    21022106          garbageCollector.invalidate(calendar->getCurrentDate()); 
    21032107        } 
     2108        CMemChecker::logMem( "CContext::updateCalendar_"+std::to_string(step) ); 
    21042109      } 
    21052110      else if (prevStep == step) 
  • XIOS3/branches/xios-3.0-beta/src/server.cpp

    r2399 r2427  
    1313#include "tracer.hpp" 
    1414#include "timer.hpp" 
     15#include "mem_checker.hpp" 
    1516#include "event_scheduler.hpp" 
    1617#include "string_tools.hpp" 
     
    159160      CServer::openInfoStream(CXios::serverFile); 
    160161      CServer::openErrorStream(CXios::serverFile); 
     162 
     163      CMemChecker::logMem( "CServer::initialize" ); 
    161164 
    162165      ///////////////////////////////////////// 
     
    429432      CXios::getMpiGarbageCollector().release() ; // release unfree MPI ressources 
    430433 
     434      CMemChecker::logMem( "CServer::finalize", true ); 
    431435      if (!is_MPI_Initialized) 
    432436      { 
     
    438442      report(0)<<"Performance report : Ratio : "<<CTimer::get("Process events").getCumulatedTime()/CTimer::get("XIOS server").getCumulatedTime()*100.<<"%"<<endl  ; 
    439443      report(100)<<CTimer::getAllCumulatedTime()<<endl ; 
     444      report(100)<<CMemChecker::getAllCumulatedMem()<<endl ; 
    440445       
    441446      CWorkflowGraph::drawWorkFlowGraph_server(); 
Note: See TracChangeset for help on using the changeset viewer.