RootSpy Namespace Reference

Classes
struct	logitem

Functions
const std::pair< std::string, std::string > &	getSymbol (const void *address)
bool	endsWith (const std::string &s, const char *pat, size_t npat)
bool	ignoreLib (const std::string &libname)
const char *	getROOTName (void *tobject)
const char *	getROOTClass (void *tobject)
void	logcall (const void *cthisptr, void *&realaddr, bool indirect=false)
void	logcall (const void *cthisptr, const void *&realaddr)
const std::pair< std::string, std::string > &	getUserSymbol (const logitem &item)
void	reportcall (const logitem &item, unsigned ncalls)
void	reporthist (const logitem &item, unsigned thesize)
void	producereport ()

Function Documentation

endsWith()

bool RootSpy::endsWith	(	const std::string &	s,
		const char *	pat,
		size_t	npat
	)

Definition at line 73 of file rootspy.cxx.

                                                               {
    return s.size()>=npat && strncmp(&(s[s.size()-npat]),pat,npat)==0;
  }

getROOTClass()

const char* RootSpy::getROOTClass

(

void *

tobject

)

Definition at line 95 of file rootspy.cxx.

                                           {
    // cppcheck-suppress nullPointerRedundantCheck; false positive
    static const char* (*real)(void*)  = 0;
    if (!real) {
      real = (const char* (*)(void*))dlsym(RTLD_NEXT, "_ZNK7TObject9ClassNameEv");//Fixme: avoid this symbol hardcoding.
      if (!real) {
    std::cout<<"ROOTSPY ERROR: Could not find symbol for TObject::GetName() through hardcoded mangling."<<std::endl;
        return nullptr;
      }
    }
    return real(tobject);
  }

getROOTName()

const char* RootSpy::getROOTName

(

void *

tobject

)

Definition at line 82 of file rootspy.cxx.

                                          {
    // cppcheck-suppress nullPointerRedundantCheck; false positive
    static const char* (*real)(void*)  = 0;
    if (!real) {
      real = (const char* (*)(void*))dlsym(RTLD_NEXT, "_ZNK6TNamed7GetNameEv");//Fixme: avoid this symbol hardcoding.
      if (!real) {
    std::cout<<"ROOTSPY ERROR: Could not find symbol for TNamed::GetName() through hardcoded mangling."<<std::endl;
        return nullptr;
      }
    }
    return real(tobject);
  }

getSymbol()

const std::pair<std::string,std::string>& RootSpy::getSymbol

(

const void *

address

)

Definition at line 48 of file rootspy.cxx.

  {
    if (!address) {
      static std::pair<std::string,std::string> np("/libnothing.so","nullptr");
      return np;
    }
    std::map<const void*,std::pair<std::string,std::string> >::const_iterator it=s_getsymbol_cache.find(address);
    if (it!=s_getsymbol_cache.end())
      return it->second;
 
    void *array[1];
    array[0]=const_cast<void*>(address);
    char **strings = backtrace_symbols (array,1);
    std::string s(strings[0]);
    size_t n = s.find('+');
    if (n!=std::string::npos) s.resize(n);
    n=s.find('(');
    std::string cleansymb = &(s.c_str()[(n==std::string::npos?0:n+1)]);
    std::string libname(s);
    if (n!=std::string::npos)
      libname.resize(n);
    s_getsymbol_cache[address]=std::pair<std::string,std::string>(libname,cleansymb);
    return s_getsymbol_cache[address];
  }

getUserSymbol()

const std::pair<std::string,std::string>& RootSpy::getUserSymbol

(

const logitem &

item

)

Definition at line 190 of file rootspy.cxx.

                                                                        {
    unsigned depth=2+item.traceoffset;
    for (;depth<item.ntrace;++depth) {
      const std::pair<std::string,std::string>& s=getSymbol(item.trace[depth]);
      if (!ignoreLib(s.first)) {
    return s;
      }
    }
    std::cout<<"ROOTSPY WARNING: Could not find user symbol in trace"<<std::endl;
    return getSymbol(item.trace[item.ntrace-1]);
  }

ignoreLib()

