Using mallinfo only on Linux
[u/mrichter/AliRoot.git] / STEER / AliMemoryWatcher.cxx
CommitLineData
d60522e4 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15/* $Id$ */
16//_________________________________________________________________________
00399209 17//Basic Memory Leak utility.
18// You can use this tiny class to *see* if your program is leaking.
19// Usage:
ac8cd48d 20// AliMemoryWatcher memwatcher;
00399209 21// some program loop on events here {
22// if ( nevents % x == 0 )
23// {
24// // take a sample every x events
25// memwatcher.watch(nevents);
26// }
27// }
28// TFile f("out.root","RECREATE");
29// memwatcher.write();
30// f.Close();
31// In the output root file you'll get 3 graphs representing
32// the evolAliPHOSon, as a function of the number of events, of :
33// - VSIZE is the virtual size (in KBytes) of your program, that is sort of
34// the total memory used
35// - RSSIZE is the resident size (in KBytes), that is, the part of your
36// program which is really in physical memory.
37// - TIME is an estimate of time per event (really it's the time elasped
38// between two calls to watch method)
39// WARNING: this is far from a bulletproof memory report (it's basically
40// using UNIX command ps -h -p [PID] -o vsize,rssize to do its job).
41// It has only been tested on Linux so far.
42// But by fitting the VSIZE by a pol1 under ROOT, you'll see right away
43// by how much your program is leaking.
d60522e4 44//*-- Author: Laurent Aphecetche(SUBATECH)
d60522e4 45// --- std system ---
b01af8c2 46class assert ;
7406fd3c 47#include <malloc.h>
d60522e4 48// --- AliRoot header files ---
ac8cd48d 49#include "AliMemoryWatcher.h"
d60522e4 50// --- ROOT system ---
51#include "TSystem.h"
52#include "TGraph.h"
53#include "TH2.h"
54#include "TStopwatch.h"
dfe7f75b 55
ac8cd48d 56ClassImp(AliMemoryWatcher)
dfe7f75b 57
d60522e4 58//_____________________________________________________________________________
ac8cd48d 59AliMemoryWatcher::AliMemoryWatcher(UInt_t maxsize)
d60522e4 60{
b01af8c2 61 //ctor
d60522e4 62 fMAXSIZE=maxsize;
7406fd3c 63 fUseMallinfo = true;
d60522e4 64 fPID = gSystem->GetPid();
65 sprintf(fCmd,"ps -h -p %d -o vsize,rssize",fPID);
b01af8c2 66 fX = new Int_t[fMAXSIZE];
67 fVSIZE = new Int_t[fMAXSIZE];
68 fRSSIZE = new Int_t[fMAXSIZE];
69 fTIME = new Double_t[fMAXSIZE];
d60522e4 70 fSize=0;
71 fDisabled=false;
72 fTimer=0;
73}
d60522e4 74//_____________________________________________________________________________
d1898505 75AliMemoryWatcher::AliMemoryWatcher(const AliMemoryWatcher& mw):
76 TObject(mw)
00399209 77{
78 //copy ctor
79 fMAXSIZE = mw.fMAXSIZE ;
7406fd3c 80 fUseMallinfo = mw.fUseMallinfo;
00399209 81 fPID = mw.fPID ;
82 strcpy(fCmd, mw.fCmd) ;
83 fX = new Int_t[fMAXSIZE];
84 fVSIZE = new Int_t[fMAXSIZE];
85 fRSSIZE = new Int_t[fMAXSIZE];
86 fTIME = new Double_t[fMAXSIZE];
87 fSize=0;
88 fDisabled=false;
89 fTimer=0;
90}
91//_____________________________________________________________________________
ac8cd48d 92AliMemoryWatcher::~AliMemoryWatcher()
d60522e4 93{
2a6e66b9 94 // dtor
d60522e4 95 delete[] fVSIZE;
96 delete[] fRSSIZE;
97 delete[] fX;
98 delete[] fTIME;
99 delete fTimer;
100}
d60522e4 101//_____________________________________________________________________________
ac8cd48d 102void AliMemoryWatcher::Watch(Int_t x)
d60522e4 103{
b01af8c2 104 // Sets the point where CPU parameters have to be monitored
d60522e4 105 if ( !fDisabled && fSize < fMAXSIZE ) {
d60522e4 106 if ( fSize==0 ) {
107 assert(fTimer==0);
108 fTimer = new TStopwatch;
109 fTimer->Start(true);
110 fTimer->Stop();
111 }
7406fd3c 112 if ( fUseMallinfo ) {
1844c927 113#ifdef __linux
7406fd3c 114 static struct mallinfo meminfo;
115 meminfo = mallinfo();
d60522e4 116 fX[fSize] = x ;
7406fd3c 117 fVSIZE[fSize] = (meminfo.hblkhd + meminfo.uordblks) / 1024;
118 fRSSIZE[fSize] = meminfo.uordblks / 1024;
d60522e4 119 fTIME[fSize] = fTimer->CpuTime();
120 fSize++;
1844c927 121#else
122 ::Fatal("Watch","Please SetUseMallinfo to kFALSE on this system");
123#endif
7406fd3c 124 } else {
125 static Int_t vsize, rssize;
126 static FILE* pipe = 0;
127 pipe = popen(fCmd,"r");
128 if ( pipe ) {
129
130 fscanf(pipe,"%d %d",&vsize,&rssize);
131
132 fX[fSize] = x ;
133 fVSIZE[fSize] = vsize ;
134 fRSSIZE[fSize] = rssize ;
135 fTIME[fSize] = fTimer->CpuTime();
136 fSize++;
137 }
138 assert(pclose(pipe)!=-1);
d60522e4 139 }
d60522e4 140 fTimer->Start(true);
d60522e4 141 }
142 else {
143 fDisabled=true;
21cd0c07 144 Error("watch", "I'm full !" ) ;
d60522e4 145 }
146}
d60522e4 147//_____________________________________________________________________________
148TGraph*
ac8cd48d 149AliMemoryWatcher::GraphVSIZE(void)
d60522e4 150{
b01af8c2 151 // Fills the graph with the virtual memory sized used
d60522e4 152 TGraph* g = 0;
00399209 153 if ( Size() )
d60522e4 154 {
00399209 155 g = new TGraph(Size());
b01af8c2 156 Int_t i ;
157 for (i=0; i < g->GetN(); i++ ) {
d60522e4 158 g->SetPoint(i,X(i),VSIZE(i));
159 }
160 }
161 return g;
162}
d60522e4 163//_____________________________________________________________________________
164TGraph*
ac8cd48d 165AliMemoryWatcher::GraphRSSIZE(void)
d60522e4 166{
b01af8c2 167 // Fills the graph with the real memory sized used
d60522e4 168 TGraph* g = 0;
00399209 169 if ( Size() )
d60522e4 170 {
00399209 171 g = new TGraph(Size());
b01af8c2 172 Int_t i ;
173 for (i=0; i < g->GetN(); i++ ) {
d60522e4 174 g->SetPoint(i,X(i),RSSIZE(i));
175 }
176 }
177 return g;
178}
d60522e4 179//_____________________________________________________________________________
180TGraph*
ac8cd48d 181AliMemoryWatcher::GraphTIME(void)
d60522e4 182{
b01af8c2 183 // Fills the raph with the used CPU time
d60522e4 184 TGraph* g = 0;
00399209 185 if ( Size() )
d60522e4 186 {
00399209 187 g = new TGraph(Size());
b01af8c2 188 Int_t i ;
189 for (i=0; i < g->GetN(); i++ ) {
d60522e4 190 g->SetPoint(i,X(i),TIME(i));
191 }
192 }
193 return g;
194}
d60522e4 195//_____________________________________________________________________________
196TH2*
ac8cd48d 197AliMemoryWatcher::Frame(void) const
d60522e4 198{
b01af8c2 199 //creates the frame histo in which the graphs will be plotted
200 Double_t xmin=1E30;
201 Double_t xmax=0;
202 Double_t ymin=1;
203 Double_t ymax=0;
204 UInt_t i ;
00399209 205 for (i=0; i < Size() ; i++ ) {
d60522e4 206 if ( X(i) < xmin ) xmin = X(i);
207 if ( X(i) > xmax ) xmax = X(i);
b01af8c2 208 Double_t y = VSIZE(i)+RSSIZE(i);
d60522e4 209 if ( y > ymax ) ymax = y;
d60522e4 210 if ( VSIZE(i) < ymin ) ymin = VSIZE(i);
211 if ( RSSIZE(i) < ymin ) ymin = RSSIZE(i);
212 }
d60522e4 213 TH2F* h = new TH2F("frame","",10,xmin,xmax,10,ymin*0.8,ymax*1.2);
d60522e4 214 return h;
215}
d60522e4 216//_____________________________________________________________________________
6c4904c2 217Int_t
218AliMemoryWatcher::Write(const char *, Int_t, Int_t)
d60522e4 219{
b01af8c2 220 // Stores the graphs in a file
221 if ( GraphVSIZE() ) GraphVSIZE()->Write("VSIZE",TObject::kOverwrite);
00399209 222 if ( GraphRSSIZE() ) GraphRSSIZE() ->Write("RSSIZE",TObject::kOverwrite);
b01af8c2 223 if ( GraphTIME() ) GraphTIME()->Write("TIME",TObject::kOverwrite);
6c4904c2 224 return 0;
4ed9ed00 225}