LeakCheckModule.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/

 
 
 
//
// includes
//
 
#include <EventLoop/LeakCheckModule.h>
 
#include <EventLoop/Job.h>
#include <EventLoop/ModuleData.h>
#include <SampleHandler/MetaObject.h>
#include <TSystem.h>
#include <TTree.h>
#include <exception>
 
//
// method implementations
//
 
namespace EL
{
  namespace Detail
  {
    StatusCode LeakCheckModule ::
    postFirstEvent (ModuleData& data)
    {
      m_skippedEvents = data.m_eventsProcessed + 1;
 
      // Get the memory usage of the process after initialisation.
      ::ProcInfo_t pinfo;
      if (gSystem->GetProcInfo (&pinfo) != 0) {
        ANA_MSG_ERROR ("Could not get memory usage information");
        return StatusCode::FAILURE;
      }
      m_initMemResident = pinfo.fMemResident;
      m_initMemVirtual = pinfo.fMemVirtual;
      ANA_MSG_DEBUG ("starting memory: " << pinfo.fMemResident << " " << pinfo.fMemVirtual);
      return StatusCode::SUCCESS;
    }
 
 
 
    StatusCode LeakCheckModule ::
    postFinalize (ModuleData& data)
    {
      if (m_skippedEvents > 0) {
        // Get the memory usage of the process after finalisation.
        ::ProcInfo_t pinfo;
        if (gSystem->GetProcInfo (&pinfo) != 0) {
          ANA_MSG_ERROR ("Could not get memory usage information");
          return StatusCode::FAILURE;
        }
        m_finMemResident = pinfo.fMemResident;
        m_finMemVirtual = pinfo.fMemVirtual;
        ANA_MSG_DEBUG ("finishing memory: " << pinfo.fMemResident << " " << pinfo.fMemVirtual);
 
        // Save the memory increase values into the job statistics tree.
        // The values are held in module members because the tree is only
        // filled later, in Worker::finalize, by which point any function
        // local would be out of scope and the branch address dangling.
        RCU_ASSERT (data.m_jobStats != nullptr);
        m_incResBuffer = memIncreaseResident();
        if (! data.m_jobStats->Branch ("memIncreaseResident", &m_incResBuffer)) {
          ANA_MSG_ERROR ("Failed to create branch memIncreaseResident");
          return StatusCode::FAILURE;
        }
        m_incVirtBuffer = memIncreaseVirtual();
        if (! data.m_jobStats->Branch ("memIncreaseVirtual", &m_incVirtBuffer)) {
          ANA_MSG_ERROR ("Failed to create branch memIncreaseVirtual");
          return StatusCode::FAILURE;
        }
      }
      return StatusCode::SUCCESS;
    }
 
 
 
    StatusCode LeakCheckModule ::
    onWorkerEnd (ModuleData& data)
    {
      // Perform a memory leak check in case at least one event was processed.
      if (m_skippedEvents > 0 &&
          data.m_eventsProcessed > m_skippedEvents) {
 
        // Calculate and print the memory increase of the job.
        const Long_t resLeak = memIncreaseResident();
        const Double_t resLeakPerEv =
          (static_cast< Double_t > (resLeak) /
           static_cast< Double_t > (data.m_eventsProcessed-m_skippedEvents));
        const Long_t virtLeak = memIncreaseVirtual();
        const Double_t virtLeakPerEv =
          (static_cast< Double_t > (virtLeak) /
           static_cast< Double_t > (data.m_eventsProcessed-m_skippedEvents) );
        ANA_MSG_INFO ("Memory increase/change during the job:");
        ANA_MSG_INFO ("  - resident: " << resLeakPerEv << " kB/event ("
                      << resLeak << " kB total)");
        ANA_MSG_INFO ("  - virtual : " << virtLeakPerEv << " kB/event ("
                      << virtLeak << " kB total)");
 
        // Decide if this acceptable or not.
        if ((resLeak > absResidentLimit.value()) &&
            (resLeakPerEv > perEvResidentLimit.value()) &&
            (virtLeak > absVirtualLimit.value()) &&
            (virtLeakPerEv > perEvVirtualLimit.value())) {
 
          // If not, decide what to do about it.
          if (failOnLeak.value()) {
            ANA_MSG_ERROR ("A significant memory leak was detected");
            return StatusCode::FAILURE;
          } else {
            ANA_MSG_WARNING ("*");
            ANA_MSG_WARNING ("* A significant memory leak was detected");
            ANA_MSG_WARNING ("*");
          }
        }
      }
      return StatusCode::SUCCESS;
    }
 
 
 
    Long_t LeakCheckModule ::
    memIncreaseResident () const
    {
      // Check that the user called the function at the correct time.
      if ((m_initMemResident == -1) || (m_finMemResident == -1)) {
        throw std::logic_error ("Function called at incorrect time");
      }
      // Return the resident memory increase.
      return (m_finMemResident - m_initMemResident);
    }
 
 
 
    Long_t LeakCheckModule ::
    memIncreaseVirtual () const
    {
      // Check that the user called the function at the correct time.
      if ((m_initMemVirtual == -1) || (m_finMemVirtual == -1)) {
        throw std::logic_error ("Function called at incorrect time");
      }
      // Return the resident memory increase.
      return (m_finMemVirtual - m_initMemVirtual);
    }
  }
}