bool RootSpy::ignoreLib

(

const std::string &

libname

)

Definition at line 76 of file rootspy.cxx.

  { 
    return endsWith(libname,"libHist.so",10)||endsWith(libname,"libAthenaMonitoringLib.so",25);
  }

logcall() [1/2]

void RootSpy::logcall	(	const void *	cthisptr,
		const void *&	realaddr
	)

Definition at line 183 of file rootspy.cxx.

  {
    void* ra = const_cast<void*>(realaddr);
    logcall(cthisptr,ra,true);
    realaddr=ra;
  };

logcall() [2/2]

void RootSpy::logcall	(	const void *	cthisptr,
		void *&	realaddr,
		bool	indirect = false
	)

Definition at line 143 of file rootspy.cxx.

  {
    if (realaddr&&loglvl>1)
      return;
    logitem item(indirect);
    item.ntrace=backtrace(item.trace, logitem::ntracemax);
    if (!realaddr)
      realaddr=dlsym(RTLD_NEXT, getSymbol(item.trace[1+item.traceoffset]).second.c_str());
    if (loglvl>1)
      return;
    //Add the non-trace info and calc hash:
    void* thisptr=const_cast<void*>(cthisptr);
    const char* rc=thisptr?getROOTClass(thisptr):0;
    const char* rn=thisptr?getROOTName(thisptr):0;
    if (!rc) rc="NULL";
    if (!rn) rn="NULL";
    size_t nrc(strlen(rc));
    size_t nrn(strlen(rn));
    item.name.reserve(nrc+nrn+1);
    item.name.append(rc,nrc);
    item.name.push_back(':');
    item.name.append(rn,nrn);
    item.calchash();
    //Log this trace and root item:
    std::map<logitem,unsigned>::iterator it=s_logcalls.find(item);
    if (it==s_logcalls.end()) {
      s_logcalls[item]=1;
    } else {
      ++(it->second);
    }
    //Log this histogram and its size:
    unsigned thesize = roothiststatGetSize(static_cast<TH1*>(thisptr));//TK: Really update every single time?
    std::map<void*,std::pair<logitem,unsigned> >::iterator it2=s_loghists.find(thisptr);//histaddress->(first logitem,maxsize).
    if (it2==s_loghists.end()) {
      s_loghists.insert(std::pair<void*,std::pair<logitem,unsigned> >(thisptr,std::pair<logitem,unsigned>(item,thesize)));
    } else {
      it2->second.second=std::max<unsigned>(it2->second.second,thesize);
    }
  }

producereport()

void RootSpy::producereport

(

)

Definition at line 210 of file rootspy.cxx.

                       {
    std::cout<<"============= rootspy: Producing report [begin]"<<std::endl;
    std::cout<<"============= Calls"<<std::endl;
    std::map<logitem,unsigned>::iterator it(s_logcalls.begin()),itE(s_logcalls.end());
    for (;it!=itE;++it)
      reportcall(it->first,it->second);
    std::cout<<"============= Sizes"<<std::endl;
    std::map<void*,std::pair<logitem,unsigned> >::iterator it2(s_loghists.begin()),it2E(s_loghists.end());
    for (;it2!=it2E;++it2)
      reporthist(it2->second.first,it2->second.second);
    std::cout<<"============= rootspy: Producing report [end]"<<std::endl;
  }

reportcall()

void RootSpy::reportcall	(	const logitem &	item,
		unsigned	ncalls
	)

Definition at line 202 of file rootspy.cxx.

                                                        {
    const std::pair<std::string,std::string>& s = getUserSymbol(item);
    std::cout<<ncalls<<" calls to "<<getSymbol(item.trace[1+item.traceoffset]).second
         <<" by "<<s.second <<" : "<<s.first <<" : "<<item.name<<std::endl;
  }

reporthist()

void RootSpy::reporthist	(	const logitem &	item,
		unsigned	thesize
	)

Definition at line 207 of file rootspy.cxx.

                                                         {
    std::cout<<thesize<<" bytes in "<<item.name<<" from "<<getUserSymbol(item).first<<std::endl;
  }