!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
!_TAG_PROGRAM_NAME	Exuberant Ctags	//
!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
!_TAG_PROGRAM_VERSION	5.7	//
AC	BPred.h	/^  int AC;  $/;"	m	class:BPOgehl
APredTableType	MemAnalyzer.h	/^  typedef std::vector<GAddressPredictor*> APredTableType;$/;"	t	class:MemAnalyzer
ASVERSION_H	ASVersion.h	23;"	d
AVSeries	MemAnalyzer.cpp	/^AVSeries::AVSeries() $/;"	f	class:AVSeries
AVSeries	MemAnalyzer.h	/^class AVSeries {$/;"	c
Access	Epoch.h	/^	{PreAccess, Acquire, Access, Release, PostAccess}      sync : 3;$/;"	e	enum:tls::Epoch::State::SyncEnum
AccessType	Epoch.h	/^      typedef enum AccessTypeEnum {Read, Write} AccessType;$/;"	t	class:tls::Epoch::TraceAccessEvent	typeref:enum:tls::Epoch::TraceAccessEvent::AccessTypeEnum
AccessTypeEnum	Epoch.h	/^      typedef enum AccessTypeEnum {Read, Write} AccessType;$/;"	g	class:tls::Epoch::TraceAccessEvent
AccuFarIndepEpoch	Epoch.cpp	/^  Stats::Distribution AccuFarIndepEpoch(&AllStats,"distance to farthest independent epoch");$/;"	v
AccuNumIndepEpochs	Epoch.cpp	/^  Stats::Distribution AccuNumIndepEpochs(&AllStats,"accurate number of independent epochs");$/;"	v
Acquire	Epoch.h	/^	{PreAccess, Acquire, Access, Release, PostAccess}      sync : 3;$/;"	e	enum:tls::Epoch::State::SyncEnum
AcquireBlocksNeeded	Epoch.cpp	/^  Stats::Distribution AcquireBlocksNeeded(&AllStats,"number of buffer blocks needed to perform acquire");$/;"	v
ActiveMerge	Epoch.h	/^      enum MergEnum {PassiveMerge, ActiveMerge}                merg : 1;$/;"	e	enum:tls::Epoch::State::MergEnum
AddrDInstQMap	LDSTQ.h	/^  typedef HASH_MAP<PAddr, DInstQueue> AddrDInstQMap;$/;"	t	class:LDSTQ
AddrQ	MemAnalyzer.h	/^  typedef std::deque<PAddr> AddrQ;$/;"	t	class:MarkovAP
AddrSet	Profile.h	/^  typedef HASH_SET<VAddr> AddrSet;$/;"	t	class:Profile
AddressSet	Epoch.cpp	/^  typedef std::set<Address> AddressSet;$/;"	t	namespace:tls	file:
AddressSet	Epoch.h	/^    typedef std::set<Address> AddressSet;$/;"	t	class:tls::Epoch
After	Epoch.h	/^    enum CmpResult { Before, Unordered, After };$/;"	e	enum:tls::VClock::CmpResult
All	Epoch.h	/^	All=Anti|Output|Flow$/;"	e	enum:tls::Epoch::RaceInfo::RaceType
AllStats	Epoch.cpp	/^  Stats::Group AllStats;$/;"	v
AnomaliesPerRaceEpoch	Epoch.cpp	/^    AnomaliesPerRaceEpoch(&AllStats,"total anomalies detected per race epoch");$/;"	v
AnomaliesPerSrcRaceEpoch	Epoch.cpp	/^    AnomaliesPerSrcRaceEpoch(&AllStats,"total anomalies detected per source-race epoch"),$/;"	v
Anti	Epoch.h	/^	Anti=1,$/;"	e	enum:tls::Epoch::RaceInfo::RaceType
AtomEnum	Epoch.h	/^      enum AtomEnum {NotAtomic, Atomic}                        atom : 1;$/;"	g	struct:tls::Epoch::State
Atomic	Epoch.h	/^      enum AtomEnum {NotAtomic, Atomic}                        atom : 1;$/;"	e	enum:tls::Epoch::State::AtomEnum
BB4Cycle	FetchEngine.h	/^  ushort BB4Cycle;$/;"	m	class:FetchEngine
BHLVPred	VPred.cpp	/^BHLVPred::BHLVPred(unsigned size, const char *name) :$/;"	f	class:BHLVPred
BHLVPred	VPred.h	/^class BHLVPred : public GValuePredictor {$/;"	c
BIM	BPred.h	/^  SCTable BIM;$/;"	m	class:BP2BcgSkew
BMVec	BulkManager.h	/^  typedef std::vector<BulkManager *> BMVec;$/;"	t	class:BulkManager
BM_t	BulkManager.h	/^typedef long BM_t;$/;"	t
BP2BcgSkew	BPred.cpp	/^BP2BcgSkew::BP2BcgSkew(int i, const char *section)$/;"	f	class:BP2BcgSkew
BP2BcgSkew	BPred.h	/^class BP2BcgSkew : public BPred {$/;"	c
BP2bit	BPred.cpp	/^BP2bit::BP2bit(int i, const char *section)$/;"	f	class:BP2bit
BP2bit	BPred.h	/^class BP2bit:public BPred {$/;"	c
BP2level	BPred.cpp	/^BP2level::BP2level(int i, const char *section)$/;"	f	class:BP2level
BP2level	BPred.h	/^class BP2level:public BPred {$/;"	c
BPBTB	BPred.cpp	/^BPBTB::BPBTB(int i, const char *section, const char *name)$/;"	f	class:BPBTB
BPBTB	BPred.h	/^class BPBTB:public BPred {$/;"	c
BPCRap	BPred.cpp	/^BPCRap::BPCRap(int i, const char *section)$/;"	f	class:BPCRap
BPCRap	BPred.h	/^class BPCRap : public BPred {$/;"	c
BPHybrid	BPred.cpp	/^BPHybrid::BPHybrid(int i, const char *section)$/;"	f	class:BPHybrid
BPHybrid	BPred.h	/^class BPHybrid:public BPred {$/;"	c
BPNotTaken	BPred.h	/^  BPNotTaken(int i, const char *section)$/;"	f	class:BPNotTaken
BPNotTaken	BPred.h	/^class BPNotTaken:public BPred {$/;"	c
BPOgehl	BPred.cpp	/^BPOgehl::BPOgehl(int i, const char *section)$/;"	f	class:BPOgehl
BPOgehl	BPred.h	/^class BPOgehl : public BPred {$/;"	c
BPOracle	BPred.h	/^  BPOracle(int i, const char *section)$/;"	f	class:BPOracle
BPOracle	BPred.h	/^class BPOracle:public BPred {$/;"	c
BPRED_H	BPred.h	24;"	d
BPRap	BPred.cpp	/^BPRap::BPRap(int i, const char *section)$/;"	f	class:BPRap
BPRap	BPred.h	/^class BPRap : public BPred {$/;"	c
BPRas	BPred.cpp	/^BPRas::BPRas(int i, const char *section)$/;"	f	class:BPRas
BPRas	BPred.h	/^class BPRas:public BPred {$/;"	c
BPStatic	BPred.h	/^  BPStatic(int i, const char *section)$/;"	f	class:BPStatic
BPStatic	BPred.h	/^class BPStatic:public BPred {$/;"	c
BPTaken	BPred.h	/^  BPTaken(int i, const char *section)$/;"	f	class:BPTaken
BPTaken	BPred.h	/^class BPTaken:public BPred {$/;"	c
BPred	BPred.cpp	/^BPred::BPred(int i, const char *s, const char *n)$/;"	f	class:BPred
BPred	BPred.h	/^class BPred {$/;"	c
BPredictor	BPred.cpp	/^BPredictor::BPredictor(int i, const char *sec, BPredictor *bpred)$/;"	f	class:BPredictor
BPredictor	BPred.h	/^class BPredictor {$/;"	c
BPyags	BPred.cpp	/^BPyags::BPyags(int i, const char *section)$/;"	f	class:BPyags
BPyags	BPred.h	/^class BPyags : public BPred {$/;"	c
BTACDelay	FetchEngine.h	/^  TimeDelta_t BTACDelay;$/;"	m	class:FetchEngine
BTBCache	BPred.h	/^  typedef CacheGeneric<BTBState, ulong, false> BTBCache;$/;"	t	class:BPBTB
BTBState	BPred.h	/^    BTBState() {$/;"	f	class:BPBTB::BTBState
BTBState	BPred.h	/^  class BTBState : public StateGeneric<> {$/;"	c	class:BPBTB
BULK_MANAGER_H_	BulkManager.h	2;"	d
BasicLogger	BulkManager.h	/^class BasicLogger:public BulkLogger{$/;"	c
Before	Epoch.h	/^    enum CmpResult { Before, Unordered, After };$/;"	e	enum:tls::VClock::CmpResult
Begin	MemAnalyzer.cpp	/^void DelinquentLoad::Begin(int tid)$/;"	f	class:DelinquentLoad
BitMaskType	MemBuffer.h	/^typedef unsigned char BitMaskType;$/;"	t
BlockAddrToVersions	Epoch.h	/^      typedef HASH_MAP<Address,BlockVersions *>  BlockAddrToVersions;$/;"	t	class:tls::Epoch::BlockVersions
BlockData	Checkpoint.cpp	/^    BlockData(Address baseAddr){$/;"	f	class:tls::Checkpoint::BlockData
BlockData	Checkpoint.cpp	/^  class Checkpoint::BlockData{$/;"	c	class:tls::Checkpoint	file:
BlockPosition	Epoch.h	/^      typedef BufferBlockList::iterator BlockPosition;$/;"	t	class:tls::Epoch::BlockVersions
BlockVersions	Epoch.h	/^      BlockVersions(void){$/;"	f	class:tls::Epoch::BlockVersions
BlockVersions	Epoch.h	/^    class BlockVersions{$/;"	c	class:tls::Epoch
BlocksMap	Checkpoint.h	/^    typedef HASH_MAP<Address,BlockData *> BlocksMap;$/;"	t	class:tls::Checkpoint
BufBlocksAdjusted	Epoch.cpp	/^  Stats::Distribution BufBlocksAdjusted(&AllStats,"number of buffer blocks per SClock adjustment");$/;"	v
BuffState	MemAnalyzer.h	/^  class BuffState : public StateGeneric<> {$/;"	c	class:GAddressPredictor
BuffType	MemAnalyzer.h	/^  typedef CacheGeneric<BuffState,PAddr> BuffType;$/;"	t	class:GAddressPredictor
BufferBlock	Epoch.h	/^      BufferBlock(Epoch *epoch, Address baseAddr)$/;"	f	class:tls::Epoch::BufferBlock
BufferBlock	Epoch.h	/^    class BufferBlock{$/;"	c	class:tls::Epoch
BufferBlockConstantsEnum	Epoch.h	/^    enum BufferBlockConstantsEnum{$/;"	g	class:tls::Epoch
BufferBlockList	Epoch.h	/^      typedef std::list<BufferBlock *> BufferBlockList;$/;"	t	class:tls::Epoch::BlockVersions
BufferBlocks	Epoch.h	/^    typedef HASH_MAP<Address,BufferBlock *> BufferBlocks;$/;"	t	class:tls::Epoch
BufferSize	BPred.h	/^  const size_t BufferSize;$/;"	m	class:BPRap
BulkLogger	BulkManager.h	/^  BulkLogger(){};$/;"	f	class:BulkLogger
BulkLogger	BulkManager.h	/^class BulkLogger{$/;"	c
BulkManager	BulkManager.cpp	/^BulkManager::BulkManager(GProcessor *gp) :$/;"	f	class:BulkManager
BulkManager	BulkManager.h	/^class BulkManager {$/;"	c
BulkManagerBuilder	BulkManager.h	/^  BulkManagerBuilder(){};$/;"	f	class:BulkManagerBuilder
BulkManagerBuilder	BulkManager.h	/^class BulkManagerBuilder{$/;"	c
CAVAMANAGER_H	CavaManager.h	24;"	d
CBMemRequest	MemRequest.h	/^class CBMemRequest : public MemRequest {$/;"	c
CGCacheLine	CriticalityBuilder.h	/^  typedef CacheGeneric<GraphState,PAddr>::CacheLine CGCacheLine;$/;"	t	class:CriticalityBuilder
CGCacheLine	CriticalityManager.h	/^  typedef CacheGeneric<GraphState,PAddr>::CacheLine CGCacheLine;$/;"	t	class:CriticalityBase
CGPredLine	CriticalityManager.h	/^typedef CacheGeneric<CGPredState,PAddr>::CacheLine CGPredLine;$/;"	t
CGPredState	CriticalityManager.h	/^class CGPredState : public StateGeneric<>{$/;"	c
CGPredictor	CriticalityManager.h	/^typedef CacheGeneric<CGPredState,PAddr> CGPredictor;$/;"	t
CGraphCache	CriticalityBuilder.h	/^  typedef CacheGeneric<GraphState,PAddr> CGraphCache;$/;"	t	class:CriticalityBuilder
CGraphCache	CriticalityManager.h	/^  typedef CacheGeneric<GraphState,PAddr> CGraphCache;$/;"	t	class:CriticalityBase
CLEAN	Profile.h	/^enum PCacheState {CLEAN, DIRTY};$/;"	e	enum:PCacheState
CLUSTER_H	Cluster.h	23;"	d
CONSISTENCYPOLICY_H	ConsistencyPolicy.h	24;"	d
CPBUILDER_H	CPBuilder.h	2;"	d
CPBuilder	CPBuilder.cpp	/^CPBuilder::CPBuilder() $/;"	f	class:CPBuilder
CPBuilder	CPBuilder.h	/^class CPBuilder {$/;"	c
CPEventList	CriticalityPredictor.h	/^typedef std::list<CPSchedEvent> CPEventList;$/;"	t
CPFinishEvent	CriticalityPredictor.h	/^  CPFinishEvent,$/;"	e	enum:__anon3
CPNodeGroup_hash	CriticalityBuilder.h	/^struct CPNodeGroup_hash {$/;"	s
CPNodeGroup_hash	CriticalityManager.h	/^struct CPNodeGroup_hash {$/;"	s
CPPRED_H	CPPred.h	2;"	d
CPPred	CPPred.cpp	/^CPPred::CPPred(const char *section) {$/;"	f	class:CPPred
CPPred	CPPred.h	/^class CPPred {$/;"	c
CPPredEntry	CPPred.cpp	/^CPPredEntry::CPPredEntry()$/;"	f	class:CPPredEntry
CPPredEntry	CPPred.h	/^class CPPredEntry : public StateGeneric<ulonglong> {$/;"	c
CPRemoveEvent	CriticalityPredictor.h	/^  CPRemoveEvent,$/;"	e	enum:__anon3
CPSchedEvent	CriticalityPredictor.h	/^class CPSchedEvent {$/;"	c
CPSpawnEvent	CriticalityPredictor.h	/^  CPSpawnEvent,$/;"	e	enum:__anon3
CPSquashEvent	CriticalityPredictor.h	/^  CPSquashEvent,$/;"	e	enum:__anon3
CPSyncEvent	CriticalityPredictor.h	/^  CPSyncEvent,$/;"	e	enum:__anon3
CP_BRANCH_HISTORY	CPBuilder.h	/^enum PredIndexPolicy{CP_STATIC_ID, CP_TASK_HISTORY, CP_BRANCH_HISTORY, CP_BRANCH_XOR_TASK};$/;"	e	enum:PredIndexPolicy
CP_BRANCH_XOR_TASK	CPBuilder.h	/^enum PredIndexPolicy{CP_STATIC_ID, CP_TASK_HISTORY, CP_BRANCH_HISTORY, CP_BRANCH_XOR_TASK};$/;"	e	enum:PredIndexPolicy
CP_STATIC_ID	CPBuilder.h	/^enum PredIndexPolicy{CP_STATIC_ID, CP_TASK_HISTORY, CP_BRANCH_HISTORY, CP_BRANCH_XOR_TASK};$/;"	e	enum:PredIndexPolicy
CP_TASK_HISTORY	CPBuilder.h	/^enum PredIndexPolicy{CP_STATIC_ID, CP_TASK_HISTORY, CP_BRANCH_HISTORY, CP_BRANCH_XOR_TASK};$/;"	e	enum:PredIndexPolicy
CRITICALITYBUILDER_H	CriticalityBuilder.h	2;"	d
CRITICALITYCONTROLLER_H	CriticalityController.h	2;"	d
CRITICALITYMANAGER_H	CriticalityManager.h	2;"	d
CRITICALITYPREDICTOR_H	CriticalityPredictor.h	2;"	d
CRITICALITYTC_H	CriticalityTC.h	2;"	d
CRITICALITY_H	Criticality.h	2;"	d
CacheNotTaken	BPred.h	/^  uchar *CacheNotTaken;$/;"	m	class:BPyags
CacheNotTakenMask	BPred.h	/^  HistoryType CacheNotTakenMask;$/;"	m	class:BPyags
CacheNotTakenTagMask	BPred.h	/^  HistoryType CacheNotTakenTagMask;$/;"	m	class:BPyags
CacheTaken	BPred.h	/^  uchar *CacheTaken;$/;"	m	class:BPyags
CacheTakenMask	BPred.h	/^  HistoryType CacheTakenMask;$/;"	m	class:BPyags
CacheTakenTagMask	BPred.h	/^  HistoryType CacheTakenTagMask;$/;"	m	class:BPyags
CacheType	BPred.h	/^  typedef CacheGeneric<PathEntry, HistoryType> CacheType;$/;"	t	class:BPCRap
CavaManager	CavaManager.cpp	/^CavaManager::CavaManager(GMemorySystem *gms, int cpuId)$/;"	f	class:CavaManager
CavaManager	CavaManager.h	/^class CavaManager {$/;"	c
ChainHash	CriticalityPredictor.h	/^  typedef HASH_MAP<ProcessId*,EdgeChain*,hash_pointer> ChainHash;$/;"	t	class:EdgeCPred
ChainList	CriticalityPredictor.h	/^typedef std::list<EdgeChain*> ChainList;$/;"	t
Checkpoint	Checkpoint.cpp	/^  Checkpoint::Checkpoint(ClockValue myClock)$/;"	f	class:tls::Checkpoint
Checkpoint	Checkpoint.h	/^  class Checkpoint{$/;"	c	namespace:tls
CheckpointList	Checkpoint.h	/^    typedef std::list<class Checkpoint *> CheckpointList;$/;"	t	class:tls::Checkpoint
ChooseTwo	CriticalityPredictor.h	/^  ChooseTwo,$/;"	e	enum:__anon2
ChooseTwoCPred	CriticalityPredictor.h	/^  ChooseTwoCPred(const char* section)$/;"	f	class:ChooseTwoCPred
ChooseTwoCPred	CriticalityPredictor.h	/^class ChooseTwoCPred : public IdealPredInfo {$/;"	c
Chunk	BulkManager.h	/^    Chunk():$/;"	f	class:BulkManager::Chunk
Chunk	BulkManager.h	/^  class Chunk {$/;"	c	class:BulkManager
ChunkBitMask	Epoch.h	/^    typedef unsigned char ChunkBitMask;$/;"	t	class:tls::Epoch
ChunkDQ	BulkManager.h	/^  typedef std::deque<Chunk *> ChunkDQ;$/;"	t	class:BulkManager
ChunkSet	BulkManager.h	/^  typedef std::set<Chunk *> ChunkSet;$/;"	t	class:BulkManager
CkpInfoEntry	CavaManager.h	/^    CkpInfoEntry() {$/;"	f	class:CavaManager::CkpInfoEntry
CkpInfoEntry	CavaManager.h	/^  class CkpInfoEntry {$/;"	c	class:CavaManager
CkpInfoMap	CavaManager.h	/^  typedef HASH_MAP<unsigned int, CkpInfoEntry> CkpInfoMap;$/;"	t	class:CavaManager
ClockValue	Epoch.h	/^  typedef long int ClockValue;$/;"	t	namespace:tls
ClockVector	Epoch.h	/^    typedef std::vector<ClockValue> ClockVector;$/;"	t	class:tls::VClock
Cluster	Cluster.cpp	/^Cluster::Cluster(const char *clusterName, GProcessor *gp)$/;"	f	class:Cluster
Cluster	Cluster.h	/^class Cluster {$/;"	c
ClusterManager	Cluster.cpp	/^ClusterManager::ClusterManager(GMemorySystem *ms, GProcessor *gproc)$/;"	f	class:ClusterManager
ClusterManager	Cluster.h	/^class ClusterManager {$/;"	c
CmpResult	Epoch.h	/^    enum CmpResult { Before, Unordered, After };$/;"	g	class:tls::VClock
CmpResult	Epoch.h	/^    enum CmpResult{$/;"	g	class:tls::Epoch
CollectVersionCountStats	Epoch.h	4;"	d
Committed	Epoch.h	/^      enum SpecEnum {Spec, ThreadSafe, GlobalSafe, Committed}  spec : 2;$/;"	e	enum:tls::Epoch::State::SpecEnum
Completed	Epoch.h	/^      enum ExecEnum {Spawning, Running, Waiting, Completed}    exec : 2;$/;"	e	enum:tls::Epoch::State::ExecEnum
ConfidenceEstimator	VPred.cpp	/^ConfidenceEstimator::ConfidenceEstimator(int size, const char *name, bool ubh, uchar bits) $/;"	f	class:ConfidenceEstimator
ConfidenceEstimator	VPred.h	/^class ConfidenceEstimator {$/;"	c
ConflictInfo	Epoch.h	/^	ConflictInfo(BufferBlock *block, ChunkBitMask mask)$/;"	f	struct:tls::Epoch::BlockVersions::ConflictInfo
ConflictInfo	Epoch.h	/^	ConflictInfo(const ConflictInfo &other)$/;"	f	struct:tls::Epoch::BlockVersions::ConflictInfo
ConflictInfo	Epoch.h	/^      struct ConflictInfo{$/;"	s	class:tls::Epoch::BlockVersions
ConflictList	Epoch.h	/^      typedef slist<ConflictInfo> ConflictList;$/;"	t	class:tls::Epoch::BlockVersions
ConsistencyPolicy	ConsistencyPolicy.cpp	/^ConsistencyPolicy::ConsistencyPolicy(GProcessor* gproc)$/;"	f	class:ConsistencyPolicy
ConsistencyPolicy	ConsistencyPolicy.h	/^class ConsistencyPolicy{$/;"	c
CorrectPrediction	BPred.h	/^  CorrectPrediction = 0,$/;"	e	enum:PredType
CountMap	Epoch.h	/^      typedef std::map<Address,VersionCount> CountMap;$/;"	t	struct:tls::Epoch::VersionCounts
CritEvent_t	CriticalityPredictor.h	/^} CritEvent_t;$/;"	t	typeref:enum:__anon3
CritHigh	Criticality.h	/^  CritHigh=0,$/;"	e	enum:CritLevel
CritID	CriticalityTC.h	/^typedef long long CritID;$/;"	t
CritLevel	Criticality.h	/^enum CritLevel {$/;"	g
CritLifetime	CriticalityManager.h	/^  CritLifetime(const char *baseName,const char *name, int sid)$/;"	f	class:CritLifetime
CritLifetime	CriticalityManager.h	/^class CritLifetime {$/;"	c
CritLow	Criticality.h	/^  CritLow$/;"	e	enum:CritLevel
CritPredInfo	CriticalityPredictor.h	/^  CritPredInfo()$/;"	f	class:CritPredInfo
CritPredInfo	CriticalityPredictor.h	/^class CritPredInfo {$/;"	c
CritPredictor_t	CriticalityManager.h	/^} CritPredictor_t;$/;"	t	typeref:enum:__anon1
CritPredictor_t	CriticalityPredictor.h	/^} CritPredictor_t;$/;"	t	typeref:enum:__anon2
CritScheduler	CriticalityManager.h	/^  CritScheduler()$/;"	f	class:CritScheduler
CritScheduler	CriticalityManager.h	/^class CritScheduler {$/;"	c
CriticalityBase	CriticalityManager.cpp	/^CriticalityBase::CriticalityBase()$/;"	f	class:CriticalityBase
CriticalityBase	CriticalityManager.h	/^class CriticalityBase {$/;"	c
CriticalityBuilder	CriticalityBuilder.cpp	/^CriticalityBuilder::CriticalityBuilder()$/;"	f	class:CriticalityBuilder
CriticalityBuilder	CriticalityBuilder.h	/^class CriticalityBuilder {$/;"	c
CriticalityBuilderIface	CriticalityBuilder.cpp	/^CriticalityBuilderIface::CriticalityBuilderIface()$/;"	f	class:CriticalityBuilderIface
CriticalityBuilderIface	CriticalityBuilder.h	/^class CriticalityBuilderIface : public CriticalityBuilder {$/;"	c
CriticalityController	CriticalityController.cpp	/^CriticalityController::CriticalityController()$/;"	f	class:CriticalityController
CriticalityController	CriticalityController.h	/^class CriticalityController {$/;"	c
CriticalityManager	CriticalityManager.cpp	/^CriticalityManager::CriticalityManager()$/;"	f	class:CriticalityManager
CriticalityManager	CriticalityManager.h	/^class CriticalityManager : public CriticalityBase {$/;"	c
CriticalityPredictor	CriticalityPredictor.h	/^  CriticalityPredictor(const char *section=NULL) {}$/;"	f	class:CriticalityPredictor
CriticalityPredictor	CriticalityPredictor.h	/^class CriticalityPredictor {$/;"	c
CriticalityTC	CriticalityTC.cpp	/^CriticalityTC::CriticalityTC(TaskContext *aTC)$/;"	f	class:CriticalityTC
CriticalityTC	CriticalityTC.h	/^class CriticalityTC {$/;"	c
CriticalityTable	CPPred.h	/^  typedef CacheGeneric<CPPredEntry,ulonglong> CriticalityTable;$/;"	t	class:CPPred
DEBUGCONDITION	MemObj.h	40;"	d
DEBUGCONDITION	MemObj.h	42;"	d
DEBUGCONDITION	MemRequest.h	53;"	d
DEBUGCONDITION	MemRequest.h	55;"	d
DEPWINDOW_H	DepWindow.h	24;"	d
DINST_H	DInst.h	24;"	d
DIRTY	Profile.h	/^enum PCacheState {CLEAN, DIRTY};$/;"	e	enum:PCacheState
DInst	DInst.cpp	/^DInst::DInst()$/;"	f	class:DInst
DInst	DInst.h	/^class DInst {$/;"	c
DInstNext	DInst.h	/^  DInstNext() {$/;"	f	class:DInstNext
DInstNext	DInst.h	/^class DInstNext {$/;"	c
DInstQueue	LDSTQ.h	/^  typedef std::vector<DInst *> DInstQueue;$/;"	t	class:LDSTQ
DInstSet	LDSTQ.h	/^  typedef std::set<DInst *> DInstSet;$/;"	t	class:LDSTQ
DMemRequest	MemRequest.h	/^class DMemRequest : public MemRequest {$/;"	c
DPHASE1_HUGEHOIST	Profile.h	/^  DPHASE1_HUGEHOIST,    \/\/deleted in phase 1 because of too long hoisting distance$/;"	e	enum:Note_t
DPHASE1_SHORTHOIST	Profile.h	/^  DPHASE1_SHORTHOIST,   \/\/deleted in phase 1 because of short hoisting distance$/;"	e	enum:Note_t
DPHASE1_SMALL	Profile.h	/^  DPHASE1_SMALL,        \/\/deleted in phase 1 because of small task size$/;"	e	enum:Note_t
DPHASE2	Profile.h	/^  DPHASE2 =11,$/;"	e	enum:Note_t
DPT	VPred.h	/^  unsigned *DPT;$/;"	m	class:FWPred
DTLBCache	GMemoryOS.h	/^  typedef CacheGeneric<DTLBState> DTLBCache;$/;"	t	class:DummyMemoryOS
DTLBState	GMemoryOS.h	/^    DTLBState(long iphysicalPage = -1) {  physicalPage = iphysicalPage; }$/;"	f	class:DummyMemoryOS::DTLBState
DTLBState	GMemoryOS.h	/^  class DTLBState : public StateGeneric<> {$/;"	c	class:DummyMemoryOS
DVFSMANAGER_H	DVFSManager.h	23;"	d
DVFSManager	DVFSManager.h	/^class DVFSManager {$/;"	c
DVFSPolicy_t	DVFSManager.h	/^enum DVFSPolicy_t {$/;"	g
DVFS_NONE	DVFSManager.h	/^  DVFS_NONE,$/;"	e	enum:DVFSPolicy_t
DVFS_TS_CRITICAL	DVFSManager.h	/^  DVFS_TS_CRITICAL$/;"	e	enum:DVFSPolicy_t
DVFS_TS_NAIVE	DVFSManager.h	/^  DVFS_TS_NAIVE,$/;"	e	enum:DVFSPolicy_t
DataDepViolationAt	DInst.h	/^enum DataDepViolationAt { DataDepViolationAtExe=0, DataDepViolationAtFetch, $/;"	g
DataDepViolationAtExe	DInst.h	/^enum DataDepViolationAt { DataDepViolationAtExe=0, DataDepViolationAtFetch, $/;"	e	enum:DataDepViolationAt
DataDepViolationAtFetch	DInst.h	/^enum DataDepViolationAt { DataDepViolationAtExe=0, DataDepViolationAtFetch, $/;"	e	enum:DataDepViolationAt
DataDepViolationAtMax	DInst.h	/^			  DataDepViolationAtRetire, DataDepViolationAtMax };$/;"	e	enum:DataDepViolationAt
DataDepViolationAtRetire	DInst.h	/^			  DataDepViolationAtRetire, DataDepViolationAtMax };$/;"	e	enum:DataDepViolationAt
DefaultConsistencyPolicy	ConsistencyPolicy.cpp	/^DefaultConsistencyPolicy::DefaultConsistencyPolicy(GProcessor* gproc)$/;"	f	class:DefaultConsistencyPolicy
DefaultConsistencyPolicy	ConsistencyPolicy.h	/^class DefaultConsistencyPolicy : public ConsistencyPolicy {$/;"	c
DelinquentLoad	MemAnalyzer.cpp	/^DelinquentLoad::DelinquentLoad()$/;"	f	class:DelinquentLoad
DelinquentLoad	MemAnalyzer.h	/^class DelinquentLoad {$/;"	c
DepInfo	Profile.h	/^    DepInfo() {$/;"	f	class:Profile::DepInfo
DepInfo	Profile.h	/^  class DepInfo {$/;"	c	class:Profile
DepInfoType	Profile.h	/^  typedef HASH_MAP<int, DepInfo> DepInfoType;$/;"	t	class:Profile
DepWindow	DepWindow.cpp	/^DepWindow::DepWindow(GProcessor *gproc, const char *clusterName)$/;"	f	class:DepWindow
DepWindow	DepWindow.h	/^class DepWindow {$/;"	c
DetWinBuffObserver	Epoch.cpp	/^  Stats::Distribution DetWinBuffObserver(&AllStats,"bytes of buffer space in epoch's detection window");$/;"	v
DetWinEpochObserver	Epoch.cpp	/^  Stats::Distribution DetWinEpochObserver(&AllStats,"number of epochs in epoch's detection window");$/;"	v
DetWinInstObserver	Epoch.cpp	/^  Stats::Distribution DetWinInstObserver(&AllStats,"number of instructions in epoch's detection window");$/;"	v
DetWinVersObserver	Epoch.cpp	/^  Stats::Distribution DetWinVersObserver(&AllStats,"number of same-block versions in epoch's detection window");$/;"	v
DiscardedSet	CavaManager.h	/^  typedef HASH_SET<unsigned int> DiscardedSet;$/;"	t	class:CavaManager
Distribution	AdvancedStats.h	/^    Distribution(Group *parentGroup=0, char *name=0,size_t numPoints=100)$/;"	f	class:Stats::Distribution
Distribution	AdvancedStats.h	/^  class Distribution : public Group{$/;"	c	namespace:Stats
DstAnomaliesPerEpoch	Epoch.cpp	/^    DstAnomaliesPerEpoch(&AllStats,"destination anomalies detected per epoch"),$/;"	v
DstRacesPerEpoch	Epoch.cpp	/^    DstRacesPerEpoch(&AllStats,"destination races detected per epoch"),$/;"	v
DummyMemObj	MemObj.cpp	/^DummyMemObj::DummyMemObj() $/;"	f	class:DummyMemObj
DummyMemObj	MemObj.cpp	/^DummyMemObj::DummyMemObj(const char *section, const char *sName)$/;"	f	class:DummyMemObj
DummyMemObj	MemObj.h	/^class DummyMemObj : public MemObj {$/;"	c
DummyMemoryOS	GMemoryOS.cpp	/^DummyMemoryOS::DummyMemoryOS(int i)$/;"	f	class:DummyMemoryOS
DummyMemoryOS	GMemoryOS.h	/^class DummyMemoryOS : public GMemoryOS {$/;"	c
DummyMemorySystem	GMemorySystem.cpp	/^DummyMemorySystem::DummyMemorySystem(int id) $/;"	f	class:DummyMemorySystem
DummyMemorySystem	GMemorySystem.h	/^class DummyMemorySystem : public GMemorySystem {$/;"	c
ELVPred	VPred.cpp	/^ELVPred::ELVPred(unsigned size, const char *name) :$/;"	f	class:ELVPred
ELVPred	VPred.h	/^class ELVPred : public GValuePredictor {$/;"	c
ELine	CriticalityPredictor.h	/^  typedef CacheGeneric<EdgeState,unsigned int>::CacheLine ELine;$/;"	t	class:EdgeCPred
EdgeCPred	CriticalityPredictor.cpp	/^EdgeCPred::EdgeCPred(const char* section)$/;"	f	class:EdgeCPred
EdgeCPred	CriticalityPredictor.h	/^class EdgeCPred : public CriticalityPredictor {$/;"	c
EdgeChain	CriticalityPredictor.h	/^class EdgeChain {$/;"	c
EdgePred	CriticalityPredictor.h	/^  EdgePred,$/;"	e	enum:__anon2
EdgePredCache	CriticalityPredictor.h	/^  typedef CacheGeneric<EdgeState,unsigned int> EdgePredCache;$/;"	t	class:EdgeCPred
EdgeState	CriticalityPredictor.h	/^  EdgeState()$/;"	f	class:EdgeState
EdgeState	CriticalityPredictor.h	/^class EdgeState : public StateGeneric<>{$/;"	c
EdgeStateStat	CriticalityPredictor.h	/^  EdgeStateStat(const char* aName) {$/;"	f	class:EdgeStateStat
EdgeStateStat	CriticalityPredictor.h	/^class EdgeStateStat : public GStats {$/;"	c
EdgeStateX	CriticalityPredictor.h	/^  EdgeStateX()$/;"	f	class:EdgeStateX
EdgeStateX	CriticalityPredictor.h	/^class EdgeStateX : public EdgeState {$/;"	c
EmptyLogger	BulkManager.h	/^class EmptyLogger:public BulkLogger{$/;"	c
End	MemAnalyzer.cpp	/^void DelinquentLoad::End()$/;"	f	class:DelinquentLoad
EnergyMgr	EnergyMgr.h	/^  EnergyMgr() {$/;"	f	class:EnergyMgr
EnergyMgr	EnergyMgr.h	/^class EnergyMgr {$/;"	c
EntryType	LDSTBuffer.h	/^  typedef HASH_MAP<VAddr,DInst *> EntryType;$/;"	t	class:LDSTBuffer
Epoch	Epoch.cpp	/^  Epoch::Epoch(Epoch *parentEpoch)$/;"	f	class:tls::Epoch
Epoch	Epoch.cpp	/^  Epoch::Epoch(ThreadID tid)$/;"	f	class:tls::Epoch
Epoch	Epoch.h	/^  class Epoch{$/;"	c	namespace:tls
EpochBuffObserver	Epoch.cpp	/^  Stats::Distribution EpochBuffObserver(&AllStats,"bytes of buffer space per epoch");$/;"	v
EpochInstObserver	Epoch.cpp	/^  Stats::Distribution EpochInstObserver(&AllStats,"number of instructions per epoch");$/;"	v
EpochList	Epoch.h	/^  typedef std::list<class Epoch *> EpochList;$/;"	t	namespace:tls
EpochSet	Epoch.h	/^  typedef std::set<class Epoch *> EpochSet;$/;"	t	namespace:tls
EventSet	Epoch.h	/^    typedef std::set<TraceAccessEvent *> EventSet;$/;"	t	class:tls::Epoch
ExeOrder	Checkpoint.h	/^    class ExeOrder{$/;"	c	class:tls::Checkpoint
ExeOrderEntry	Checkpoint.cpp	/^    ExeOrderEntry(ClockValue myClk, ClockValue parClk)$/;"	f	struct:tls::ExeOrderEntry
ExeOrderEntry	Checkpoint.cpp	/^    ExeOrderEntry(const ExeOrderEntry &other){$/;"	f	struct:tls::ExeOrderEntry
ExeOrderEntry	Checkpoint.cpp	/^  struct ExeOrderEntry{$/;"	s	namespace:tls	file:
ExeOrderList	Checkpoint.cpp	/^  typedef std::list<ExeOrderEntry *> ExeOrderList;$/;"	t	namespace:tls	file:
ExecEnum	Epoch.h	/^      enum ExecEnum {Spawning, Running, Waiting, Completed}    exec : 2;$/;"	g	struct:tls::Epoch::State
ExecutedCluster	Cluster.h	/^  ExecutedCluster(const char *clusterName, GProcessor *gp)$/;"	f	class:ExecutedCluster
ExecutedCluster	Cluster.h	/^class ExecutedCluster : public Cluster {$/;"	c
FCMPred	VPred.cpp	/^FCMPred::FCMPred(unsigned size, const char *name) :$/;"	f	class:FCMPred
FCMPred	VPred.h	/^class FCMPred : public GValuePredictor {$/;"	c
FETCHENGINE_H	FetchEngine.h	26;"	d
FUBranch	Resource.cpp	/^FUBranch::FUBranch(Cluster *cls, PortGeneric *aGen, TimeDelta_t l, int mb)$/;"	f	class:FUBranch
FUBranch	Resource.h	/^class FUBranch : public Resource {$/;"	c
FUEvent	Resource.cpp	/^FUEvent::FUEvent(Cluster *cls)$/;"	f	class:FUEvent
FUEvent	Resource.h	/^class FUEvent : public Resource {$/;"	c
FUGeneric	Resource.cpp	/^FUGeneric::FUGeneric(Cluster *cls$/;"	f	class:FUGeneric
FUGeneric	Resource.h	/^class FUGeneric : public Resource {$/;"	c
FULoad	Resource.cpp	/^FULoad::FULoad(Cluster *cls, PortGeneric *aGen$/;"	f	class:FULoad
FULoad	Resource.h	/^class FULoad : public MemResource {$/;"	c
FUMemory	Resource.cpp	/^FUMemory::FUMemory(Cluster *cls, GMemorySystem *ms, int id)$/;"	f	class:FUMemory
FUMemory	Resource.h	/^class FUMemory : public MemResource {$/;"	c
FUStore	Resource.cpp	/^FUStore::FUStore(Cluster *cls, PortGeneric *aGen$/;"	f	class:FUStore
FUStore	Resource.h	/^class FUStore : public MemResource {$/;"	c
FWPred	VPred.cpp	/^FWPred::FWPred(unsigned size, const char *name) :$/;"	f	class:FWPred
FWPred	VPred.h	/^class FWPred : public GValuePredictor {$/;"	c
FenceEntryType	LDSTBuffer.h	/^  typedef HASH_MAP<int, DInst*>   FenceEntryType;$/;"	t	class:LDSTBuffer
Fetch	SMTProcessor.cpp	/^SMTProcessor::Fetch::Fetch(GMemorySystem *gm, CPU_t cpuID, int cid, FetchEngine *fe)$/;"	f	class:SMTProcessor::Fetch
Fetch	SMTProcessor.h	/^  class Fetch {$/;"	c	class:SMTProcessor
FetchContainer	SMTProcessor.h	/^  typedef std::vector<Fetch *> FetchContainer;$/;"	t	class:SMTProcessor
FetchEngine	FetchEngine.cpp	/^FetchEngine::FetchEngine(int cId$/;"	f	class:FetchEngine
FetchEngine	FetchEngine.h	/^class FetchEngine {$/;"	c
FetchWidth	FetchEngine.h	/^  ushort FetchWidth;$/;"	m	class:FetchEngine
FetchWidth	GProcessor.h	/^  const int FetchWidth;$/;"	m	class:GProcessor
First	Epoch.h	/^      enum Position { First, Second} myPosition;$/;"	e	enum:tls::Epoch::RaceAddrInfo::Position
Flow	Epoch.h	/^	Flow=4,$/;"	e	enum:tls::Epoch::RaceInfo::RaceType
FullReplay	Epoch.h	/^      enum IterEnum {Initial, PartReplay, FullReplay, Merging} iter : 2;$/;"	e	enum:tls::Epoch::State::IterEnum
G0	BPred.h	/^  SCTable G0;$/;"	m	class:BP2BcgSkew
G0HistoryMask	BPred.h	/^  const HistoryType  G0HistoryMask;$/;"	m	class:BP2BcgSkew
G0HistorySize	BPred.h	/^  const ushort       G0HistorySize;$/;"	m	class:BP2BcgSkew
G1	BPred.h	/^  SCTable G1;$/;"	m	class:BP2BcgSkew
G1HistoryMask	BPred.h	/^  const HistoryType  G1HistoryMask;$/;"	m	class:BP2BcgSkew
G1HistorySize	BPred.h	/^  const ushort       G1HistorySize;$/;"	m	class:BP2BcgSkew
GAddressPredictor	MemAnalyzer.cpp	/^GAddressPredictor::GAddressPredictor(const char *name, const char *pbsec)$/;"	f	class:GAddressPredictor
GAddressPredictor	MemAnalyzer.h	/^class GAddressPredictor {$/;"	c
GENERGYMGR_H	EnergyMgr.h	25;"	d
GLVID	GLVID.h	/^class GLVID {$/;"	c
GLVIDDummy	GLVID.cpp	/^GLVIDDummy::GLVIDDummy() $/;"	f	class:GLVIDDummy
GLVIDDummy	GLVID.h	/^class GLVIDDummy : public GLVID {$/;"	c
GLVID_H	GLVID.h	23;"	d
GMEMORYOS_H	GMemoryOS.h	25;"	d
GMEMORYSYSTEM_H	GMemorySystem.h	24;"	d
GMemoryOS	GMemoryOS.h	/^  GMemoryOS(int i) $/;"	f	class:GMemoryOS
GMemoryOS	GMemoryOS.h	/^class GMemoryOS {$/;"	c
GMemorySystem	GMemorySystem.cpp	/^GMemorySystem::GMemorySystem(int processorId) $/;"	f	class:GMemorySystem
GMemorySystem	GMemorySystem.h	/^class GMemorySystem {$/;"	c
GPROCESSOR_H	GProcessor.h	24;"	d
GProcCont	RunningProcs.h	/^  typedef SLIST<GProcessor *> GProcCont;$/;"	t	class:RunningProcs
GProcessor	GProcessor.cpp	/^GProcessor::GProcessor(GMemorySystem *gm, CPU_t i, size_t numFlows)$/;"	f	class:GProcessor
GProcessor	GProcessor.h	/^class GProcessor {$/;"	c
GValuePredictor	VPred.cpp	/^GValuePredictor::GValuePredictor(const char *name) $/;"	f	class:GValuePredictor
GValuePredictor	VPred.h	/^class GValuePredictor {$/;"	c
GlobalHybrid	CriticalityPredictor.h	/^  GlobalHybrid,$/;"	e	enum:__anon2
GlobalLVPred	VPred.cpp	/^GlobalLVPred::GlobalLVPred(const char *name) :$/;"	f	class:GlobalLVPred
GlobalLVPred	VPred.h	/^class GlobalLVPred : public GValuePredictor {$/;"	c
GlobalSafe	Epoch.h	/^      enum SpecEnum {Spec, ThreadSafe, GlobalSafe, Committed}  spec : 2;$/;"	e	enum:tls::Epoch::State::SpecEnum
GraphState	CriticalityBuilder.h	/^class GraphState : public StateGeneric<> {$/;"	c
GraphState	CriticalityManager.h	/^class GraphState : public StateGeneric<> {$/;"	c
Group	AdvancedStats.cpp	/^  Group::Group(Group *parentGroup, char *name)$/;"	f	class:Stats::Group
Group	AdvancedStats.h	/^  class Group{$/;"	c	namespace:Stats
GroupList	AdvancedStats.h	/^    typedef list<Group *> GroupList;$/;"	t	class:Stats::Group
GroupList	CriticalityBuilder.h	/^  typedef std::vector<CPNodeGroup*> GroupList;$/;"	t	class:CriticalityBuilder
GroupList	CriticalityManager.h	/^  typedef std::vector<CPNodeGroup*> GroupList;$/;"	t	class:CriticalityBase
GroupListIt	AdvancedStats.h	/^    typedef GroupList::iterator GroupListIt;$/;"	t	class:Stats::Group
GroupMap	AdvancedStats.h	/^    typedef map<Group *,GroupListIt> GroupMap;$/;"	t	class:Stats::Group
HT	VPred.h	/^  unsigned *HT;$/;"	m	class:FCMPred
HVERSION_H	HVersion.h	24;"	d
HVersion	ASVersion.h	/^class HVersion {$/;"	c
HVersion	HVersion.h	/^class HVersion {$/;"	c
HVersionDomain	HVersion.h	/^  HVersionDomain() {$/;"	f	class:HVersionDomain
HVersionDomain	HVersion.h	/^class HVersionDomain {$/;"	c
HVersionHashFunc	ASVersion.h	/^class HVersionHashFunc {$/;"	c
HVersionHashFunc	HVersion.h	/^class HVersionHashFunc {$/;"	c
HVersionLessThan	ASVersion.h	/^class HVersionLessThan {$/;"	c
HVersionLessThan	HVersion.h	/^class HVersionLessThan {$/;"	c
HVersionMax	HVersion.h	/^  static const VType HVersionMax = 0xffffffffffffffffULL - 4*HVersionReclaim;$/;"	m	class:HVersion
HVersionReclaim	ASVersion.h	/^  static const VType HVersionReclaim = 268435456;$/;"	m	class:HVersion
HVersionReclaim	HVersion.h	/^  static const VType HVersionReclaim = 268435456;$/;"	m	class:HVersion
Hash4DInst	DInst.h	/^class Hash4DInst {$/;"	c
Hash4HistoryType	BPred.h	/^  class Hash4HistoryType {$/;"	c	class:BPred
Hash4TaskContext	TaskContext.h	/^  class Hash4TaskContext {$/;"	c	class:TaskContext
HashType	RiskLoadProf.h	/^  typedef HASH_MAP<ulong, int> HashType;$/;"	t	class:RiskLoadProf
HistoryType	BPred.h	/^  typedef unsigned long long HistoryType;$/;"	t	class:BPred
IBucket	Pipeline.cpp	/^IBucket::IBucket(size_t size, Pipeline *p, bool clean)$/;"	f	class:IBucket
IBucket	Pipeline.h	/^class IBucket : public FastQueue<DInst *> {$/;"	c
IBucketCont	Pipeline.h	/^  typedef std::vector<IBucket *> IBucketCont;$/;"	t	class:Pipeline
ID	DInst.h	/^  long ID; \/\/ static ID, increased every create (currentID). pointer to the$/;"	m	class:DInst
IDP	HVersion.h	/^  class IDP { \/\/ Interval Distribution Predictor$/;"	c	class:HVersion
IFID	Processor.h	/^  FetchEngine IFID;$/;"	m	class:Processor
IFID	SMTProcessor.h	/^    FetchEngine IFID;$/;"	m	class:SMTProcessor::Fetch
IL1HitDelay	FetchEngine.h	/^  TimeDelta_t IL1HitDelay;$/;"	m	class:FetchEngine
IMemRequest	MemRequest.h	/^class IMemRequest : public MemRequest {$/;"	c
IPC	BulkManager.h	/^    float  IPC;$/;"	m	class:BulkManager::Chunk
ITLBTranslate	GMemoryOS.cpp	/^long DummyMemoryOS::ITLBTranslate(unsigned long iAddr)$/;"	f	class:DummyMemoryOS
Id	DepWindow.h	/^  const int Id;$/;"	m	class:DepWindow
Id	FetchEngine.h	/^  const int Id;$/;"	m	class:FetchEngine
Id	GMemoryOS.h	/^  const int Id; \/\/ One OS instance per processor (1 per SMT too)$/;"	m	class:GMemoryOS
Id	GMemorySystem.h	/^  const int Id;$/;"	m	class:GMemorySystem
Id	GProcessor.h	/^  const CPU_t Id;$/;"	m	class:GProcessor
Id	MultiManager.h	/^  int Id;$/;"	m	class:MultiPathManager
IdealHybrid	CriticalityPredictor.h	/^  IdealHybrid,$/;"	e	enum:__anon2
IdealHybridCPred	CriticalityPredictor.h	/^class IdealHybridCPred : public IdealPredInfo {$/;"	c
IdealPredInfo	CriticalityPredictor.cpp	/^IdealPredInfo::IdealPredInfo(const char* section)$/;"	f	class:IdealPredInfo
IdealPredInfo	CriticalityPredictor.h	/^class IdealPredInfo : public CriticalityPredictor {$/;"	c
InOrderCore	DepWindow.h	/^  const bool InOrderCore;$/;"	m	class:DepWindow
InOrderCore	GProcessor.h	/^  const bool InOrderCore;$/;"	m	class:GProcessor
IndexCounts	Epoch.h	/^    typedef std::vector<size_t> IndexCounts;$/;"	t	class:tls::VClock
IndexSet	Epoch.h	/^    typedef std::set<ThreadIndex> IndexSet;$/;"	t	class:tls::Thread
InflightSet	CavaManager.h	/^  typedef HASH_SET<PAddr> InflightSet;$/;"	t	class:CavaManager
Initial	Epoch.h	/^      enum IterEnum {Initial, PartReplay, FullReplay, Merging} iter : 2;$/;"	e	enum:tls::Epoch::State::IterEnum
Initialize	CPBuilder.cpp	/^void CPBuilder::Initialize()$/;"	f	class:CPBuilder
Initialize	TimelineManager.cpp	/^void TimelineManager::Initialize()$/;"	f	class:TimelineManager
InsDetWinBuffObserver	Epoch.cpp	/^  Stats::Distribution InsDetWinBuffObserver(&AllStats,"bytes of buffer space in instruction's detection window");$/;"	v
InsDetWinEpochObserver	Epoch.cpp	/^  Stats::Distribution InsDetWinEpochObserver(&AllStats,"number of epochs in instruction's detection window");$/;"	v
InsDetWinInstObserver	Epoch.cpp	/^  Stats::Distribution InsDetWinInstObserver(&AllStats,"number of instructions in instruction's detection window");$/;"	v
InsDetWinVersObserver	Epoch.cpp	/^  Stats::Distribution InsDetWinVersObserver(&AllStats,"number of same-block versions in instruction's detection window");$/;"	v
InstQueueSize	GProcessor.h	/^  const int InstQueueSize;$/;"	m	class:GProcessor
InstrCount	Epoch.h	/^  typedef unsigned long long InstrCount;$/;"	t	namespace:tls
InterClusterLat	DepWindow.h	/^  const TimeDelta_t InterClusterLat;$/;"	m	class:DepWindow
InvalidState	ProcessId.h	/^  InvalidState = 0,$/;"	e	enum:ProcessIdState
IsEntered	MemAnalyzer.h	/^  static bool IsEntered() { return DelinquentLoad::entered; }$/;"	f	class:DelinquentLoad
IssueWidth	GProcessor.h	/^  const int IssueWidth;$/;"	m	class:GProcessor
IterEnum	Epoch.h	/^      enum IterEnum {Initial, PartReplay, FullReplay, Merging} iter : 2;$/;"	g	struct:tls::Epoch::State
Key2PosType	BPred.h	/^  typedef HASH_MAP<HistoryType, int, Hash4HistoryType> Key2PosType;$/;"	t	class:BPRap
L1DCache	Resource.h	/^  MemObj  *L1DCache;$/;"	m	class:MemResource
L1ICache	Resource.h	/^  MemObj  *L1ICache;$/;"	m	class:MemResource
LDSTBUFFER_H	LDSTBuffer.h	23;"	d
LDSTBuffer	LDSTBuffer.h	/^class LDSTBuffer {$/;"	c
LDSTQ	LDSTQ.cpp	/^LDSTQ::LDSTQ(GProcessor *gp, const int id) $/;"	f	class:LDSTQ
LDSTQ	LDSTQ.h	/^class LDSTQ {$/;"	c
LDSTQ_H	LDSTQ.h	24;"	d
LOCAL_WRITE	Profile.h	32;"	d
LOGMSG	BulkManager.cpp	27;"	d	file:
LSDelay	Resource.h	/^  const TimeDelta_t LSDelay;$/;"	m	class:FULoad
LSQBanks	Resource.h	/^  const int LSQBanks;$/;"	m	class:MemResource
LVID	FetchEngine.h	/^  GLVID       *LVID;$/;"	m	class:FetchEngine
LVPT	VPred.h	/^  ValueType *LVPT;$/;"	m	class:BHLVPred
LVPT	VPred.h	/^  ValueType *LVPT;$/;"	m	class:ELVPred
LVPT	VPred.h	/^  ValueType *LVPT;$/;"	m	class:LVPred
LVPTa	VPred.h	/^  ValueType *LVPTa;$/;"	m	class:SPred
LVPTb	VPred.h	/^  ValueType *LVPTb;$/;"	m	class:SPred
LVPred	VPred.cpp	/^LVPred::LVPred(unsigned size, const char *name) :$/;"	f	class:LVPred
LVPred	VPred.h	/^class LVPred : public GValuePredictor {$/;"	c
LargeCount	AdvancedStats.h	/^  typedef long long unsigned int LargeCount;$/;"	t	namespace:Stats
LevelType	MemObj.h	/^  typedef std::vector<MemObj*> LevelType;$/;"	t	class:MemObj
Line	CPPred.h	/^  typedef CacheGeneric<CPPredEntry,ulonglong>::CacheLine Line;$/;"	t	class:CPPred
LocalHistory	CriticalityManager.h	/^  LocalHistory,$/;"	e	enum:__anon1
LocalHybrid	CriticalityPredictor.h	/^  LocalHybrid,$/;"	e	enum:__anon2
LocalHybridCPred	CriticalityPredictor.cpp	/^LocalHybridCPred::LocalHybridCPred(const char* section)$/;"	f	class:LocalHybridCPred
LocalHybridCPred	CriticalityPredictor.h	/^class LocalHybridCPred : public SquashOnlyCPred {$/;"	c
Log2PageSize	GMemorySystem.cpp	/^ushort GMemorySystem::Log2PageSize=0;$/;"	m	class:GMemorySystem	file:
Log2PageSize	GMemorySystem.h	/^  static ushort Log2PageSize;$/;"	m	class:GMemorySystem
MACacheState	MemAnalyzer.h	/^class MACacheState : public StateGeneric<> {$/;"	c
MACacheType	MemAnalyzer.h	/^  typedef CacheGeneric<MACacheState,PAddr> MACacheType;$/;"	t	class:MemAnalyzer
MAX	CriticalityPredictor.cpp	4;"	d	file:
MAX	CriticalityPredictor.h	516;"	d
MAXCHUNKSIZE	BulkManager.h	19;"	d
MAXTHETA	BPred.h	/^  int MAXTHETA;$/;"	m	class:BPOgehl
MAX_FILENAME_LENGTH	SysCall.h	94;"	d
MAX_PENDING_SOURCES	DInst.h	/^  static const int MAX_PENDING_SOURCES=2;$/;"	m	class:DInst
MEMANALYZER_H	MemAnalyzer.h	23;"	d
MEMBUFFER_H	MemBuffer.h	25;"	d
MEMOBJ_H	MemObj.h	25;"	d
MEMREQUEST_H	MemRequest.h	24;"	d
MFThreshold	TaskContext.cpp	/^size_t TaskContext::MFThreshold;$/;"	m	class:TaskContext	file:
MFThreshold	TaskContext.h	/^  static size_t MFThreshold; \/\/ Merge First Threshold$/;"	m	class:TaskContext
MINITAG	BPred.h	/^  char *MINITAG;$/;"	m	class:BPOgehl
MLThreshold	TaskContext.cpp	/^size_t TaskContext::MLThreshold;$/;"	m	class:TaskContext	file:
MLThreshold	TaskContext.h	/^  static size_t MLThreshold; \/\/ Merge Last Threshold$/;"	m	class:TaskContext
M_SIZ	BPred.h	/^  const int M_SIZ;$/;"	m	class:BPOgehl
MapMemOpsType	MemBuffer.h	/^typedef HASH_MAP<ulong, MemOpsType::iterator> MapMemOpsType;$/;"	t
MarkovAP	MemAnalyzer.cpp	/^MarkovAP::MarkovAP(const char *name, const char *pbsec, int ts, int tw) $/;"	f	class:MarkovAP
MarkovAP	MemAnalyzer.h	/^class MarkovAP : public GAddressPredictor {$/;"	c
MarkovPred	CriticalityPredictor.h	/^  MarkovPred() {}$/;"	f	class:MarkovPred
MarkovPred	CriticalityPredictor.h	/^class MarkovPred {$/;"	c
MaxFlows	GProcessor.h	/^  const size_t MaxFlows;$/;"	m	class:GProcessor
MaxIRequests	Pipeline.h	/^  const int MaxIRequests;$/;"	m	class:Pipeline
MaxNoRetResp	Resource.h	/^  MaxNoRetResp$/;"	e	enum:NoRetResp
MaxPredType	CriticalityPredictor.h	/^  MaxPredType$/;"	e	enum:__anon2
MaxROBSize	GProcessor.h	/^  const size_t MaxROBSize;$/;"	m	class:GProcessor
MaxRetOutcome	Resource.h	/^  MaxRetOutcome$/;"	e	enum:RetOutcome
MaxStall	Resource.h	/^  MaxStall$/;"	e	enum:StallCause
MaxThreadsHist	TaskContext.h	/^  static const size_t MaxThreadsHist=16;$/;"	m	class:TaskContext
MaxValue	ValueTable.h	/^    static const int MaxValue = (1<<2)-1;$/;"	m	class:ValueTable::PredEntry
MaxWinSize	Cluster.h	/^  const long MaxWinSize;$/;"	m	class:Cluster
MemAnalyzer	MemAnalyzer.cpp	/^MemAnalyzer::MemAnalyzer() $/;"	f	class:MemAnalyzer
MemAnalyzer	MemAnalyzer.h	/^class MemAnalyzer {$/;"	c
MemBuffer	MemBuffer.h	/^  MemBuffer()  $/;"	f	class:MemBuffer
MemBuffer	MemBuffer.h	/^class MemBuffer {$/;"	c
MemBufferDomain	MemBuffer.h	/^class MemBufferDomain {$/;"	c
MemBufferEntry	MemBuffer.cpp	/^MemBufferEntry::MemBufferEntry()$/;"	f	class:MemBufferEntry
MemBufferEntry	MemBuffer.h	/^class MemBufferEntry {$/;"	c
MemBufferEntryLessThan	MemBuffer.h	/^struct MemBufferEntryLessThan {$/;"	s
MemLastOp	MemRequest.h	/^  MemLastOp \/\/ just to get the size of the enumeration$/;"	e	enum:MemOperation
MemObj	MemObj.cpp	/^MemObj::MemObj(const char *section, const char *sName)$/;"	f	class:MemObj
MemObj	MemObj.h	/^class MemObj {$/;"	c
MemObjCaseeqstr	GMemorySystem.h	/^class MemObjCaseeqstr {$/;"	c
MemObjHashFunc	MemObj.h	/^class MemObjHashFunc {$/;"	c
MemObjList	MemObj.h	/^  typedef HASH_MAP<MemObj *, MemObj *, MemObjHashFunc> MemObjList;$/;"	t	class:MemObj
MemOperation	MemRequest.h	/^enum MemOperation {$/;"	g
MemOpsType	MemBuffer.h	/^typedef std::set<MemBufferEntry *, MemBufferEntryLessThan> MemOpsType;$/;"	t
MemPush	MemRequest.h	/^  MemPush,$/;"	e	enum:MemOperation
MemRead	MemRequest.h	/^  MemRead = 0,$/;"	e	enum:MemOperation
MemReadW	MemRequest.h	/^  MemReadW,                  \/\/ store that misses and needs data,$/;"	e	enum:MemOperation
MemRequest	MemRequest.cpp	/^MemRequest::MemRequest()$/;"	f	class:MemRequest
MemRequest	MemRequest.h	/^class MemRequest {$/;"	c
MemRequestHashFunc	MemRequest.h	/^class MemRequestHashFunc {$/;"	c
MemResource	Resource.cpp	/^MemResource::MemResource(Cluster *cls$/;"	f	class:MemResource
MemResource	Resource.h	/^class MemResource : public Resource {$/;"	c
MemWrite	MemRequest.h	/^  MemWrite,$/;"	e	enum:MemOperation
MemoryBlockConstantsEnum	Checkpoint.h	/^    enum MemoryBlockConstantsEnum{$/;"	g	class:tls::Checkpoint
MemoryObjContainer	GMemorySystem.h	/^class MemoryObjContainer {$/;"	c
MergEnum	Epoch.h	/^      enum MergEnum {PassiveMerge, ActiveMerge}                merg : 1;$/;"	g	struct:tls::Epoch::State
Merging	Epoch.h	/^      enum IterEnum {Initial, PartReplay, FullReplay, Merging} iter : 2;$/;"	e	enum:tls::Epoch::State::IterEnum
MetaHistoryMask	BPred.h	/^  const HistoryType  MetaHistoryMask;$/;"	m	class:BP2BcgSkew
MetaHistorySize	BPred.h	/^  const ushort       MetaHistorySize;$/;"	m	class:BP2BcgSkew
MissPrediction	BPred.h	/^  MissPrediction$/;"	e	enum:PredType
MultiPathManager	MultiManager.cpp	/^MultiPathManager::MultiPathManager(int cpuId)$/;"	f	class:MultiPathManager
MultiPathManager	MultiManager.h	/^class MultiPathManager {$/;"	c
NES	TaskContext.h	/^  long NES; \/\/ Number of Exists to Skipt (mergeNext)$/;"	m	class:TaskContext
NEWEDGEPRED	CriticalityPredictor.h	12;"	d
NEWPRED	CriticalityManager.cpp	1131;"	d	file:
NORMAL	Profile.h	/^  NORMAL=0, \/\/normal selected tasks$/;"	e	enum:Note_t
NTOKENS	CPBuilder.h	8;"	d
NoBTBPrediction	BPred.h	/^  NoBTBPrediction,$/;"	e	enum:PredType
NoCachePorts	Resource.h	/^  NoCachePorts,  \/\/ for stores only$/;"	e	enum:RetOutcome
NoCacheSpace	Resource.h	/^  NoCacheSpace,  \/\/ for stores and ifetch ops only$/;"	e	enum:RetOutcome
NoMigration	OSSim.h	/^  bool NoMigration; \/\/ Configuration option that dissables migration (optional)$/;"	m	class:OSSim
NoPred	CriticalityManager.h	/^  NoPred=0,$/;"	e	enum:__anon1
NoPred	CriticalityPredictor.h	/^  NoPred=0,$/;"	e	enum:__anon2
NoPrediction	BPred.h	/^  NoPrediction,$/;"	e	enum:PredType
NoRetResp	Resource.h	/^enum NoRetResp { \/\/ instruction responsible for stall$/;"	g
NoStall	Resource.h	/^  NoStall=0,$/;"	e	enum:StallCause
NoWait	Epoch.h	/^      enum WaitEnum {NoWait, WaitThreadSafe,$/;"	e	enum:tls::Epoch::State::WaitEnum
NonCritLifetime	CriticalityManager.h	/^  NonCritLifetime(int sid,const char* name="")$/;"	f	class:NonCritLifetime
NonCritLifetime	CriticalityManager.h	/^class NonCritLifetime {$/;"	c
None	Epoch.h	/^	None=0,$/;"	e	enum:tls::Epoch::RaceInfo::RaceType
NotAtomic	Epoch.h	/^      enum AtomEnum {NotAtomic, Atomic}                        atom : 1;$/;"	e	enum:tls::Epoch::State::AtomEnum
NotExecuted	Resource.h	/^  NotExecuted,$/;"	e	enum:RetOutcome
NotFinished	Resource.h	/^  NotFinished,   \/\/ for loads only$/;"	e	enum:RetOutcome
NotSucceeded	Epoch.h	/^      enum SuccEnum {NotSucceeded, WasSucceeded}               succ : 1;$/;"	e	enum:tls::Epoch::State::SuccEnum
Note_t	Profile.h	/^enum Note_t {$/;"	g
NumRunSClockAdj	Epoch.cpp	/^  Stats::Distribution NumRunSClockAdj(&AllStats,"number of run-time SClock adjustments");$/;"	v
OBJS	Makefile	/^OBJS	:=Processor.o GProcessor.o LDSTQ.o SMTProcessor.o DInst.o Pipeline.o \\$/;"	m
OBJS	Makefile	/^OBJS:=DDIS.o $(OBJS)$/;"	m
OSSim	OSSim.cpp	/^OSSim::OSSim(int argc, char **argv, char **envp)$/;"	f	class:OSSim
OSSim	OSSim.h	/^class OSSim {$/;"	c
OneLimFarIndepEpoch	Epoch.cpp	/^  Stats::Distribution OneLimFarIndepEpoch(&AllStats,"one-limit distance to latest independent epoch");$/;"	v
OneLimNumIndepEpochs	Epoch.cpp	/^  Stats::Distribution OneLimNumIndepEpochs(&AllStats,"one-limit number of independent epochs");$/;"	v
OpenFileInfo	SysCall.h	/^    OpenFileInfo(char *name, int flags, mode_t mode, off_t offset)$/;"	f	struct:SysCallFileIO::OpenFileInfo
OpenFileInfo	SysCall.h	/^    OpenFileInfo(const OpenFileInfo &other)$/;"	f	struct:SysCallFileIO::OpenFileInfo
OpenFileInfo	SysCall.h	/^  struct OpenFileInfo{$/;"	s	class:SysCallFileIO
OpenFileVector	SysCall.h	/^  typedef std::vector<OpenFileInfo *> OpenFileVector;$/;"	t	class:SysCallFileIO
OraclePredInfo	CriticalityPredictor.h	/^  class OraclePredInfo {$/;"	c	class:OracularCPred
OraclePredVector	CriticalityPredictor.h	/^  typedef std::vector<OraclePredInfo> OraclePredVector;$/;"	t	class:OracularCPred
Oracular	CriticalityPredictor.h	/^  Oracular,$/;"	e	enum:__anon2
OracularCPred	CriticalityPredictor.cpp	/^OracularCPred::OracularCPred(const char *section)$/;"	f	class:OracularCPred
OracularCPred	CriticalityPredictor.h	/^class OracularCPred : public CriticalityPredictor {$/;"	c
Other	Resource.h	/^  Other,$/;"	e	enum:NoRetResp
Output	Epoch.h	/^	Output=2,$/;"	e	enum:tls::Epoch::RaceInfo::RaceType
OutsBranchesStall	Resource.h	/^  OutsBranchesStall,$/;"	e	enum:StallCause
OutsLoadsStall	Resource.h	/^  OutsLoadsStall,$/;"	e	enum:StallCause
OutsStoresStall	Resource.h	/^  OutsStoresStall,$/;"	e	enum:StallCause
PCState	Profile.h	/^    PCState(PCacheState is=CLEAN) {$/;"	f	class:ProfCache::PCState
PCState	Profile.h	/^  class PCState : public StateGeneric<PAddr> {$/;"	c	class:ProfCache
PCacheState	Profile.h	/^enum PCacheState {CLEAN, DIRTY};$/;"	g
PCacheType	Profile.h	/^  typedef CacheGeneric<PCState,PAddr> PCacheType;$/;"	t	class:ProfCache
PIPELINE_H	Pipeline.h	23;"	d
PREDUP	BPred.h	/^  int PREDUP;$/;"	m	class:BPOgehl
PRED_CHAIN_HEAD	CriticalityPredictor.h	607;"	d
PRED_CURRENT	CriticalityPredictor.h	606;"	d
PRED_HI_CONF_DELTA	CriticalityPredictor.h	612;"	d
PRED_LEASTSPEC	CriticalityPredictor.h	608;"	d
PRED_LO_CONF_DELTA	CriticalityPredictor.h	613;"	d
PRED_NONCRIT	CriticalityPredictor.h	609;"	d
PRED_SQUASH	CriticalityPredictor.h	610;"	d
PRED_THRESHOLD	CriticalityPredictor.cpp	/^int PRED_THRESHOLD=32;$/;"	v
PREFETCH	Profile.h	/^  PREFETCH=999, \/\/prefetch tasks$/;"	e	enum:Note_t
PROCESSID_H	ProcessId.h	25;"	d
PROFILE_H	Profile.h	23;"	d
PageMask	GMemorySystem.cpp	/^long GMemorySystem::PageMask;$/;"	m	class:GMemorySystem	file:
PageMask	GMemorySystem.h	/^  static long   PageMask;$/;"	m	class:GMemorySystem
ParPredefinedBulkManager	BulkManager.cpp	/^ParPredefinedBulkManager::ParPredefinedBulkManager(GProcessor *gp,bool replay):$/;"	f	class:ParPredefinedBulkManager
ParPredefinedBulkManager	BulkManager.h	/^class ParPredefinedBulkManager : public PredefinedBulkManager{$/;"	c
PartReplay	Epoch.h	/^      enum IterEnum {Initial, PartReplay, FullReplay, Merging} iter : 2;$/;"	e	enum:tls::Epoch::State::IterEnum
PassiveMerge	Epoch.h	/^      enum MergEnum {PassiveMerge, ActiveMerge}                merg : 1;$/;"	e	enum:tls::Epoch::State::MergEnum
PathCPred	CriticalityPredictor.h	/^  PathCPred(const char * section)$/;"	f	class:PathCPred
PathCPred	CriticalityPredictor.h	/^class PathCPred  : public IdealPredInfo {$/;"	c
PathEntry	BPred.h	/^  class PathEntry : public StateGeneric<HistoryType> {$/;"	c	class:BPCRap
PathHistoryEntry	BPred.h	/^    PathHistoryEntry() {$/;"	f	class:BPRap::PathHistoryEntry
PathHistoryEntry	BPred.h	/^  class PathHistoryEntry{$/;"	c	class:BPRap
PathPred	CriticalityPredictor.h	/^  PathPred,$/;"	e	enum:__anon2
PidToEpoch	Epoch.h	/^    typedef std::vector<Epoch *> PidToEpoch;$/;"	t	class:tls::Epoch
Pid_tSet	TaskContext.h	/^  typedef std::set<Pid_t> Pid_tSet;$/;"	t	class:TaskContext
PipeIBucketLess	Pipeline.h	/^class PipeIBucketLess {$/;"	c
PipeLength	Pipeline.h	/^  const size_t PipeLength;$/;"	m	class:Pipeline
PipeQueue	Pipeline.cpp	/^PipeQueue::PipeQueue(CPU_t i)$/;"	f	class:PipeQueue
PipeQueue	Pipeline.h	/^class PipeQueue {$/;"	c
Pipeline	Pipeline.cpp	/^Pipeline::Pipeline(size_t s, size_t fetch, int maxReqs)$/;"	f	class:Pipeline
Pipeline	Pipeline.h	/^class Pipeline {$/;"	c
Position	Epoch.h	/^      enum Position { First, Second} myPosition;$/;"	g	struct:tls::Epoch::RaceAddrInfo
PostAccess	Epoch.h	/^	{PreAccess, Acquire, Access, Release, PostAccess}      sync : 3;$/;"	e	enum:tls::Epoch::State::SyncEnum
Pr	CriticalityManager.h	/^  float Pr(int n) {$/;"	f	class:CritLifetime
PrAll	CriticalityManager.h	/^  float PrAll() { return occ? ((float)all) \/ ((float)occ) : 0.00; }$/;"	f	class:CritLifetime
PrCritical	CriticalityManager.h	/^  float PrCritical() { return occ?  ((float)(occ-no)) \/ ((float)occ) :1.00; }$/;"	f	class:NonCritLifetime
PrCritical	CriticalityManager.h	/^  float PrCritical() {$/;"	f	class:PredData
PrGivenParentCrit	CriticalityManager.h	/^  float PrGivenParentCrit() {$/;"	f	class:PredData
PrNever	CriticalityManager.h	/^  float PrNever() { return occ? ((float)no) \/ ((float)occ) : 0.00; }$/;"	f	class:CritLifetime
PrNever	CriticalityManager.h	/^  float PrNever() { return occ?((float)no) \/ ((float)occ) : 0.00; }$/;"	f	class:NonCritLifetime
PrNonCritical	CriticalityManager.h	/^  float PrNonCritical() {$/;"	f	class:PredData
PrResource	CriticalityManager.h	/^  float PrResource() { return occ? ((float)resource.occ) \/ ((float)occ) : 0.00; }$/;"	f	class:NonCritLifetime
PrRestart	CriticalityManager.h	/^  float PrRestart() { return occ? ((float)restart.occ) \/ ((float)occ) : 1.00; }$/;"	f	class:NonCritLifetime
PrSpawn	CriticalityManager.h	/^  float PrSpawn() { return occ? ((float)all) \/ ((float)occ) : 0.00; }$/;"	f	class:CritLifetime
PrSquash	CriticalityManager.h	/^  float PrSquash() { return occ? ((float)(occ-all-no)) \/ ((float)occ) : 0.00; }$/;"	f	class:CritLifetime
PrSync	CriticalityManager.h	/^  float PrSync() { return occ? ((float)sync.occ) \/ ((float)occ) : 0.00; }$/;"	f	class:NonCritLifetime
PreAccess	Epoch.h	/^	{PreAccess, Acquire, Access, Release, PostAccess}      sync : 3;$/;"	e	enum:tls::Epoch::State::SyncEnum
PredData	CriticalityManager.h	/^  PredData(int sid, const char* name="PredData")$/;"	f	class:PredData
PredData	CriticalityManager.h	/^class PredData {$/;"	c
PredEntry	HVersion.h	/^    class PredEntry {$/;"	c	class:HVersion::IDP
PredEntry	ValueTable.cpp	/^ValueTable::PredEntry::PredEntry(int i) $/;"	f	class:ValueTable::PredEntry
PredEntry	ValueTable.h	/^  class PredEntry {$/;"	c	class:ValueTable
PredEntryTag	HVersion.h	/^    typedef unsigned long PredEntryTag;$/;"	t	class:HVersion::IDP
PredIdMap	CavaManager.h	/^  typedef HASH_MAP<MemRequest *, unsigned int, MemRequestHashFunc> PredIdMap;$/;"	t	class:CavaManager
PredIndexPolicy	CPBuilder.h	/^enum PredIndexPolicy{CP_STATIC_ID, CP_TASK_HISTORY, CP_BRANCH_HISTORY, CP_BRANCH_XOR_TASK};$/;"	g
PredInfo	CavaManager.h	/^    PredInfo() {$/;"	f	class:CavaManager::PredInfo
PredInfo	CavaManager.h	/^  class PredInfo {$/;"	c	class:CavaManager
PredInfoMap	CavaManager.h	/^  typedef HASH_MAP<unsigned int, PredInfo> PredInfoMap;$/;"	t	class:CavaManager
PredLinesSet	CavaManager.h	/^    typedef HASH_SET<PAddr> PredLinesSet;$/;"	t	class:CavaManager::CkpInfoEntry
PredType	BPred.h	/^enum PredType {$/;"	g
PredType	HVersion.h	/^    typedef CacheGeneric<PredEntry, PredEntryTag> PredType;$/;"	t	class:HVersion::IDP
PredefinedBulkManager	BulkManager.cpp	/^PredefinedBulkManager::PredefinedBulkManager(GProcessor *gp,bool replay):$/;"	f	class:PredefinedBulkManager
PredefinedBulkManager	BulkManager.h	/^class PredefinedBulkManager: public BulkManager{$/;"	c
PredictorCnt	CriticalityPredictor.h	/^  PredictorCnt()$/;"	f	class:PredictorCnt
PredictorCnt	CriticalityPredictor.h	/^  PredictorCnt(int aMod)$/;"	f	class:PredictorCnt
PredictorCnt	CriticalityPredictor.h	/^class PredictorCnt {$/;"	c
PrefEntry	MemAnalyzer.h	/^  typedef CacheGeneric<PrefState,PAddr>::CacheLine PrefEntry;$/;"	t	class:MarkovAP
PrefEntry	MemAnalyzer.h	/^  typedef CacheGeneric<PrefState,PAddr>::CacheLine PrefEntry;$/;"	t	class:StrideAP
PrefState	MemAnalyzer.h	/^  class PrefState : public StateGeneric<> {$/;"	c	class:MarkovAP
PrefState	MemAnalyzer.h	/^  class PrefState : public StateGeneric<> {$/;"	c	class:StrideAP
PrefTableType	MemAnalyzer.h	/^  typedef CacheGeneric<PrefState,PAddr> PrefTableType;$/;"	t	class:MarkovAP
PrefTableType	MemAnalyzer.h	/^  typedef CacheGeneric<PrefState,PAddr> PrefTableType;$/;"	t	class:StrideAP
ProcSet	CriticalityController.h	/^  typedef HASH_SET<ProcessId*,pointer_hash > ProcSet;$/;"	t	class:CriticalityController
ProcSet	CriticalityManager.h	/^  typedef HASH_SET<ProcessId*,pointer_hash> ProcSet;$/;"	t	class:CritScheduler
ProcessId	ProcessId.h	/^  ProcessId() {$/;"	f	class:ProcessId
ProcessId	ProcessId.h	/^class ProcessId {$/;"	c
ProcessIdCmp	CriticalityManager.h	/^  class ProcessIdCmp {$/;"	c	class:CritScheduler
ProcessIdState	ProcessId.h	/^enum ProcessIdState {$/;"	g
ProcessQueue	ProcessId.h	/^  typedef std::list<ProcessId *> ProcessQueue;$/;"	t	class:ProcessId
Processor	Processor.cpp	/^Processor::Processor(GMemorySystem *gm, CPU_t i)$/;"	f	class:Processor
Processor	Processor.h	/^class Processor:public GProcessor {$/;"	c
ProcessorMultiSet	RunningProcs.h	/^  typedef std::multiset<GProcessor *> ProcessorMultiSet;$/;"	t	class:RunningProcs
ProfCache	Profile.cpp	/^ProfCache::ProfCache()$/;"	f	class:ProfCache
ProfCache	Profile.h	/^class ProfCache {$/;"	c
Profile	Profile.cpp	/^Profile::Profile()$/;"	f	class:Profile
Profile	Profile.h	/^class Profile : public GStats {$/;"	c
RAP_T_NT_ONLY	BPred.h	46;"	d
RAT	Processor.h	/^  DInst *RAT[NumArchRegs];$/;"	m	class:Processor
RATEntry	DInst.h	/^  DInst      **RATEntry;$/;"	m	class:DInst
RCWPFConsistencyPolicy	ConsistencyPolicy.h	/^  RCWPFConsistencyPolicy(GProcessor* gproc) : $/;"	f	class:RCWPFConsistencyPolicy
RCWPFConsistencyPolicy	ConsistencyPolicy.h	/^class RCWPFConsistencyPolicy : public DefaultConsistencyPolicy {$/;"	c
RESOURCE_H	Resource.h	27;"	d
ROB	GProcessor.h	/^  FastQueue<DInst *> ROB;$/;"	m	class:GProcessor
RUNNINGPROCS	RunningProcs.h	24;"	d
RaceAddrInfo	Epoch.h	/^      RaceAddrInfo(Address dAddrV, Position myPosition)$/;"	f	struct:tls::Epoch::RaceAddrInfo
RaceAddrInfo	Epoch.h	/^    struct RaceAddrInfo{$/;"	s	class:tls::Epoch
RaceByAddr	Epoch.h	/^    typedef std::map<Address,RaceInfo *> RaceByAddr;$/;"	t	class:tls::Epoch
RaceByAddrEp	Epoch.h	/^    typedef std::map<Address,RaceAddrInfo *> RaceByAddrEp;$/;"	t	class:tls::Epoch
RaceByEp	Epoch.h	/^    typedef std::map<Epoch *,RaceInfo *> RaceByEp;$/;"	t	class:tls::Epoch
RaceByEpAddr	Epoch.h	/^    typedef std::map<Epoch *,RaceByAddr> RaceByEpAddr;$/;"	t	class:tls::Epoch
RaceGrpIniBuffObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpIniBuffObserver(&AllStats,"bytes of buffer space for the initial race of the group");$/;"	v
RaceGrpIniEpochObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpIniEpochObserver(&AllStats,"number of epochs for the initial race of the group");$/;"	v
RaceGrpIniInstObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpIniInstObserver(&AllStats,"number of instructions for the initial race of the group");$/;"	v
RaceGrpIniVersObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpIniVersObserver(&AllStats,"number of same-block versions for the initial race of the group");$/;"	v
RaceGrpShortBuffObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpShortBuffObserver(&AllStats,"bytes of buffer space for the shortest race of the group");$/;"	v
RaceGrpShortEpochObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpShortEpochObserver(&AllStats,"number of epochs for the shortest race of the group");$/;"	v
RaceGrpShortInstObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpShortInstObserver(&AllStats,"number of instructions for the shortest race of the group");$/;"	v
RaceGrpShortVersObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpShortVersObserver(&AllStats,"number of same-block versions for the shortest race of the group");$/;"	v
RaceGrpWinBuffObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpWinBuffObserver(&AllStats,"bytes of buffer space in the window of the race group");$/;"	v
RaceGrpWinEpochObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpWinEpochObserver(&AllStats,"number of epochs in the window of the race group");$/;"	v
RaceGrpWinInstObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpWinInstObserver(&AllStats,"number of instructions in the window of the race group");$/;"	v
RaceGrpWinVersObserver	Epoch.cpp	/^  Stats::Distribution RaceGrpWinVersObserver(&AllStats,"number of same-block versions in the window of the race group");$/;"	v
RaceInfo	Epoch.h	/^      RaceInfo(Address  addr, Epoch *ep1, Epoch *ep2, RaceType raceType)$/;"	f	struct:tls::Epoch::RaceInfo
RaceInfo	Epoch.h	/^    struct RaceInfo{$/;"	s	class:tls::Epoch
RaceType	Epoch.h	/^      enum RaceType {$/;"	g	struct:tls::Epoch::RaceInfo
RacesPerRaceEpoch	Epoch.cpp	/^    RacesPerRaceEpoch(&AllStats,"total races detected per race epoch"),$/;"	v
RasSize	BPred.h	/^  const ushort RasSize;$/;"	m	class:BPRas
RatsManager	RatsManager.cpp	/^RatsManager::RatsManager(GMemorySystem *gms, int cpuId)$/;"	f	class:RatsManager
RatsManager	RatsManager.h	/^class RatsManager {$/;"	c
RdHit	MemAnalyzer.cpp	/^void DelinquentLoad::RdHit()$/;"	f	class:DelinquentLoad
RdMiss	MemAnalyzer.cpp	/^void DelinquentLoad::RdMiss()$/;"	f	class:DelinquentLoad
Read	Epoch.h	/^      typedef enum AccessTypeEnum {Read, Write} AccessType;$/;"	e	enum:tls::Epoch::TraceAccessEvent::AccessTypeEnum
ReadyState	ProcessId.h	/^  ReadyState,     \/\/ Runnable, but not running$/;"	e	enum:ProcessIdState
RealisticWidth	GProcessor.h	/^  const int RealisticWidth;$/;"	m	class:GProcessor
RegFileDelay	DepWindow.h	/^  const TimeDelta_t RegFileDelay;$/;"	m	class:DepWindow
Release	Epoch.h	/^	{PreAccess, Acquire, Access, Release, PostAccess}      sync : 3;$/;"	e	enum:tls::Epoch::State::SyncEnum
ReplayRelSpeed	Epoch.cpp	/^  Stats::Distribution ReplayRelSpeed(&AllStats,"relative speed of reenactement execution");$/;"	v
ReplayStall	Resource.h	/^  ReplayStall,$/;"	e	enum:StallCause
ReqPath	MemRequest.h	/^  typedef std::vector<ReqPathEntry *> ReqPath;$/;"	t	class:MemRequest
ReqPathEntry	MemRequest.h	/^class ReqPathEntry {$/;"	c
Resource	Resource.cpp	/^Resource::Resource(Cluster *cls, PortGeneric *aGen)$/;"	f	class:Resource
Resource	Resource.h	/^class Resource {$/;"	c
RetOutcome	Resource.h	/^enum RetOutcome {$/;"	g
RetireWidth	GProcessor.h	/^  const int RetireWidth;$/;"	m	class:GProcessor
Retired	Resource.h	/^  Retired=0,$/;"	e	enum:RetOutcome
RetiredCluster	Cluster.h	/^  RetiredCluster(const char *clusterName, GProcessor *gp)$/;"	f	class:RetiredCluster
RetiredCluster	Cluster.h	/^class RetiredCluster : public Cluster {$/;"	c
RiskLoadProf	RiskLoadProf.cpp	/^RiskLoadProf::RiskLoadProf() $/;"	f	class:RiskLoadProf
RiskLoadProf	RiskLoadProf.h	/^class RiskLoadProf {$/;"	c
Running	Epoch.h	/^      enum ExecEnum {Spawning, Running, Waiting, Completed}    exec : 2;$/;"	e	enum:tls::Epoch::State::ExecEnum
RunningProcs	RunningProcs.cpp	/^RunningProcs::RunningProcs()$/;"	f	class:RunningProcs
RunningProcs	RunningProcs.h	/^class RunningProcs {$/;"	c
RunningState	ProcessId.h	/^  RunningState,   \/\/ Running$/;"	e	enum:ProcessIdState
SBimodal	GProcessor.cpp	/^SBimodal::SBimodal(int i, const char *section)$/;"	f	class:SBimodal
SBimodal	GProcessor.h	/^class SBimodal:public SqPred{$/;"	c
SCConsistencyPolicy	ConsistencyPolicy.cpp	/^SCConsistencyPolicy::SCConsistencyPolicy(GProcessor* gproc)$/;"	f	class:SCConsistencyPolicy
SCConsistencyPolicy	ConsistencyPolicy.h	/^class SCConsistencyPolicy : public ConsistencyPolicy{$/;"	c
SCPFConsistencyPolicy	ConsistencyPolicy.cpp	/^SCPFConsistencyPolicy::SCPFConsistencyPolicy(GProcessor* gproc) : $/;"	f	class:SCPFConsistencyPolicy
SCPFConsistencyPolicy	ConsistencyPolicy.h	/^class SCPFConsistencyPolicy : public SCConsistencyPolicy {$/;"	c
SCWBConsistencyPolicy	ConsistencyPolicy.h	/^  SCWBConsistencyPolicy(GProcessor* gproc) : $/;"	f	class:SCWBConsistencyPolicy
SCWBConsistencyPolicy	ConsistencyPolicy.h	/^class SCWBConsistencyPolicy : public SCConsistencyPolicy {$/;"	c
SCWBPFConsistencyPolicy	ConsistencyPolicy.h	/^  SCWBPFConsistencyPolicy(GProcessor* gproc) : $/;"	f	class:SCWBPFConsistencyPolicy
SCWBPFConsistencyPolicy	ConsistencyPolicy.h	/^class SCWBPFConsistencyPolicy : public SCPFConsistencyPolicy {$/;"	c
SCWPFConsistencyPolicy	ConsistencyPolicy.h	/^  SCWPFConsistencyPolicy(GProcessor* gproc) : $/;"	f	class:SCWPFConsistencyPolicy
SCWPFConsistencyPolicy	ConsistencyPolicy.h	/^class SCWPFConsistencyPolicy : public SCPFConsistencyPolicy {$/;"	c
SHybrid	GProcessor.cpp	/^SHybrid::SHybrid(int i, const char *section)$/;"	f	class:SHybrid
SHybrid	GProcessor.h	/^class SHybrid:public SqPred{$/;"	c
SIGNATURE	Makefile	/^SIGNATURE=libcore$/;"	m
SMTPROCESSOR_H	SMTProcessor.h	25;"	d
SMTProcessor	SMTProcessor.cpp	/^SMTProcessor::SMTProcessor(GMemorySystem *gm, CPU_t i)$/;"	f	class:SMTProcessor
SMTProcessor	SMTProcessor.h	/^class SMTProcessor:public GProcessor {$/;"	c
SMTcopy	BPred.h	/^  const bool SMTcopy;$/;"	m	class:BPredictor
SNotSquash	GProcessor.cpp	/^SNotSquash::SNotSquash(int i, const char *section)$/;"	f	class:SNotSquash
SNotSquash	GProcessor.h	/^class SNotSquash:public SqPred{$/;"	c
SPred	VPred.cpp	/^SPred::SPred(unsigned size, const char *name) :$/;"	f	class:SPred
SPred	VPred.h	/^class SPred : public GValuePredictor {$/;"	c
SPredictor	GProcessor.cpp	/^SPredictor::SPredictor(int i, const char *sec)$/;"	f	class:SPredictor
SPredictor	GProcessor.h	/^class SPredictor{$/;"	c
SSquash	GProcessor.cpp	/^SSquash::SSquash(int i, const char *section)$/;"	f	class:SSquash
SSquash	GProcessor.h	/^class SSquash:public SqPred{$/;"	c
STARTDUMP	MemBuffer.cpp	175;"	d	file:
STagged	GProcessor.cpp	/^STagged::STagged(int i, const char *section)$/;"	f	class:STagged
STagged	GProcessor.h	/^class STagged:public SqPred{$/;"	c
SafeOnly	CriticalityManager.h	/^  SafeOnly,$/;"	e	enum:__anon1
SafeOnly	CriticalityPredictor.h	/^  SafeOnly,$/;"	e	enum:__anon2
SafePlus	CriticalityPredictor.h	/^  SafePlus,$/;"	e	enum:__anon2
SafeSort	CriticalityPredictor.h	/^  SafeSort,$/;"	e	enum:__anon2
SafeSortCPred	CriticalityPredictor.h	/^  SafeSortCPred(const char *section=NULL) {}$/;"	f	class:SafeSortCPred
SafeSortCPred	CriticalityPredictor.h	/^class SafeSortCPred : public CriticalityPredictor {$/;"	c
SampleCounts	AdvancedStats.h	/^    typedef std::map<double,LargeCount> SampleCounts;$/;"	t	class:Stats::Distribution
SchedDelay	DepWindow.h	/^  const TimeDelta_t SchedDelay;$/;"	m	class:DepWindow
Second	Epoch.h	/^      enum Position { First, Second} myPosition;$/;"	e	enum:tls::Epoch::RaceAddrInfo::Position
Selector	VPred.cpp	/^Selector::Selector(int size, const char *name, GValuePredictor *p1, GValuePredictor *p2) $/;"	f	class:Selector
Selector	VPred.h	/^class Selector {$/;"	c
Self	Resource.h	/^  Self=0,$/;"	e	enum:NoRetResp
Setltstr	MemObj.cpp	/^class Setltstr {$/;"	c	file:
SimPoint	CriticalityBuilder.cpp	/^void CriticalityBuilder::SimPoint()$/;"	f	class:CriticalityBuilder
SimPoint	CriticalityController.h	/^  static void SimPoint() {}$/;"	f	class:CriticalityController
SimPoint	CriticalityManager.cpp	/^void CriticalityBase::SimPoint()$/;"	f	class:CriticalityBase
SimPoint	CriticalityTC.cpp	/^void CriticalityTC::SimPoint()$/;"	f	class:CriticalityTC
SimulationMark_t	OSSim.h	/^  } SimulationMark_t;$/;"	t	class:OSSim	typeref:struct:OSSim::__anon5
SmallREGStall	Resource.h	/^  SmallREGStall,$/;"	e	enum:StallCause
SmallROBStall	Resource.h	/^  SmallROBStall,$/;"	e	enum:StallCause
SmallWinStall	Resource.h	/^  SmallWinStall,$/;"	e	enum:StallCause
SpLine	CriticalityPredictor.h	/^  typedef CacheGeneric<SpawnState,unsigned int>::CacheLine SpLine;$/;"	t	class:LocalHybridCPred
SpLine	CriticalityPredictor.h	/^  typedef CacheGeneric<SpawnState,unsigned int>::CacheLine SpLine;$/;"	t	class:SpawnOnlyCPred
SpawnInfo	Profile.h	/^  class SpawnInfo {$/;"	c	class:Profile
SpawnOnly	CriticalityPredictor.h	/^  SpawnOnly,$/;"	e	enum:__anon2
SpawnOnlyCPred	CriticalityPredictor.cpp	/^SpawnOnlyCPred::SpawnOnlyCPred(const char* section)$/;"	f	class:SpawnOnlyCPred
SpawnOnlyCPred	CriticalityPredictor.h	/^class SpawnOnlyCPred : public CriticalityPredictor {$/;"	c
SpawnPredCache	CriticalityPredictor.h	/^  typedef CacheGeneric<SpawnState,unsigned int> SpawnPredCache;$/;"	t	class:LocalHybridCPred
SpawnPredCache	CriticalityPredictor.h	/^  typedef CacheGeneric<SpawnState,unsigned int> SpawnPredCache;$/;"	t	class:SpawnOnlyCPred
SpawnState	CriticalityPredictor.h	/^  SpawnState()$/;"	f	class:SpawnState
SpawnState	CriticalityPredictor.h	/^class SpawnState : public StateGeneric<>{$/;"	c
Spawning	Epoch.h	/^      enum ExecEnum {Spawning, Running, Waiting, Completed}    exec : 2;$/;"	e	enum:tls::Epoch::State::ExecEnum
Spec	Epoch.h	/^      enum SpecEnum {Spec, ThreadSafe, GlobalSafe, Committed}  spec : 2;$/;"	e	enum:tls::Epoch::State::SpecEnum
SpecEnum	Epoch.h	/^      enum SpecEnum {Spec, ThreadSafe, GlobalSafe, Committed}  spec : 2;$/;"	g	struct:tls::Epoch::State
SqLine	CriticalityPredictor.h	/^  typedef CacheGeneric<SquashState,unsigned int>::CacheLine SqLine;$/;"	t	class:SquashOnlyCPred
SqPred	GProcessor.cpp	/^SqPred::SqPred(int i, const char *s, const char *name)$/;"	f	class:SqPred
SqPred	GProcessor.h	/^class SqPred{$/;"	c
SqPredCache	CriticalityPredictor.h	/^  typedef CacheGeneric<SquashState,unsigned int> SqPredCache;$/;"	t	class:SquashOnlyCPred
SquashOnly	CriticalityPredictor.h	/^  SquashOnly,$/;"	e	enum:__anon2
SquashOnlyCPred	CriticalityPredictor.cpp	/^SquashOnlyCPred::SquashOnlyCPred(const char* section)$/;"	f	class:SquashOnlyCPred
SquashOnlyCPred	CriticalityPredictor.h	/^class SquashOnlyCPred : public CriticalityPredictor {$/;"	c
SquashState	CriticalityPredictor.h	/^class SquashState : public StateGeneric<>{$/;"	c
SrcAnomaliesPerEpoch	Epoch.cpp	/^  Stats::Distribution SrcAnomaliesPerEpoch(&AllStats,"source anomalies detected per epoch"),$/;"	v
SrcAnomaliesPerSrcRaceEpoch	Epoch.cpp	/^    SrcAnomaliesPerSrcRaceEpoch(&AllStats,"source anomalies detected per source-race epoch"),$/;"	v
SrcRacesPerEpoch	Epoch.cpp	/^    SrcRacesPerEpoch(&AllStats,"source races detected per epoch"),$/;"	v
SrcRacesPerSrcRaceEpoch	Epoch.cpp	/^    SrcRacesPerSrcRaceEpoch(&AllStats,"source races detected per source-race epoch"),$/;"	v
StallCause	Resource.h	/^enum StallCause {$/;"	g
State	Epoch.h	/^      State(void)$/;"	f	struct:tls::Epoch::State
State	Epoch.h	/^    struct State{$/;"	s	class:tls::Epoch
StaticCBMemRequest	MemRequest.cpp	/^StaticCBMemRequest::StaticCBMemRequest(StaticCallbackBase *c)$/;"	f	class:StaticCBMemRequest
StaticCBMemRequest	MemRequest.h	/^class StaticCBMemRequest : public MemRequest {$/;"	c
Stats	AdvancedStats.cpp	/^namespace Stats{$/;"	n	file:
Stats	AdvancedStats.h	/^namespace Stats{$/;"	n
Stats	ProcessId.h	/^  class Stats {$/;"	c	class:ProcessId
StoreMap	VPred.h	/^  typedef HASH_MULTIMAP<PAddr, PAddr> StoreMap;$/;"	t	class:FWPred
StoreQueue	VPred.h	/^  typedef std::deque<StoreMap::iterator> StoreQueue;$/;"	t	class:FWPred
StrCounterType	GMemorySystem.h	/^  typedef HASH_MAP<const char*, unsigned int, HASH<const char*>, MemObjCaseeqstr > StrCounterType;$/;"	t	class:GMemorySystem
StrToMemoryObjMapper	GMemorySystem.h	/^  typedef HASH_MAP<const char *, MemObj *, HASH<const char*>, MemObjCaseeqstr> StrToMemoryObjMapper;$/;"	t	class:MemoryObjContainer
StrideAP	MemAnalyzer.cpp	/^StrideAP::StrideAP(const char *name, const char *pbsec, int ns, int depth, int win)$/;"	f	class:StrideAP
StrideAP	MemAnalyzer.h	/^class StrideAP : public GAddressPredictor {$/;"	c
StrongAfter	Epoch.h	/^      StrongAfter$/;"	e	enum:tls::Epoch::CmpResult
StrongBefore	Epoch.h	/^      StrongBefore,$/;"	e	enum:tls::Epoch::CmpResult
SubLVIDType	GLVID.h	/^typedef ushort SubLVIDType;$/;"	t
SubtaskContext	CriticalityTC.h	/^  SubtaskContext() { init(); }$/;"	f	class:SubtaskContext
SubtaskContext	CriticalityTC.h	/^class SubtaskContext {$/;"	c
SuccEnum	Epoch.h	/^      enum SuccEnum {NotSucceeded, WasSucceeded}               succ : 1;$/;"	g	struct:tls::Epoch::State
SuspendedState	ProcessId.h	/^  SuspendedState, \/\/ Removed from the runQ (suspended)$/;"	e	enum:ProcessIdState
SyncEnum	Epoch.h	/^      enum SyncEnum$/;"	g	struct:tls::Epoch::State
SyncOnRestart	TaskContext.cpp	/^int TaskContext::SyncOnRestart;$/;"	m	class:TaskContext	file:
SyncOnRestart	TaskContext.h	/^  static int  SyncOnRestart; \/\/ # of restarts to support before wait to become safe$/;"	m	class:TaskContext
SysCall	SysCall.h	/^  SysCall(void) : executed(false){$/;"	f	class:SysCall
SysCall	SysCall.h	/^class SysCall{$/;"	c
SysCallClose	SysCall.h	/^  ID(SysCallClose(void){type="SysCallClose";});$/;"	f	class:SysCallClose
SysCallClose	SysCall.h	/^class SysCallClose : public SysCallFileIO{$/;"	c
SysCallCount	Epoch.cpp	/^  Stats::Distribution SysCallCount(&AllStats,"recorded system calls per epoch");$/;"	v
SysCallExit	SysCall.h	/^  ID(SysCallExit(void){type="SysCallExit";});$/;"	f	class:SysCallExit
SysCallExit	SysCall.h	/^class SysCallExit : public SysCall{$/;"	c
SysCallFileIO	SysCall.h	/^class SysCallFileIO : public SysCall{$/;"	c
SysCallFree	SysCall.h	/^  ID(SysCallFree(void){type="SysCallFree";});$/;"	f	class:SysCallFree
SysCallFree	SysCall.h	/^class SysCallFree : public SysCall{$/;"	c
SysCallLog	Epoch.h	/^typedef std::list<SysCall *> SysCallLog;$/;"	t
SysCallMalloc	SysCall.h	/^  ID(SysCallMalloc(void){type="SysCallMalloc";});$/;"	f	class:SysCallMalloc
SysCallMalloc	SysCall.h	/^class SysCallMalloc : public SysCall{$/;"	c
SysCallMmap	SysCall.h	/^  ID(SysCallMmap(void){type="SysCallMmap";});$/;"	f	class:SysCallMmap
SysCallMmap	SysCall.h	/^class SysCallMmap : public SysCall{$/;"	c
SysCallMunmap	SysCall.h	/^  ID(SysCallMunmap(void){type="SysCallMunmap";});$/;"	f	class:SysCallMunmap
SysCallMunmap	SysCall.h	/^class SysCallMunmap : public SysCall{$/;"	c
SysCallOpen	SysCall.h	/^  ID(SysCallOpen(void){type="SysCallOpen";});$/;"	f	class:SysCallOpen
SysCallOpen	SysCall.h	/^class SysCallOpen : public SysCallFileIO{$/;"	c
SysCallRead	SysCall.h	/^  ID(SysCallRead(void){type="SysCallRead";});$/;"	f	class:SysCallRead
SysCallRead	SysCall.h	/^class SysCallRead : public SysCallFileIO {$/;"	c
SysCallSescSpawn	SysCall.h	/^  ID(SysCallSescSpawn(void){type="SysCallSescSpawn";});$/;"	f	class:SysCallSescSpawn
SysCallSescSpawn	SysCall.h	/^class SysCallSescSpawn : public SysCall{$/;"	c
SysCallTimes	SysCall.h	/^  ID(SysCallTimes(void){type="SysCallTimes";});$/;"	f	class:SysCallTimes
SysCallTimes	SysCall.h	/^class SysCallTimes : public SysCall{$/;"	c
SysCallWait	SysCall.h	/^  ID(SysCallWait(void){type="SysCallWait";});$/;"	f	class:SysCallWait
SysCallWait	SysCall.h	/^class SysCallWait : public SysCall{$/;"	c
SysCallWrite	SysCall.h	/^  ID(SysCallWrite(void){type="SysCallWrite";});$/;"	f	class:SysCallWrite
SysCallWrite	SysCall.h	/^class SysCallWrite : public SysCallFileIO {$/;"	c
T	BPred.h	/^  int *T;$/;"	m	class:BPOgehl
TASKCONTEXT_H	TaskContext.h	27;"	d
TASKHANDLER_H	TaskHandler.h	23;"	d
TC	BPred.h	/^  int TC;$/;"	m	class:BPOgehl
THETA	BPred.h	/^  int THETA;$/;"	m	class:BPOgehl
THETAUP	BPred.h	/^  int THETAUP;$/;"	m	class:BPOgehl
TIMELINEMANAGER_H	TimelineManager.h	24;"	d
TLBTranslate	GMemoryOS.cpp	/^long DummyMemoryOS::TLBTranslate(unsigned long vAddr)$/;"	f	class:DummyMemoryOS
TaskContext	TaskContext.cpp	/^TaskContext::TaskContext()$/;"	f	class:TaskContext
TaskContext	TaskContext.h	/^class TaskContext {$/;"	c
TaskEntriesType	TaskContext.h	/^  typedef HASH_MAP<PAddr, TaskEntry *> TaskEntriesType;$/;"	t	class:TaskContext
TaskEntry	TaskContext.h	/^    TaskEntry() {$/;"	f	class:TaskContext::TaskEntry
TaskEntry	TaskContext.h	/^  class TaskEntry {$/;"	c	class:TaskContext
TaskHandler	TaskHandler.h	/^class TaskHandler {$/;"	c
TaskInfo	Profile.h	/^    TaskInfo() {$/;"	f	class:Profile::TaskInfo
TaskInfo	Profile.h	/^  class TaskInfo {$/;"	c	class:Profile
TaskInfoType	Profile.h	/^  typedef HASH_MAP<int,TaskInfo> TaskInfoType;$/;"	t	class:Profile
Thread	Epoch.cpp	/^  Thread::Thread(ThreadID tid)$/;"	f	class:tls::Thread
Thread	Epoch.h	/^  class Thread{$/;"	c	namespace:tls
ThreadExeOrder	Checkpoint.cpp	/^    ThreadExeOrder(const ThreadExeOrder &other){$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
ThreadExeOrder	Checkpoint.cpp	/^    ThreadExeOrder(void)$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
ThreadExeOrder	Checkpoint.cpp	/^  class Checkpoint::ExeOrder::ThreadExeOrder{$/;"	c	class:tls::Checkpoint::ExeOrder	file:
ThreadExeOrders	Checkpoint.h	/^      typedef std::vector<ThreadExeOrder *> ThreadExeOrders;$/;"	t	class:tls::Checkpoint::ExeOrder
ThreadID	Epoch.h	/^  typedef Pid_t ThreadID;$/;"	t	namespace:tls
ThreadIndex	Epoch.h	/^    typedef ThreadVector::size_type ThreadIndex;$/;"	t	class:tls::Thread
ThreadSafe	Epoch.h	/^      enum SpecEnum {Spec, ThreadSafe, GlobalSafe, Committed}  spec : 2;$/;"	e	enum:tls::Epoch::State::SpecEnum
ThreadVector	Epoch.h	/^    typedef std::vector<Thread *> ThreadVector;$/;"	t	class:tls::Thread
Tid2TaskContextType	TaskContext.h	/^  typedef std::vector<TaskContext *> Tid2TaskContextType;$/;"	t	class:TaskContext
TimelineManager	TimelineManager.h	/^class TimelineManager {$/;"	c
Token	CPBuilder.h	/^      Token() { invalidate(); tracePrediction = false; }$/;"	f	struct:CPBuilder::Token
Token	CPBuilder.h	/^    struct Token {$/;"	s	class:CPBuilder
TokenContainer	CPBuilder.h	/^    TokenContainer() {$/;"	f	class:TokenContainer
TokenContainer	CPBuilder.h	/^class TokenContainer$/;"	c
TraceAccessEvent	Epoch.h	/^      TraceAccessEvent(Epoch *epoch, Address dAddrV, AccessType accessType)$/;"	f	class:tls::Epoch::TraceAccessEvent
TraceAccessEvent	Epoch.h	/^    class TraceAccessEvent : public TraceEvent{$/;"	c	class:tls::Epoch
TraceEvent	Epoch.h	/^      TraceEvent(Epoch *epoch){$/;"	f	class:tls::Epoch::TraceEvent
TraceEvent	Epoch.h	/^    class TraceEvent{$/;"	c	class:tls::Epoch
TraceList	Epoch.h	/^    typedef std::list<TraceEvent *> TraceList;$/;"	t	class:tls::Epoch
TwoLimFarIndepEpoch	Epoch.cpp	/^  Stats::Distribution TwoLimFarIndepEpoch(&AllStats,"two-limit distance to latest independent epoch");$/;"	v
TwoLimNumIndepEpochs	Epoch.cpp	/^  Stats::Distribution TwoLimNumIndepEpochs(&AllStats,"two-limit number of independet epochs");$/;"	v
UnitEntry	Cluster.cpp	/^struct UnitEntry {$/;"	s	file:
UnitMapType	Cluster.cpp	/^typedef HASH_MAP<const char *,UnitEntry, HASH<const char*>, eqstr> UnitMapType;$/;"	t	file:
Unordered	Epoch.h	/^      Unordered,$/;"	e	enum:tls::Epoch::CmpResult
Unordered	Epoch.h	/^    enum CmpResult { Before, Unordered, After };$/;"	e	enum:tls::VClock::CmpResult
VALUETABLE_H	ValueTable.h	25;"	d
VClock	Epoch.h	/^    VClock(const VClock &other)$/;"	f	class:tls::VClock
VClock	Epoch.h	/^    VClock(size_type index)$/;"	f	class:tls::VClock
VClock	Epoch.h	/^    VClock(void)$/;"	f	class:tls::VClock
VClock	Epoch.h	/^  class VClock{$/;"	c	namespace:tls
VClockList	Epoch.h	/^    typedef std::list<VClock *> VClockList;$/;"	t	class:tls::VClock
VDomainVectorType	HVersion.h	/^  typedef std::vector<HVersionDomain *> VDomainVectorType;$/;"	t	class:HVersionDomain
VPMode	CavaManager.h	/^  enum VPMode { eager, atHeadROB, whenStall };$/;"	g	class:CavaManager
VPRED_H	VPred.h	23;"	d
VPT	VPred.h	/^  ValueType *VPT;$/;"	m	class:FWPred
VPredTableType	MemAnalyzer.h	/^  typedef std::vector<GValuePredictor*> VPredTableType;$/;"	t	class:MemAnalyzer
VSelTableType	MemAnalyzer.h	/^  typedef std::vector<Selector *> VSelTableType;$/;"	t	class:MemAnalyzer
VT	VPred.h	/^  unsigned *VT;$/;"	m	class:FCMPred
VTable	ValueTable.h	/^    typedef HASH_MAP<int, PredEntry*> VTable;$/;"	t	class:ValueTable::PredEntry
VType	ASVersion.h	/^  typedef long long VType;$/;"	t	class:HVersion
VType	HVersion.h	/^  typedef unsigned long long VType;$/;"	t	class:HVersion
ValueTable	ValueTable.cpp	/^ValueTable::ValueTable()$/;"	f	class:ValueTable
ValueTable	ValueTable.h	/^class ValueTable {$/;"	c
ValueType	VPred.h	/^typedef unsigned long long ValueType;$/;"	t
VersionCount	Epoch.h	/^      VersionCount(void)$/;"	f	struct:tls::Epoch::VersionCount
VersionCount	Epoch.h	/^    struct VersionCount{$/;"	s	class:tls::Epoch
VersionCounts	Epoch.h	/^    struct VersionCounts{$/;"	s	class:tls::Epoch
WRITE_REVISE	Profile.h	33;"	d
WaitEnum	Epoch.h	/^      enum WaitEnum {NoWait, WaitThreadSafe,$/;"	g	struct:tls::Epoch::State
WaitForFence	Resource.h	/^  WaitForFence,  \/\/ for ifetch ops only$/;"	e	enum:RetOutcome
WaitFullyMerged	Epoch.h	/^		     WaitGlobalSafe, WaitFullyMerged}          wait : 2;$/;"	e	enum:tls::Epoch::State::WaitEnum
WaitGlobalSafe	Epoch.h	/^		     WaitGlobalSafe, WaitFullyMerged}          wait : 2;$/;"	e	enum:tls::Epoch::State::WaitEnum
WaitThreadSafe	Epoch.h	/^      enum WaitEnum {NoWait, WaitThreadSafe,$/;"	e	enum:tls::Epoch::State::WaitEnum
Waiting	Epoch.h	/^      enum ExecEnum {Spawning, Running, Waiting, Completed}    exec : 2;$/;"	e	enum:tls::Epoch::State::ExecEnum
WaitingAcquirers	Epoch.cpp	/^  Stats::Distribution WaitingAcquirers(&AllStats,"number of waiting acquirers for a sync action");$/;"	v
WaitingState	ProcessId.h	/^  WaitingState,   \/\/ Removed from the runQ and waiting until a child finishes$/;"	e	enum:ProcessIdState
WakeUpDelay	DepWindow.h	/^  const TimeDelta_t WakeUpDelay;$/;"	m	class:DepWindow
WasSucceeded	Epoch.h	/^      enum SuccEnum {NotSucceeded, WasSucceeded}               succ : 1;$/;"	e	enum:tls::Epoch::State::SuccEnum
WeakAfter	Epoch.h	/^      WeakAfter,$/;"	e	enum:tls::Epoch::CmpResult
WeakBefore	Epoch.h	/^      WeakBefore,$/;"	e	enum:tls::Epoch::CmpResult
Write	Epoch.h	/^      typedef enum AccessTypeEnum {Read, Write} AccessType;$/;"	e	enum:tls::Epoch::TraceAccessEvent::AccessTypeEnum
WriteInfo	Profile.h	/^    WriteInfo() {$/;"	f	class:Profile::WriteInfo
WriteInfo	Profile.h	/^  class WriteInfo {$/;"	c	class:Profile
WriteInfoType	Profile.h	/^  typedef HASH_MAP<VAddr, WriteInfo>  WriteInfoType;$/;"	t	class:Profile
WriteList	Profile.h	/^  typedef SLIST<WriteInfo *> WriteList;$/;"	t	class:Profile
XACTION_MANAGER_H	XactionManager.h	24;"	d
XactionManager	XactionManager.cpp	/^XactionManager::XactionManager(int cpuId)$/;"	f	class:XactionManager
XactionManager	XactionManager.h	/^class XactionManager {$/;"	c
ZeroPred	VPred.cpp	/^ZeroPred::ZeroPred (const char *name) :$/;"	f	class:ZeroPred
ZeroPred	VPred.h	/^class ZeroPred : public GValuePredictor {$/;"	c
_AdvancedStats_hpp_	AdvancedStats.h	2;"	d
_Checkpoint_hpp_	Checkpoint.h	2;"	d
_Epoch_hpp_	Epoch.h	2;"	d
_MAKEFILE_COMMON_SUBSHELL	Makefile	/^_MAKEFILE_COMMON_SUBSHELL=1$/;"	m
_OSSim_H_	OSSim.h	31;"	d
_PROCESSOR_H_	Processor.h	25;"	d
_RISK_LOAD_PROF_H	RiskLoadProf.h	22;"	d
_SysCall_h_	SysCall.h	2;"	d
_singleton	CPBuilder.cpp	/^CPBuilder *CPBuilder::_singleton;$/;"	m	class:CPBuilder	file:
_singleton	CPBuilder.h	/^    static CPBuilder *_singleton;$/;"	m	class:CPBuilder
aPredictors	MemAnalyzer.h	/^  APredTableType aPredictors;$/;"	m	class:MemAnalyzer
access	Epoch.cpp	/^  void Epoch::BlockVersions::access(bool isWrite, BufferBlock *currBlock, BlockPosition &blockPos){$/;"	f	class:tls::Epoch::BlockVersions
access	MemAnalyzer.cpp	/^bool GAddressPredictor::access(PAddr addr)$/;"	f	class:GAddressPredictor
access	MemObj.cpp	/^void DummyMemObj::access(MemRequest *req)    $/;"	f	class:DummyMemObj
access	MemRequest.cpp	/^void MemRequest::access()$/;"	f	class:MemRequest
accessBitMask	Epoch.cpp	/^  const Epoch::ChunkBitMask Epoch::accessBitMask[16][chunkSize]={$/;"	m	class:tls::Epoch	file:
accessBitMask	Epoch.h	/^    static const ChunkBitMask accessBitMask[16][chunkSize];$/;"	m	class:tls::Epoch
accessBitMask	MemBuffer.cpp	/^const BitMaskType MemBufferEntry::accessBitMask[16][chunkSize]={$/;"	m	class:MemBufferEntry	file:
accessBitMask	MemBuffer.h	/^  static const BitMaskType accessBitMask[16][chunkSize];$/;"	m	class:MemBufferEntry
accessCB	MemRequest.h	/^  StaticCallbackMember0<MemRequest, &MemRequest::access> accessCB;$/;"	m	class:MemRequest
accessCount	Epoch.h	/^      size_t accessCount;$/;"	m	class:tls::Epoch::TraceAccessEvent
accessEvents	Epoch.h	/^    EventSet accessEvents;$/;"	m	class:tls::Epoch
accessTime	MemRequest.h	/^  Time_t accessTime;$/;"	m	class:ReqPathEntry
accessType	Epoch.h	/^      AccessType accessType;$/;"	m	class:tls::Epoch::TraceAccessEvent
accessors	Epoch.h	/^      BufferBlockList accessors;$/;"	m	class:tls::Epoch::BlockVersions
accessorsCount	Epoch.h	/^      size_t accessorsCount;$/;"	m	class:tls::Epoch::BlockVersions
accessorsPos	Epoch.h	/^      BlockVersions::BufferBlockList::iterator accessorsPos;$/;"	m	class:tls::Epoch::BufferBlock
ack	MemRequest.cpp	/^void CBMemRequest::ack(TimeDelta_t lat)$/;"	f	class:CBMemRequest
ack	MemRequest.cpp	/^void DMemRequest::ack(TimeDelta_t lat)$/;"	f	class:DMemRequest
ack	MemRequest.cpp	/^void IMemRequest::ack(TimeDelta_t lat)$/;"	f	class:IMemRequest
ack	MemRequest.cpp	/^void StaticCBMemRequest::ack(TimeDelta_t lat)$/;"	f	class:StaticCBMemRequest
ackDone	MemRequest.h	/^  bool ackDone;$/;"	m	class:StaticCBMemRequest
actPool	MemRequest.h	/^  static pool<CBMemRequest, true> actPool;$/;"	m	class:CBMemRequest
actPool	MemRequest.h	/^  static pool<DMemRequest, true> actPool;$/;"	m	class:DMemRequest
actPool	MemRequest.h	/^  static pool<IMemRequest, true> actPool;$/;"	m	class:IMemRequest
action	CriticalityPredictor.h	/^  bool action;$/;"	m	class:EdgeCPred
action	CriticalityPredictor.h	/^  bool action;$/;"	m	class:PathCPred
action	MemRequest.h	/^  const char *action;$/;"	m	class:ReqPathEntry
activeChain	CriticalityPredictor.h	/^  EdgeChain  *activeChain;$/;"	m	class:EdgeCPred
activeMerging	Epoch.cpp	/^  Epoch *Epoch::activeMerging=0;$/;"	m	class:tls::Epoch	file:
activeMerging	Epoch.h	/^    static Epoch *activeMerging;$/;"	m	class:tls::Epoch
activeWaitMerge	Epoch.cpp	/^  EpochSet Epoch::activeWaitMerge;$/;"	m	class:tls::Epoch	file:
activeWaitMerge	Epoch.h	/^    static EpochSet activeWaitMerge;$/;"	m	class:tls::Epoch
actualHit	CavaManager.h	/^  GStatsCntr actualHit;$/;"	m	class:CavaManager
actualMiss	CavaManager.h	/^  GStatsCntr actualMiss;$/;"	m	class:CavaManager
adapt	CriticalityController.h	/^  bool adapt;$/;"	m	class:CriticalityController
adapt	CriticalityManager.h	/^  bool adapt;$/;"	m	class:CriticalityManager
adaptCores	CriticalityController.cpp	/^void CriticalityController::adaptCores( std::vector<int> &newVfpairs )$/;"	f	class:CriticalityController
adaptCores	CriticalityManager.cpp	/^void CriticalityManager::adaptCores( std::vector<int> &newVfpairs )$/;"	f	class:CriticalityManager
add	CriticalityController.cpp	/^void CriticalityController::add(Pid_t pid, int priority)$/;"	f	class:CriticalityController
add	CriticalityManager.cpp	/^void CritScheduler::add(Pid_t pid, int priority)$/;"	f	class:CritScheduler
add	CriticalityPredictor.h	/^  void add(int sid) {$/;"	f	class:MarkovPred
add	Epoch.h	/^      void  add(const Epoch *epoch){$/;"	f	struct:tls::Epoch::VersionCounts
add	Epoch.h	/^      void add(const BufferBlock *bufferBlock){$/;"	f	struct:tls::Epoch::VersionCounts
addAccessEvent	Epoch.h	/^    void addAccessEvent(TraceAccessEvent *event){$/;"	f	class:tls::Epoch
addChain	CriticalityPredictor.cpp	/^bool EdgeCPred::addChain(ProcessId *newStream, int pri) {$/;"	f	class:EdgeCPred
addCommitedTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::addCommitedTask(CriticalityTC &tc)$/;"	f	class:CriticalityBuilder
addCommitedTask	CriticalityManager.cpp	/^void CriticalityBase::addCommitedTask(CriticalityTC &tc)$/;"	f	class:CriticalityBase
addDInst	BulkManager.cpp	/^void BulkManager::Chunk::addDInst(DInst *dinst, bool fwd)$/;"	f	class:BulkManager::Chunk
addDataDepViolation	DInst.cpp	/^void DInst::addDataDepViolation(const HVersion *ver)$/;"	f	class:DInst
addDataDepViolation	TaskContext.h	/^  int addDataDepViolation() {$/;"	f	class:TaskContext
addEpoch	Epoch.cpp	/^  EpochList::iterator Thread::addEpoch(Epoch *epoch){$/;"	f	class:tls::Thread
addEvent	DInst.h	/^  void addEvent(CallbackBase *cb) {$/;"	f	class:DInst
addEvent	FetchEngine.h	/^  void addEvent(EventType ev, CallbackBase *cb, long vaddr) {$/;"	f	class:FetchEngine
addEvent	GProcessor.cpp	/^void GProcessor::addEvent(EventType ev, CallbackBase *cb, long vaddr)$/;"	f	class:GProcessor
addFakeSrc	DInst.h	/^  void addFakeSrc(DInst * d) {$/;"	f	class:DInst
addGroupToStagingWin	CriticalityBuilder.h	/^  void addGroupToStagingWin(CPNodeGroup *g) {$/;"	f	class:CriticalityBuilder
addGroupToStagingWin	CriticalityManager.h	/^  void addGroupToStagingWin(CPNodeGroup *g) {$/;"	f	class:CriticalityBase
addGroupToStagingWinBefore	CriticalityBuilder.cpp	/^void CriticalityBuilder::addGroupToStagingWinBefore(CPNodeGroup *g,$/;"	f	class:CriticalityBuilder
addGroupToStagingWinBefore	CriticalityManager.cpp	/^void CriticalityBase::addGroupToStagingWinBefore(CPNodeGroup *g,$/;"	f	class:CriticalityBase
addGroupToWindow	CriticalityBuilder.h	/^  void addGroupToWindow(CPNodeGroup *g) {$/;"	f	class:CriticalityBuilder
addGroupToWindow	CriticalityManager.h	/^  void addGroupToWindow(CPNodeGroup *g) {$/;"	f	class:CriticalityBase
addInitWaitTime	TaskContext.h	/^  void addInitWaitTime(void)       { tmpAddedWaitTime += (globalClock - tmpInitWaitTime);}\/\/waitTime->add(globalClock - tmpInitWaitTime);}$/;"	f	class:TaskContext
addInst	Cluster.h	/^  void addInst(DInst *dinst) {$/;"	f	class:Cluster
addInst	DepWindow.cpp	/^void DepWindow::addInst(DInst *dinst)$/;"	f	class:DepWindow
addInst	Processor.cpp	/^StallCause Processor::addInst(DInst *dinst) $/;"	f	class:Processor
addInst	SMTProcessor.cpp	/^StallCause SMTProcessor::addInst(DInst *dinst) $/;"	f	class:SMTProcessor
addKilledTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::addKilledTask(CriticalityTC &tc)$/;"	f	class:CriticalityBuilder
addKilledTask	CriticalityBuilder.cpp	/^void CriticalityBuilderIface::addKilledTask(CriticalityTC &tc)$/;"	f	class:CriticalityBuilderIface
addKilledTask	CriticalityManager.cpp	/^void CriticalityBase::addKilledTask(CriticalityTC &tc)$/;"	f	class:CriticalityBase
addKilledTask	CriticalityTC.cpp	/^void CriticalityTC::addKilledTask() {$/;"	f	class:CriticalityTC
addLowerLevel	MemObj.h	/^  void addLowerLevel(MemObj *obj) { $/;"	f	class:MemObj
addMemoryObj	GMemorySystem.cpp	/^void MemoryObjContainer::addMemoryObj(const char *device_name, MemObj *obj) $/;"	f	class:MemoryObjContainer
addPid	CriticalityController.cpp	/^void CriticalityController::addPid(Pid_t pid)$/;"	f	class:CriticalityController
addPrediction	CavaManager.cpp	/^void CavaManager::addPrediction(MemRequest *mreq, unsigned long predId)$/;"	f	class:CavaManager
addPredictor	CriticalityBuilder.cpp	/^void CriticalityBuilderIface::addPredictor(CriticalityPredictor *p)$/;"	f	class:CriticalityBuilderIface
addRace	Epoch.h	/^    void addRace(Epoch *epoch1, Epoch *epoch2,$/;"	f	class:tls::Epoch
addReadAccess	Epoch.h	/^      void addReadAccess(Epoch *epoch, Address dAddrV){$/;"	f	struct:tls::Epoch::RaceAddrInfo
addResourceEdge	CriticalityBuilder.cpp	/^void CriticalityBuilder::addResourceEdge(CPNodeGroup *earlier,$/;"	f	class:CriticalityBuilder
addResourceEdge	CriticalityManager.cpp	/^void CriticalityBase::addResourceEdge(CPNodeGroup *earlier,$/;"	f	class:CriticalityBase
addSample	AdvancedStats.cpp	/^  void Distribution::addSample(const double value){$/;"	f	class:Stats::Distribution
addSample	AdvancedStats.cpp	/^  void Group::addSample(const double value) const{$/;"	f	class:Stats::Group
addSamples	AdvancedStats.cpp	/^  void Distribution::addSamples(const double value, const LargeCount count){$/;"	f	class:Stats::Distribution
addSamples	AdvancedStats.cpp	/^  void Group::addSamples(const double value, const LargeCount count) const{$/;"	f	class:Stats::Group
addSrc1	DInst.h	/^  void addSrc1(DInst * d) {$/;"	f	class:DInst
addSrc2	DInst.h	/^  void addSrc2(DInst * d) {$/;"	f	class:DInst
addStatsNoRetire	GProcessor.h	/^  void addStatsNoRetire(ushort index, DInst *dinst, RetOutcome cause) {$/;"	f	class:GProcessor
addStatsRetire	GProcessor.h	/^  void addStatsRetire(ushort index) {$/;"	f	class:GProcessor
addTask	CriticalityTC.cpp	/^void CriticalityTC::addTask() {$/;"	f	class:CriticalityTC
addToRefTasks	CriticalityTC.cpp	/^void CriticalityTC::addToRefTasks(CritID ref)$/;"	f	class:CriticalityTC
addToReplayQ	GProcessor.cpp	/^void GProcessor::addToReplayQ(DInst *dinst)$/;"	f	class:GProcessor
addToReplayQ	GProcessor.cpp	/^void GProcessor::addToReplayQ(FastQueue<DInst*>* iq){$/;"	f	class:GProcessor
addToWaitingList	BulkManager.cpp	/^void BulkManager::addToWaitingList(Chunk *cc)$/;"	f	class:BulkManager
addTraceEvent	Epoch.h	/^    void addTraceEvent(TraceEvent *traceEvent){$/;"	f	class:tls::Epoch
addType	Epoch.h	/^      void addType(RaceInfo::RaceType newType){$/;"	f	struct:tls::Epoch::RaceAddrInfo
addType	Epoch.h	/^      void addType(RaceType newType){$/;"	f	struct:tls::Epoch::RaceInfo
addUpperCachesTo	MemObj.cpp	/^void MemObj::addUpperCachesTo(MemObjList &list)$/;"	f	class:MemObj
addUpperLevel	MemObj.h	/^  void addUpperLevel(MemObj *obj) { $/;"	f	class:MemObj
addWRMask	MemBuffer.h	/^  void addWRMask(BitMaskType accMask) {$/;"	f	class:MemBufferEntry
addWaitTime	TaskContext.h	/^  void addWaitTime(void)           { tmpAddedWaitTime += (globalClock - tmpWaitTime);}$/;"	f	class:TaskContext
addWriteAccess	Epoch.h	/^      void addWriteAccess(Epoch *epoch, Address dAddrV){$/;"	f	struct:tls::Epoch::RaceAddrInfo
addrShift	BulkManager.cpp	/^int  BulkManager::addrShift;$/;"	m	class:BulkManager	file:
addrShift	BulkManager.h	/^  static int  addrShift;$/;"	m	class:BulkManager
addwidth	BPred.h	/^  const int addwidth;$/;"	m	class:BPOgehl
adjustChildSpawnAddr	TaskContext.cpp	/^PAddr TaskContext::adjustChildSpawnAddr(PAddr childAddr)$/;"	f	class:TaskContext
adjustData	CriticalityManager.h	/^  void adjustData(int s) {$/;"	f	class:CritLifetime
adjustData	CriticalityManager.h	/^  void adjustData(int s) {$/;"	f	class:NonCritLifetime
adjustPredData	CriticalityManager.h	/^  void adjustPredData() {$/;"	f	class:PredData
adjustPriority	CriticalityManager.cpp	/^void CritScheduler::adjustPriority()$/;"	f	class:CritScheduler
adjustSpawnConf	CriticalityPredictor.h	/^  void adjustSpawnConf(ELine *l, int adj) {$/;"	f	class:EdgeCPred
adjustSquashConf	CriticalityPredictor.h	/^  void adjustSquashConf(ELine *l, int adj) {$/;"	f	class:EdgeCPred
adjustTime	Epoch.h	/^      void adjustTime(const Epoch *epoch){$/;"	f	class:tls::Epoch::TraceEvent
adjustWindow	CriticalityBuilder.cpp	/^void CriticalityBuilder::adjustWindow()$/;"	f	class:CriticalityBuilder
adjustWindow	CriticalityManager.cpp	/^void CriticalityBase::adjustWindow()$/;"	f	class:CriticalityBase
advSched	CriticalityController.h	/^  bool advSched;$/;"	m	class:CriticalityController
advance	Epoch.cpp	/^  void Epoch::BlockVersions::advance(BufferBlock *block){$/;"	f	class:tls::Epoch::BlockVersions
advanceClock	Processor.cpp	/^void Processor::advanceClock()$/;"	f	class:Processor
advanceClock	SMTProcessor.cpp	/^void SMTProcessor::advanceClock()$/;"	f	class:SMTProcessor
advanceGlobalSafe	Epoch.cpp	/^  void Epoch::advanceGlobalSafe(void){$/;"	f	class:tls::Epoch
advanceSClock	Epoch.cpp	/^  void Epoch::advanceSClock(const Epoch *predEpoch,bool sync){$/;"	f	class:tls::Epoch
advanceSimPoint	OSSim.cpp	/^void OSSim::advanceSimPoint()$/;"	f	class:OSSim
advanceTimelines	TimelineManager.cpp	/^void TimelineManager::advanceTimelines()$/;"	f	class:TimelineManager
afterResource	CriticalityManager.h	/^  void afterResource(int n) {$/;"	f	class:NonCritLifetime
afterRestart	CriticalityManager.h	/^  void afterRestart(int n) {$/;"	f	class:NonCritLifetime
afterSq	CriticalityController.h	/^  int afterSq;$/;"	m	class:CriticalityController
afterSync	CriticalityManager.h	/^  void afterSync(int n) {$/;"	f	class:NonCritLifetime
aggrSq	CriticalityPredictor.h	/^  bool aggrSq;$/;"	m	class:EdgeCPred
all	CriticalityManager.h	/^  int all; \/\/ until spawn == finish$/;"	m	class:CritLifetime
allCheckpoints	Checkpoint.cpp	/^  Checkpoint::CheckpointList Checkpoint::allCheckpoints;$/;"	m	class:tls::Checkpoint	file:
allCheckpoints	Checkpoint.h	/^    static CheckpointList allCheckpoints;$/;"	m	class:tls::Checkpoint
allCommitInsts	CriticalityTC.h	/^  static GStatsCntr allCommitInsts;$/;"	m	class:CriticalityTC
allEpochs	Epoch.cpp	/^  EpochList Epoch::allEpochs;$/;"	m	class:tls::Epoch	file:
allEpochs	Epoch.h	/^    static EpochList allEpochs;$/;"	m	class:tls::Epoch
allKilledInsts	CriticalityTC.h	/^  static GStatsCntr allKilledInsts;$/;"	m	class:CriticalityTC
allOk	MultiManager.h	/^  bool allOk;$/;"	m	class:MultiPathManager
allSafeInsts	CriticalityTC.h	/^  static GStatsCntr allSafeInsts;$/;"	m	class:CriticalityTC
allSquashedInsts	CriticalityTC.h	/^  static GStatsCntr allSquashedInsts;$/;"	m	class:CriticalityTC
allVClocks	Epoch.cpp	/^  VClock::VClockList VClock::allVClocks;$/;"	m	class:tls::VClock	file:
allVClocks	Epoch.h	/^    static VClockList allVClocks;$/;"	m	class:tls::VClock
alwaysRestart	CavaManager.h	/^  const bool alwaysRestart;$/;"	m	class:CavaManager
analysisDone	Epoch.cpp	/^  EpochSet Epoch::analysisDone;$/;"	m	class:tls::Epoch	file:
analysisDone	Epoch.h	/^    static EpochSet analysisDone;$/;"	m	class:tls::Epoch
analysisNeeded	Epoch.cpp	/^  EpochSet Epoch::analysisNeeded;$/;"	m	class:tls::Epoch	file:
analysisNeeded	Epoch.h	/^    static EpochSet analysisNeeded;$/;"	m	class:tls::Epoch
analysisReady	Epoch.cpp	/^  EpochSet Epoch::analysisReady;$/;"	m	class:tls::Epoch	file:
analysisReady	Epoch.h	/^    static EpochSet analysisReady;$/;"	m	class:tls::Epoch
analyze	CriticalityBuilder.cpp	/^void CriticalityBuilder::analyze()$/;"	f	class:CriticalityBuilder
analyze	CriticalityManager.cpp	/^void CriticalityBase::analyze()$/;"	f	class:CriticalityBase
analyzeEventList	CriticalityPredictor.cpp	/^void EdgeCPred::analyzeEventList(std::vector<ProcessId*> &procVec)$/;"	f	class:EdgeCPred
analyzeProcessList	CriticalityPredictor.cpp	/^void OracularCPred::analyzeProcessList(std::vector<ProcessId*> &procVec)$/;"	f	class:OracularCPred
analyzeWindow	CriticalityBuilder.cpp	/^size_t CriticalityBuilder::analyzeWindow(size_t offset)$/;"	f	class:CriticalityBuilder
analyzeWindow	CriticalityBuilder.cpp	/^size_t CriticalityBuilderIface::analyzeWindow(size_t offset)$/;"	f	class:CriticalityBuilderIface
analyzeWindow	CriticalityManager.cpp	/^size_t CriticalityBase::analyzeWindow(size_t offset)$/;"	f	class:CriticalityBase
analyzeWindow	CriticalityManager.cpp	/^size_t CriticalityManager::analyzeWindow(size_t offset) {$/;"	f	class:CriticalityManager
analyzingNotMergingBufferBlocks	Epoch.cpp	/^  size_t Epoch::analyzingNotMergingBufferBlocks=0;$/;"	m	class:tls::Epoch	file:
analyzingNotMergingBufferBlocks	Epoch.h	/^    static size_t analyzingNotMergingBufferBlocks;$/;"	m	class:tls::Epoch
analyzingNotMergingCount	Epoch.cpp	/^  size_t Epoch::analyzingNotMergingCount=0;$/;"	m	class:tls::Epoch	file:
analyzingNotMergingCount	Epoch.h	/^    static size_t analyzingNotMergingCount;$/;"	m	class:tls::Epoch
analyzingNotMergingInstr	Epoch.cpp	/^  InstrCount Epoch::analyzingNotMergingInstr=(InstrCount)0;$/;"	m	class:tls::Epoch	file:
analyzingNotMergingInstr	Epoch.h	/^    static InstrCount analyzingNotMergingInstr;$/;"	m	class:tls::Epoch
anomalyInstAddr	Epoch.cpp	/^  AddressSet raceInstAddr, anomalyInstAddr;$/;"	v
append	Epoch.h	/^      void append(const BufferBlock *succBlock){$/;"	f	class:tls::Epoch::BufferBlock
appendBuffer	Epoch.cpp	/^  void Epoch::appendBuffer(const Epoch *succEpoch){$/;"	f	class:tls::Epoch
atHeadROB	CavaManager.h	/^  enum VPMode { eager, atHeadROB, whenStall };$/;"	e	enum:CavaManager::VPMode
atom	Epoch.h	/^      enum AtomEnum {NotAtomic, Atomic}                        atom : 1;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::AtomEnum
availableFlows	Processor.cpp	/^size_t Processor::availableFlows() const $/;"	f	class:Processor
availableFlows	SMTProcessor.cpp	/^size_t SMTProcessor::availableFlows() const $/;"	f	class:SMTProcessor
availableProcessors	RunningProcs.h	/^  ProcessorMultiSet availableProcessors;$/;"	m	class:RunningProcs
avgBranchTime	FetchEngine.h	/^  GStatsAvg  avgBranchTime;$/;"	m	class:FetchEngine
avgChunkCreationTime	BulkManager.h	/^  GStatsAvg  avgChunkCreationTime;$/;"	m	class:BulkManager
avgChunkLifetime	BulkManager.h	/^  GStatsAvg  avgChunkLifetime;$/;"	m	class:BulkManager
avgChunkSize	BulkManager.h	/^  GStatsAvg  avgChunkSize;$/;"	m	class:BulkManager
avgChunkSizeAtOwner	BulkManager.h	/^  GStatsAvg  avgChunkSizeAtOwner;$/;"	m	class:PredefinedBulkManager
avgChunkWaitingTime	BulkManager.h	/^  GStatsAvg  avgChunkWaitingTime;$/;"	m	class:BulkManager
avgCommittingChunks	BulkManager.h	/^  GStatsAvg  avgCommittingChunks;$/;"	m	class:BulkManager
avgConfSetSize	TaskContext.cpp	/^GStatsAvg  *TaskContext::avgConfSetSize=0;$/;"	m	class:TaskContext	file:
avgConfSetSize	TaskContext.h	/^  static GStatsAvg *avgConfSetSize;$/;"	m	class:TaskContext
avgCyclesFromOwnershipToCommit	BulkManager.h	/^  GStatsAvg  avgCyclesFromOwnershipToCommit;$/;"	m	class:PredefinedBulkManager
avgExeQTime	DInst.cpp	/^GStatsAvg **DInst::avgExeQTime    = 0;$/;"	m	class:DInst	file:
avgExeQTime	DInst.h	/^  static GStatsAvg **avgExeQTime;$/;"	m	class:DInst
avgFetchQTime	DInst.cpp	/^GStatsAvg **DInst::avgFetchQTime  = 0;$/;"	m	class:DInst	file:
avgFetchQTime	DInst.h	/^  static GStatsAvg **avgFetchQTime;$/;"	m	class:DInst
avgInsts	MultiManager.h	/^  GStatsAvg avgInsts;$/;"	m	class:MultiPathManager
avgInstsFetched	FetchEngine.h	/^  GStatsAvg  avgInstsFetched;$/;"	m	class:FetchEngine
avgIssueQTime	DInst.cpp	/^GStatsAvg **DInst::avgIssueQTime  = 0;$/;"	m	class:DInst	file:
avgIssueQTime	DInst.h	/^  static GStatsAvg **avgIssueQTime;$/;"	m	class:DInst
avgNumBMsReadyToCommitAfterSquash	BulkManager.h	/^  GStatsAvg  avgNumBMsReadyToCommitAfterSquash;$/;"	m	class:BulkManager
avgNumBMsReadyToCommitTokenOwnership	BulkManager.h	/^  GStatsAvg  avgNumBMsReadyToCommitTokenOwnership;$/;"	m	class:PredefinedBulkManager
avgOutsPreds	CavaManager.h	/^  GStatsAvg  avgOutsPreds;$/;"	m	class:CavaManager
avgOutsPredsLines	CavaManager.h	/^  GStatsAvg  avgOutsPredsLines;$/;"	m	class:CavaManager
avgPrivReadSetSize	BulkManager.h	/^  GStatsAvg  avgPrivReadSetSize;$/;"	m	class:BulkManager
avgPrivWriteSetSize	BulkManager.h	/^  GStatsAvg  avgPrivWriteSetSize;$/;"	m	class:BulkManager
avgReadSetSize	BulkManager.h	/^  GStatsAvg  avgReadSetSize;$/;"	m	class:BulkManager
avgReadSetSize	TaskContext.cpp	/^GStatsAvg  *TaskContext::avgReadSetSize=0;$/;"	m	class:TaskContext	file:
avgReadSetSize	TaskContext.h	/^  static GStatsAvg *avgReadSetSize;$/;"	m	class:TaskContext
avgRetireQTime	DInst.cpp	/^GStatsAvg **DInst::avgRetireQTime = 0;$/;"	m	class:DInst	file:
avgRetireQTime	DInst.h	/^  static GStatsAvg **avgRetireQTime;$/;"	m	class:DInst
avgSchedQTime	DInst.cpp	/^GStatsAvg **DInst::avgSchedQTime  = 0;$/;"	m	class:DInst	file:
avgSchedQTime	DInst.h	/^  static GStatsAvg **avgSchedQTime;$/;"	m	class:DInst
avgSizeInsts	CavaManager.h	/^  GStatsAvg  avgSizeInsts;$/;"	m	class:CavaManager
avgSquashedInsts	BulkManager.h	/^  GStatsAvg  avgSquashedInsts;$/;"	m	class:BulkManager
avgTokenRoundtrip	BulkManager.h	/^  GStatsAvg  avgTokenRoundtrip;$/;"	m	class:PredefinedBulkManager
avgWriteSetSize	BulkManager.h	/^  GStatsAvg  avgWriteSetSize;$/;"	m	class:BulkManager
avgWriteSetSize	TaskContext.cpp	/^GStatsAvg  *TaskContext::avgWriteSetSize=0;$/;"	m	class:TaskContext	file:
avgWriteSetSize	TaskContext.h	/^  static GStatsAvg *avgWriteSetSize;$/;"	m	class:TaskContext
avs	MemAnalyzer.h	/^  AVSeries avs;$/;"	m	class:MemAnalyzer
avsPeriod	MemAnalyzer.h	/^  const int avsPeriod;$/;"	m	class:MemAnalyzer
awakeIfWaiting	TaskContext.cpp	/^void TaskContext::awakeIfWaiting()$/;"	f	class:TaskContext
awakeRemoteInstructions	DInst.cpp	/^void DInst::awakeRemoteInstructions() $/;"	f	class:DInst
bad	ValueTable.h	/^    void bad() {$/;"	f	class:ValueTable::PredEntry
badCntr	ValueTable.cpp	/^GStatsCntr *ValueTable::badCntr =0;$/;"	m	class:ValueTable	file:
badCntr	ValueTable.h	/^    GStatsCntr badCntr;$/;"	m	class:ValueTable::PredEntry
badCntr	ValueTable.h	/^  static GStatsCntr *badCntr;$/;"	m	class:ValueTable
badMemOpBuff	CavaManager.cpp	/^unsigned long long CavaManager::badMemOpBuff = 0;$/;"	m	class:CavaManager	file:
badMemOpBuff	CavaManager.h	/^  static unsigned long long badMemOpBuff;$/;"	m	class:CavaManager
badMemOpBuff	RatsManager.cpp	/^unsigned long long RatsManager::badMemOpBuff = 0;$/;"	m	class:RatsManager	file:
badMemOpBuff	RatsManager.h	/^  static unsigned long long badMemOpBuff;$/;"	m	class:RatsManager
bad_reg	TaskContext.h	/^  bool bad_reg[68];$/;"	m	class:TaskContext
bank	DInst.h	/^  long bank;$/;"	m	class:DInst
base	ASVersion.h	/^  VType base;$/;"	m	class:HVersion
base	HVersion.h	/^  VType base;$/;"	m	class:HVersion
baseAddr	Epoch.h	/^      Address baseAddr;$/;"	m	class:tls::Epoch::BufferBlock
baseName	CriticalityManager.h	/^  char *baseName;$/;"	m	class:PredData
becomeConsumer	Epoch.h	/^      bool becomeConsumer(void){$/;"	f	class:tls::Epoch::BufferBlock
becomeFlowSource	Epoch.h	/^      void becomeFlowSource(void){$/;"	f	class:tls::Epoch::BufferBlock
becomeFullyMerged	Epoch.h	/^    void becomeFullyMerged(void){$/;"	f	class:tls::Epoch
becomeNonReady	ProcessId.h	/^  void becomeNonReady() {$/;"	f	class:ProcessId
becomeProducer	Epoch.h	/^      bool becomeProducer(void){$/;"	f	class:tls::Epoch::BufferBlock
becomeReady	ProcessId.h	/^  ProcessId *becomeReady() {$/;"	f	class:ProcessId
becomeStale	Epoch.h	/^      void becomeStale(void){$/;"	f	class:tls::Epoch::BufferBlock
begin	OSSim.h	/^    ulong begin;$/;"	m	struct:OSSim::__anon5
beginAcquire	Epoch.cpp	/^  void Epoch::beginAcquire(void){$/;"	f	class:tls::Epoch
beginActiveMerge	Epoch.cpp	/^  void Epoch::beginActiveMerge(void){$/;"	f	class:tls::Epoch
beginCall	MemAnalyzer.h	/^  GStatsCntr beginCall;$/;"	m	class:DelinquentLoad
beginCurrentExe	Epoch.h	/^    Time_t beginCurrentExe;$/;"	m	class:tls::Epoch
beginDecisionExe	Epoch.h	/^    Time_t beginDecisionExe;$/;"	m	class:tls::Epoch
beginMerge	Epoch.cpp	/^  void Epoch::beginMerge(void){$/;"	f	class:tls::Epoch
beginRelease	Epoch.cpp	/^  void Epoch::beginRelease(void){$/;"	f	class:tls::Epoch
beginTime	Profile.h	/^    Time_t beginTime;           \/\/virtual start time$/;"	m	class:Profile::TaskInfo
beginTrain	CriticalityManager.h	/^  void beginTrain() {$/;"	f	class:CritScheduler
benchName	OSSim.cpp	/^char *OSSim::benchName=0;$/;"	m	class:OSSim	file:
benchName	OSSim.h	/^  static char *benchName;$/;"	m	class:OSSim
benchRunning	OSSim.h	/^  char *benchRunning;$/;"	m	class:OSSim
benchSection	OSSim.h	/^  char *benchSection;$/;"	m	class:OSSim
bf	Resource.h	/^  BloomFilter *bf;$/;"	m	class:FULoad
bfe	TaskContext.h	/^  static BFExplorer bfe;$/;"	m	class:TaskContext
biasTable	GProcessor.h	/^  SCTable biasTable;$/;"	m	class:STagged
block	Epoch.h	/^	BufferBlock *block;$/;"	m	struct:tls::Epoch::BlockVersions::ConflictInfo
blockAddrMask	Checkpoint.h	/^      blockAddrMask=(blockSize-1),$/;"	e	enum:tls::Checkpoint::MemoryBlockConstantsEnum
blockAddrMask	Epoch.h	/^      blockAddrMask=(blockSize-1)$/;"	e	enum:tls::Epoch::BufferBlockConstantsEnum
blockAddrToVersions	Epoch.cpp	/^  Epoch::BlockVersions::BlockAddrToVersions Epoch::BlockVersions::blockAddrToVersions;$/;"	m	class:tls::Epoch::BlockVersions	file:
blockAddrToVersions	Epoch.h	/^      static BlockAddrToVersions blockAddrToVersions;$/;"	m	class:tls::Epoch::BlockVersions
blockBaseMask	Checkpoint.h	/^      blockBaseMask=0xffffffff-blockAddrMask$/;"	e	enum:tls::Checkpoint::MemoryBlockConstantsEnum
blockCount	Epoch.cpp	/^  size_t Epoch::BufferBlock::blockCount=0;$/;"	m	class:tls::Epoch::BufferBlock	file:
blockCount	Epoch.h	/^      static size_t blockCount;$/;"	m	class:tls::Epoch::BufferBlock
blockRetire	GProcessor.h	/^  bool blockRetire;$/;"	m	class:GProcessor
blockSize	Checkpoint.h	/^      blockSize=(1<<logBlockSize),$/;"	e	enum:tls::Checkpoint::MemoryBlockConstantsEnum
blockSize	Epoch.h	/^      blockSize=(1<<logBlockSize),$/;"	e	enum:tls::Epoch::BufferBlockConstantsEnum
bmId	BulkManager.h	/^  BM_t bmId;$/;"	m	class:BulkManager
bmVec	BulkManager.cpp	/^BulkManager::BMVec BulkManager::bmVec;$/;"	m	class:BulkManager	file:
bmVec	BulkManager.h	/^  static BMVec bmVec;$/;"	m	class:BulkManager
boot	ASVersion.cpp	/^HVersion *HVersion::boot(TaskContext *t)$/;"	f	class:HVersion
boot	GMemoryOS.cpp	/^void DummyMemoryOS::boot()$/;"	f	class:DummyMemoryOS
boot	HVersion.cpp	/^HVersion *HVersion::boot(TaskContext *t)$/;"	f	class:HVersion
boot	HVersion.cpp	/^void HVersion::IDP::boot()$/;"	f	class:HVersion::IDP
boot	OSSim.h	/^  virtual void boot() {$/;"	f	class:OSSim
boot	ProcessId.cpp	/^void ProcessId::boot()$/;"	f	class:ProcessId
boot	ValueTable.cpp	/^void ValueTable::boot() $/;"	f	class:ValueTable
bothHit	MemAnalyzer.h	/^  int bothHit;$/;"	m	class:AVSeries
bpred	DInst.h	/^  BPredictor *bpred;$/;"	m	class:DInst
bpred	FetchEngine.h	/^  BPredictor *bpred;$/;"	m	class:FetchEngine
bpredEnergy	BPred.h	/^  GStatsEnergy *bpredEnergy;$/;"	m	class:BPred
brCnt	MultiManager.h	/^  long long brCnt;$/;"	m	class:MultiPathManager
brHist	CavaManager.h	/^  unsigned brHist;$/;"	m	class:CavaManager
brHist	MemAnalyzer.h	/^  unsigned brHist;$/;"	m	class:MemAnalyzer
brHist	VPred.h	/^  unsigned brHist;$/;"	m	class:ConfidenceEstimator
brHist	VPred.h	/^  unsigned brHist;$/;"	m	class:GValuePredictor
breakCheckpoint	CavaManager.h	/^  GStatsCntr breakCheckpoint;$/;"	m	class:CavaManager
breakTask	CriticalityTC.cpp	/^void CriticalityTC::breakTask(int newId, bool setCPU)$/;"	f	class:CriticalityTC
bsc	GProcessor.h	/^  BulkManager *bsc;$/;"	m	class:GProcessor
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BP2BcgSkew
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BP2bit
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BP2level
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPCRap
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPHybrid
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPOgehl
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPOracle
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPRap
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPStatic
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPTaken
btb	BPred.h	/^  BPBTB btb;$/;"	m	class:BPyags
btbEnergy	BPred.h	/^  GStatsEnergy *btbEnergy;$/;"	m	class:BPBTB
bucketPool	Pipeline.h	/^  IBucketCont bucketPool;$/;"	m	class:Pipeline
bucketPoolMaxSize	Pipeline.h	/^  const size_t bucketPoolMaxSize;$/;"	m	class:Pipeline
bufData	SysCall.h	/^  void *bufData;$/;"	m	class:SysCallWrite
buffer	BPred.h	/^  PathHistoryEntry   *buffer;$/;"	m	class:BPRap
buffer	BulkManager.h	/^  logentry_t* buffer;$/;"	m	class:BasicLogger
buffer	MemRequest.h	/^  IBucket *buffer;$/;"	m	class:IMemRequest
buffer	Pipeline.h	/^  FastQueue<IBucket *> buffer;$/;"	m	class:Pipeline
bufferBlocks	Epoch.h	/^    BufferBlocks bufferBlocks;$/;"	m	class:tls::Epoch
bufferPos	BPred.h	/^  size_t bufferPos;$/;"	m	class:BPCRap
bufferPos	BPred.h	/^  size_t bufferPos;$/;"	m	class:BPRap
bufferpos	BulkManager.h	/^  size_t bufferpos;$/;"	m	class:BasicLogger
buffersize	BulkManager.h	/^  size_t buffersize;$/;"	m	class:BasicLogger
build	BulkManager.cpp	/^BulkManager* BulkManagerBuilder::build(GProcessor *gp){$/;"	f	class:BulkManagerBuilder
buildInstStats	GProcessor.cpp	/^void GProcessor::buildInstStats(GStatsCntr *i[MaxInstType], const char *txt)$/;"	f	class:GProcessor
buildMemoryOS	GMemorySystem.cpp	/^GMemoryOS *GMemorySystem::buildMemoryOS(const char *section)$/;"	f	class:GMemorySystem
buildMemoryObj	GMemorySystem.cpp	/^MemObj *GMemorySystem::buildMemoryObj(const char *type, const char *section, const char *name)$/;"	f	class:GMemorySystem
buildMemorySystem	GMemorySystem.cpp	/^void GMemorySystem::buildMemorySystem()$/;"	f	class:GMemorySystem
buildUniqueName	GMemorySystem.cpp	/^char *GMemorySystem::buildUniqueName(const char *device_type)$/;"	f	class:GMemorySystem
buildUnit	Cluster.cpp	/^void Cluster::buildUnit(const char *clusterName$/;"	f	class:Cluster
bulkCache	BulkManager.h	/^  BulkSCCache *bulkCache;$/;"	m	class:BulkManager
bulkMan	BulkManager.h	/^    BulkManager *bulkMan;$/;"	m	class:BulkManager::Chunk
bytesRead	SysCall.h	/^  ssize_t bytesRead;$/;"	m	class:SysCallRead
bytesWritten	SysCall.h	/^  ssize_t bytesWritten;$/;"	m	class:SysCallWrite
cDecodeId	SMTProcessor.h	/^  int cDecodeId;$/;"	m	class:SMTProcessor
cFetchId	SMTProcessor.h	/^  int cFetchId;$/;"	m	class:SMTProcessor
cGraph	CriticalityBuilder.h	/^  CriticalityGraph cGraph;$/;"	m	class:CriticalityBuilder
cGraph	CriticalityManager.h	/^  CriticalityGraph cGraph;$/;"	m	class:CriticalityBase
cId	DInst.h	/^  int cId;$/;"	m	class:DInst
cIndex	MemBuffer.h	/^  ulong  cIndex; \/\/ chunkIndex (addr>>logChunkSize)$/;"	m	class:MemBufferEntry
cIssueId	SMTProcessor.h	/^  int cIssueId;$/;"	m	class:SMTProcessor
cLevel	GProcessor.h	/^  CritLevel cLevel;$/;"	m	class:GProcessor
cLevel	TaskContext.h	/^  CritLevel cLevel;$/;"	m	class:TaskContext
cacheDispatched	Resource.cpp	/^void FULoad::cacheDispatched(DInst *dinst)$/;"	f	class:FULoad
cacheDispatchedCB	Resource.h	/^  typedef CallbackMember1<FULoad, DInst *, &FULoad::cacheDispatched, 103> cacheDispatchedCB;$/;"	t	class:FULoad
cacheDisplacement	BulkManager.cpp	/^void BulkManager::cacheDisplacement(PAddr addr)$/;"	f	class:BulkManager
cacheIndex	CriticalityBuilder.h	/^  int cacheIndex;$/;"	m	class:CriticalityBuilder
cacheIndex	CriticalityManager.h	/^  int cacheIndex;$/;"	m	class:CriticalityBase
calcAccessMask	MemBuffer.h	/^  static BitMaskType calcAccessMask(short opflags, ulong cOffset) {$/;"	f	class:MemBufferEntry
calcAlignChunk	MemBuffer.h	/^  static ulong calcAlignChunk(RAddr addr) {$/;"	f	class:MemBufferEntry
calcChildSpawnAddr	TaskContext.cpp	/^PAddr TaskContext::calcChildSpawnAddr(PAddr childAddr)$/;"	f	class:TaskContext
calcChunkIndex	MemBuffer.h	/^  static ulong calcChunkIndex(RAddr addr) {$/;"	f	class:MemBufferEntry
calcChunkOffset	MemBuffer.h	/^  static ulong calcChunkOffset(RAddr addr) {$/;"	f	class:MemBufferEntry
calcFullPage	GMemorySystem.h	/^  static long  calcFullPage(long p) { return p << Log2PageSize; }$/;"	f	class:GMemorySystem
calcInstID	BPred.h	/^  HistoryType calcInstID(const Instruction *inst) const {$/;"	f	class:BPred
calcMissingWRMask	MemBuffer.h	/^  BitMaskType calcMissingWRMask(BitMaskType accMask) const {$/;"	f	class:MemBufferEntry
calcPAddr	GMemorySystem.h	/^  static PAddr calcPAddr(long p, VAddr a) { $/;"	f	class:GMemorySystem
calcPAddr4Page	GMemorySystem.h	/^  static PAddr calcPAddr4Page(long p) { return p << Log2PageSize; }$/;"	f	class:GMemorySystem
calcPage	GMemorySystem.h	/^  static long  calcPage(PAddr paddr)  { return paddr >> Log2PageSize; }$/;"	f	class:GMemorySystem
calcPageMask	GMemorySystem.h	/^  static long  calcPageMask(long p) { return p & PageMask; }$/;"	f	class:GMemorySystem
calcWord	LDSTBuffer.h	/^  static VAddr calcWord(const DInst *dinst) {$/;"	f	class:LDSTBuffer
calcWord	LDSTQ.h	/^  static VAddr calcWord(const DInst *dinst) {$/;"	f	class:LDSTQ
calcXRDMask	MemBuffer.h	/^  BitMaskType calcXRDMask(BitMaskType accMask) const {$/;"	f	class:MemBufferEntry
canAcceptLoad	MemObj.h	/^  virtual bool canAcceptLoad(PAddr addr) { return true; }$/;"	f	class:MemObj
canAcceptStore	MemObj.cpp	/^bool DummyMemObj::canAcceptStore(PAddr addr)$/;"	f	class:DummyMemObj
canBeRecycled	DInst.h	/^  bool canBeRecycled;$/;"	m	class:DInst
canDelete	CriticalityBuilder.cpp	/^bool CriticalityBuilder::canDelete(CPNodeGroup *g)$/;"	f	class:CriticalityBuilder
canDelete	CriticalityManager.cpp	/^bool CriticalityBase::canDelete(CPNodeGroup *g)$/;"	f	class:CriticalityBase
canDump	CriticalityBuilder.cpp	/^bool CriticalityBuilder::canDump(CPNodeGroup *g)$/;"	f	class:CriticalityBuilder
canDump	CriticalityManager.cpp	/^bool CriticalityBase::canDump(CPNodeGroup *g)$/;"	f	class:CriticalityBase
canEarlyAwake	TaskContext.h	/^  bool canEarlyAwake; \/\/ Early awake (even before receiving the commit token)$/;"	m	class:TaskContext
canHandleXProcSrc2Dep	BulkManager.h	/^  virtual bool canHandleXProcSrc2Dep() const {return false;}$/;"	f	class:PredefinedBulkManager
canHandleXProcSrc2Dep	BulkManager.h	/^  virtual bool canHandleXProcSrc2Dep() const {return true;}$/;"	f	class:BulkManager
canIssue	Cluster.h	/^  bool canIssue(DInst *dinst) const { return windowSize>0; }$/;"	f	class:Cluster
canIssue	Resource.cpp	/^StallCause FUBranch::canIssue(DInst *dinst)$/;"	f	class:FUBranch
canIssue	Resource.cpp	/^StallCause FUEvent::canIssue(DInst *dinst)$/;"	f	class:FUEvent
canIssue	Resource.cpp	/^StallCause FUGeneric::canIssue(DInst *dinst)$/;"	f	class:FUGeneric
canIssue	Resource.cpp	/^StallCause FULoad::canIssue(DInst *dinst)$/;"	f	class:FULoad
canIssue	Resource.cpp	/^StallCause FUMemory::canIssue(DInst *dinst)$/;"	f	class:FUMemory
canIssue	Resource.cpp	/^StallCause FUStore::canIssue(DInst *dinst)$/;"	f	class:FUStore
canIssueInstruction	ConsistencyPolicy.cpp	/^bool SCConsistencyPolicy::canIssueInstruction(DInst* dinst)$/;"	f	class:SCConsistencyPolicy
canIssueInstruction	ConsistencyPolicy.cpp	/^bool SCPFConsistencyPolicy::canIssueInstruction(DInst* dinst)$/;"	f	class:SCPFConsistencyPolicy
canIssueInstruction	ConsistencyPolicy.h	/^  virtual bool canIssueInstruction(DInst* dinst) { return true; }$/;"	f	class:DefaultConsistencyPolicy
canMergeNext	TaskContext.cpp	/^bool TaskContext::canMergeNext(int tid)$/;"	f	class:TaskContext
canRetireIncompleteStore	ConsistencyPolicy.h	/^  bool canRetireIncompleteStore() { return true; }$/;"	f	class:SCWBConsistencyPolicy
canRetireIncompleteStore	ConsistencyPolicy.h	/^  bool canRetireIncompleteStore() { return true; }$/;"	f	class:SCWBPFConsistencyPolicy
canRetireIncompleteStore	ConsistencyPolicy.h	/^  virtual bool canRetireIncompleteStore() { return false; }$/;"	f	class:SCConsistencyPolicy
canRetireIncompleteStore	ConsistencyPolicy.h	/^  virtual bool canRetireIncompleteStore() { return true; }$/;"	f	class:DefaultConsistencyPolicy
canSyncBecomeSafe	TaskContext.h	/^  bool canSyncBecomeSafe() const {$/;"	f	class:TaskContext
cancelInstr	Epoch.h	/^    void cancelInstr(void){$/;"	f	class:tls::Epoch
cava	GProcessor.h	/^  CavaManager *cava;$/;"	m	class:GProcessor
cavaTrain	CavaManager.h	/^  bool cavaTrain;$/;"	m	class:CavaManager
cb	CriticalityBuilder.cpp	/^CriticalityBuilder *CriticalityBuilder::cb = NULL;$/;"	m	class:CriticalityBuilder	file:
cb	CriticalityBuilder.h	/^  static CriticalityBuilder *cb;$/;"	m	class:CriticalityBuilder
cb	CriticalityManager.cpp	/^CriticalityBase *CriticalityBase::cb = NULL;$/;"	m	class:CriticalityBase	file:
cb	CriticalityManager.h	/^  static CriticalityBase *cb;$/;"	m	class:CriticalityBase
cb	MemRequest.h	/^  CallbackBase *cb;$/;"	m	class:CBMemRequest
cb	MemRequest.h	/^  StaticCallbackBase *cb;$/;"	m	class:StaticCBMemRequest
cbi	CriticalityBuilder.cpp	/^CriticalityBuilderIface *CriticalityBuilderIface::cbi = NULL;$/;"	m	class:CriticalityBuilderIface	file:
cbi	CriticalityBuilder.h	/^  static CriticalityBuilderIface *cbi;$/;"	m	class:CriticalityBuilderIface
ce	CavaManager.h	/^  ConfidenceEstimator ce;$/;"	m	class:CavaManager
ce	MultiManager.h	/^  SCTable  ce;$/;"	m	class:MultiPathManager
ce	RatsManager.h	/^  ConfidenceEstimator *ce;$/;"	m	class:RatsManager
ceBits	MultiManager.h	/^  const int ceBits;$/;"	m	class:MultiPathManager
ceBits	RatsManager.h	/^  const uchar ceBits;$/;"	m	class:RatsManager
ceSize	MultiManager.h	/^  const int ceSize;$/;"	m	class:MultiPathManager
ceSize	RatsManager.h	/^  const int ceSize;$/;"	m	class:RatsManager
chain	CriticalityPredictor.h	/^  std::list<ProcessId*> chain;$/;"	m	class:EdgeChain
chainFinishEvent	CriticalityPredictor.cpp	/^void EdgeCPred::chainFinishEvent(ProcessId *head)$/;"	f	class:EdgeCPred
chainH	CriticalityPredictor.h	/^  ChainHash chainH;$/;"	m	class:EdgeCPred
chainSpawnEvent	CriticalityPredictor.cpp	/^void EdgeCPred::chainSpawnEvent(ProcessId *parent, ProcessId *child)$/;"	f	class:EdgeCPred
chainSquashEvent	CriticalityPredictor.cpp	/^void EdgeCPred::chainSquashEvent(ProcessId *from, ProcessId *to)$/;"	f	class:EdgeCPred
changeChipVoltFreq	DVFSManager.cpp	/^void DVFSManager::changeChipVoltFreq (const char* pairName)$/;"	f	class:DVFSManager
changeChipVoltFreq	DVFSManager.cpp	/^void DVFSManager::changeChipVoltFreq (int pairId)$/;"	f	class:DVFSManager
changeEpoch	Epoch.h	/^    Epoch *changeEpoch(){$/;"	f	class:tls::Epoch
changeThreadSafeVClock	Epoch.cpp	/^  void Thread::changeThreadSafeVClock(const VClock &newVClock){$/;"	f	class:tls::Thread
changeVoltFreq	DVFSManager.cpp	/^void DVFSManager::changeVoltFreq (CPU_t cpuId, const char* pairName)$/;"	f	class:DVFSManager
changeVoltFreq	DVFSManager.cpp	/^void DVFSManager::changeVoltFreq (CPU_t cpuId, int pairId)$/;"	f	class:DVFSManager
changed	CriticalityController.h	/^  bool  changed;$/;"	m	class:CriticalityController
changed	CriticalityManager.h	/^  bool  changed;$/;"	m	class:CritScheduler
changed	CriticalityPredictor.h	/^  bool changed;$/;"	m	class:EdgeCPred
check	Epoch.cpp	/^  void Epoch::BlockVersions::check(Address baseAddr){$/;"	f	class:tls::Epoch::BlockVersions
checkAll	Epoch.cpp	/^  void Epoch::BlockVersions::checkAll(void){$/;"	f	class:tls::Epoch::BlockVersions
checkEntry	CriticalityPredictor.h	/^  bool checkEntry(int tag) {$/;"	f	class:EdgeStateStat
checkIntervalStatus	OSSim.h	/^  void checkIntervalStatus() { \/\/inline$/;"	f	class:OSSim
checkLine	CriticalityPredictor.h	/^  void checkLine(ELine *l) {$/;"	f	class:EdgeCPred
checkMarkStatus	OSSim.h	/^  void checkMarkStatus() { \/\/inline$/;"	f	class:OSSim
checkPid	CriticalityController.cpp	/^void CriticalityController::checkPid(Pid_t pid)$/;"	f	class:CriticalityController
checkPredTable	CriticalityManager.h	/^  void checkPredTable(long sid) {$/;"	f	class:CritScheduler
checkProcessPri	CriticalityPredictor.cpp	/^void CriticalityPredictor::checkProcessPri(std::vector<ProcessId*> &procVec)$/;"	f	class:CriticalityPredictor
checkReadyProcesses	OSSim.h	/^  void checkReadyProcesses() {$/;"	f	class:OSSim
checkReadyProcesses	RunningProcs.cpp	/^void RunningProcs::checkReadyProcesses()$/;"	f	class:RunningProcs
checkRegisterRecycle	GProcessor.cpp	/^void GProcessor::checkRegisterRecycle()$/;"	f	class:GProcessor
checkSafest	CriticalityController.cpp	/^void CriticalityController::checkSafest()$/;"	f	class:CriticalityController
checkSafest	CriticalityManager.cpp	/^void CritScheduler::checkSafest()$/;"	f	class:CritScheduler
checkpoint	TaskContext.h	/^  bool checkpointed, checkpointable, checkpoint;$/;"	m	class:TaskContext
checkpointable	TaskContext.h	/^  bool checkpointed, checkpointable, checkpoint;$/;"	m	class:TaskContext
checkpointed	DInst.h	/^  bool         checkpointed;$/;"	m	class:DInst
checkpointed	HVersion.h	/^  bool checkpointed;$/;"	m	class:HVersionDomain
checkpointed	TaskContext.h	/^  bool checkpointed, checkpointable, checkpoint;$/;"	m	class:TaskContext
checkpointed	TaskContext.h	/^  bool checkpointed;$/;"	m	class:TaskContext
cherryRAT	GProcessor.h	/^  DInst *cherryRAT[NumArchRegs];$/;"	m	class:GProcessor
childPid	SysCall.h	/^  Pid_t childPid;$/;"	m	class:SysCallSescSpawn
childThread	SysCall.h	/^  Pid_t childThread;$/;"	m	class:SysCallWait
chooseBest	CriticalityPredictor.h	/^  bool chooseBest;$/;"	m	class:EdgeCPred
chooseBestChain	CriticalityPredictor.cpp	/^void EdgeCPred::chooseBestChain(std::vector<ProcessId*> &procVec)$/;"	f	class:EdgeCPred
chunkAddrMask	Epoch.h	/^      chunkAddrMask=(chunkSize-1),$/;"	e	enum:tls::Epoch::BufferBlockConstantsEnum
chunkAddrMask	MemBuffer.h	/^  chunkAddrMask=(chunkSize-1),$/;"	e	enum:__anon4
chunkCopy	MemBuffer.cpp	/^bool MemBufferEntry::chunkCopy(RAddr dstAddr, RAddr srcAddr, BitMaskType rbitmask)$/;"	f	class:MemBufferEntry
chunkCounter	BulkManager.cpp	/^long int BulkManager::Chunk::chunkCounter=0;$/;"	m	class:BulkManager::Chunk	file:
chunkCounter	BulkManager.h	/^    static long int chunkCounter;$/;"	m	class:BulkManager::Chunk
chunkDataMask	MemBuffer.h	/^  chunkDataMask=0xFF$/;"	e	enum:__anon4
chunkId	BulkManager.h	/^    long int chunkId;$/;"	m	class:BulkManager::Chunk
chunkPool	BulkManager.h	/^    static pool<Chunk> chunkPool;$/;"	m	class:BulkManager::Chunk
chunkQ	BulkManager.h	/^    FastQueue<DInst *> chunkQ;$/;"	m	class:BulkManager::Chunk
chunkSize	BulkManager.cpp	/^int  BulkManager::chunkSize;$/;"	m	class:BulkManager	file:
chunkSize	BulkManager.h	/^  static int  chunkSize;$/;"	m	class:BulkManager
chunkSize	Epoch.h	/^      chunkSize=(1<<logChunkSize),$/;"	e	enum:tls::Epoch::BufferBlockConstantsEnum
chunkSize	MemBuffer.h	/^  chunkSize=(1<<logChunkSize), \/\/ == sizeof(long long) == sizeof(BitMaskType)*8$/;"	e	enum:__anon4
ckpDone	CavaManager.cpp	/^void CavaManager::ckpDone(int ckpId)$/;"	f	class:CavaManager
ckpId	CavaManager.h	/^    unsigned int ckpId;$/;"	m	class:CavaManager::PredInfo
ckpId	DInst.h	/^  unsigned int ckpId;$/;"	m	class:DInst
ckpId	HVersion.h	/^  unsigned int ckpId;$/;"	m	class:HVersion
ckpInfoMap	CavaManager.cpp	/^CavaManager::CkpInfoMap CavaManager::ckpInfoMap; $/;"	m	class:CavaManager	file:
ckpInfoMap	CavaManager.h	/^  static CkpInfoMap ckpInfoMap; $/;"	m	class:CavaManager
ckpInstsFinished	CavaManager.cpp	/^void CavaManager::ckpInstsFinished(int ckpId)$/;"	f	class:CavaManager
ckpStillExists	CavaManager.h	/^  static bool ckpStillExists(int ckpId) {$/;"	f	class:CavaManager
claim	HVersion.cpp	/^void HVersion::claim()$/;"	f	class:HVersion
clean	CriticalityPredictor.h	/^  void clean() {$/;"	f	class:EdgeChain
clean	Epoch.h	/^      void clean(void){$/;"	f	class:tls::Epoch::BufferBlock
cleanBucketPool	Pipeline.h	/^  IBucketCont cleanBucketPool;$/;"	m	class:Pipeline
cleanBuffer	Epoch.cpp	/^  void Epoch::cleanBuffer(void){$/;"	f	class:tls::Epoch
cleanEventList	CriticalityPredictor.h	/^  void cleanEventList() {$/;"	f	class:CriticalityPredictor
cleanItem	Pipeline.h	/^  const bool cleanItem;$/;"	m	class:IBucket
cleanMark	Pipeline.cpp	/^void Pipeline::cleanMark()$/;"	f	class:Pipeline
clear	CPBuilder.h	/^    void clear(int tokenId) {$/;"	f	class:TokenContainer
clear	GMemorySystem.cpp	/^void MemoryObjContainer::clear()$/;"	f	class:MemoryObjContainer
clearBPred	TaskContext.h	/^  void clearBPred() {$/;"	f	class:TaskContext
clearChanged	CriticalityController.h	/^  void clearChanged() { changed = false; }$/;"	f	class:CriticalityController
clearDepsAtRetire	DInst.h	/^  void clearDepsAtRetire() { $/;"	f	class:DInst
clearExecuted	ProcessId.h	/^  void clearExecuted()    { executed = false; }$/;"	f	class:ProcessId
clearFinished	ASVersion.h	/^  void clearFinished() { I(0); }$/;"	f	class:HVersion
clearFinished	HVersion.h	/^  void clearFinished() {$/;"	f	class:HVersion
clearItems	Pipeline.cpp	/^void Pipeline::clearItems()$/;"	f	class:Pipeline
clearPath	MemRequest.h	/^  void clearPath() $/;"	f	class:MemRequest
clearRefTasks	CriticalityTC.cpp	/^void CriticalityTC::clearRefTasks()$/;"	f	class:CriticalityTC
clearSelective	ProcessId.h	/^  void clearSelective() {$/;"	f	class:ProcessId
clearState	TaskContext.cpp	/^void TaskContext::clearState()$/;"	f	class:TaskContext
clearStateSafe	TaskContext.cpp	/^void TaskContext::clearStateSafe()$/;"	f	class:TaskContext
clearTrace	Epoch.h	/^    void clearTrace(void){$/;"	f	class:tls::Epoch
clearWaiting	ProcessId.h	/^  void clearWaiting()     { waiting = false;  }$/;"	f	class:ProcessId
clock	Pipeline.h	/^  Time_t clock;$/;"	m	class:IBucket
clockStack	MemRequest.h	/^  std::stack<Time_t>  clockStack;$/;"	m	class:MemRequest
clockTicks	GProcessor.h	/^  Time_t clockTicks;$/;"	m	class:GProcessor
clockTimer	RatsManager.h	/^  Time_t clockTimer;$/;"	m	class:RatsManager
clone	DInst.cpp	/^DInst *DInst::clone() $/;"	f	class:DInst
clone	FetchEngine.h	/^  bool clone;$/;"	m	class:FetchEngine
clone	HVersion.h	/^  bool clone;$/;"	m	class:HVersion
clone	TaskContext.h	/^  bool clone;$/;"	m	class:TaskContext
cloneAtSpawn	RatsManager.h	/^  bool cloneAtSpawn;$/;"	m	class:RatsManager
cloneMostSpec	RatsManager.h	/^  bool cloneMostSpec;$/;"	m	class:RatsManager
cloneVer	HVersion.h	/^  const HVersion *cloneVer;$/;"	m	class:HVersion
cloned	DInst.h	/^  bool cloned;$/;"	m	class:DInst
cloned	TaskContext.h	/^  bool cloned;$/;"	m	class:TaskContext
cluster	Resource.h	/^  Cluster *const cluster;$/;"	m	class:Resource
clusterManager	GProcessor.h	/^  ClusterManager clusterManager;$/;"	m	class:GProcessor
cm	CriticalityManager.cpp	/^CriticalityManager *CriticalityManager::cm = NULL;$/;"	m	class:CriticalityManager	file:
cm	CriticalityManager.h	/^  static CriticalityManager *cm;$/;"	m	class:CriticalityManager
cnt	CriticalityPredictor.h	/^  int cnt;$/;"	m	class:SquashState
cnt	MemAnalyzer.cpp	/^long long DelinquentLoad::cnt=0;$/;"	m	class:DelinquentLoad	file:
cnt	MemAnalyzer.h	/^  static long long cnt;$/;"	m	class:DelinquentLoad
collect	TaskContext.cpp	/^void TaskContext::collect()$/;"	f	class:TaskContext
collectCB	TaskContext.cpp	/^StaticCallbackFunction0<TaskContext::collect> TaskContext::collectCB;$/;"	m	class:TaskContext	file:
collectCB	TaskContext.h	/^  static StaticCallbackFunction0<TaskContext::collect> collectCB;$/;"	m	class:TaskContext
comL2HalfMisses	TaskContext.cpp	/^GStatsCntr *TaskContext::comL2HalfMisses=0;$/;"	m	class:TaskContext	file:
comL2HalfMisses	TaskContext.h	/^  static GStatsCntr *comL2HalfMisses;$/;"	m	class:TaskContext
comL2Misses	TaskContext.cpp	/^GStatsCntr *TaskContext::comL2Misses=0;$/;"	m	class:TaskContext	file:
comL2Misses	TaskContext.h	/^  static GStatsCntr *comL2Misses;$/;"	m	class:TaskContext
commPri	CriticalityManager.h	/^  GStatsAvg  commPri;$/;"	m	class:PredData
commit	BulkManager.cpp	/^void BulkManager::commit(Chunk *ck)$/;"	f	class:BulkManager
commit	BulkManager.cpp	/^void ParPredefinedBulkManager::commit(Chunk *cc)$/;"	f	class:ParPredefinedBulkManager
commit	BulkManager.cpp	/^void PredefinedBulkManager::commit(Chunk *cc)$/;"	f	class:PredefinedBulkManager
commit	CPBuilder.cpp	/^void CPBuilder::commit(TaskContext *tc)$/;"	f	class:CPBuilder
commit	CriticalityTC.cpp	/^void CriticalityTC::commit()$/;"	f	class:CriticalityTC
commit	Epoch.cpp	/^  void Epoch::commit(void){$/;"	f	class:tls::Epoch
commitCnt	CriticalityPredictor.h	/^  int commitCnt;$/;"	m	class:EdgeState
commitComplete	BulkManager.cpp	/^void BulkManager::commitComplete()$/;"	f	class:BulkManager
commitComplete	BulkManager.cpp	/^void PredefinedBulkManager::commitComplete()$/;"	f	class:PredefinedBulkManager
commitCompleteCB	BulkManager.h	/^  typedef CallbackMember0<BulkManager, &BulkManager::commitComplete> commitCompleteCB;$/;"	t	class:BulkManager
commitCost	BulkManager.cpp	/^int  BulkManager::commitCost;$/;"	m	class:BulkManager	file:
commitCost	BulkManager.h	/^  static int  commitCost;$/;"	m	class:BulkManager
commitCrit	CriticalityPredictor.h	/^    bool commitCrit;$/;"	m	class:OracularCPred::OraclePredInfo
commitEpoch	Epoch.cpp	/^  void Thread::commitEpoch(Epoch *epoch){$/;"	f	class:tls::Thread
commitInst	TaskContext.cpp	/^GStatsCntr *TaskContext::commitInst=0;$/;"	m	class:TaskContext	file:
commitInst	TaskContext.h	/^  static GStatsCntr *commitInst;$/;"	m	class:TaskContext
commitNextChunkFromWaitingList	BulkManager.cpp	/^bool BulkManager::commitNextChunkFromWaitingList()$/;"	f	class:BulkManager
commitPort	BulkManager.cpp	/^PortGeneric *BulkManager::commitPort;$/;"	m	class:BulkManager	file:
commitPort	BulkManager.h	/^  static PortGeneric *commitPort;$/;"	m	class:BulkManager
commitPri	CriticalityManager.h	/^  GStatsHist commitPri;$/;"	m	class:CriticalityManager
commitTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::commitTask(CriticalityTC &tc)$/;"	f	class:CriticalityBuilder
commitTask	CriticalityManager.cpp	/^void CriticalityBase::commitTask(CriticalityTC &tc)$/;"	f	class:CriticalityBase
commitTime	BulkManager.h	/^    Time_t commitTime;\/\/time the chunk was committedo$/;"	m	class:BulkManager::Chunk
commitTime	CriticalityTC.h	/^  Time_t commitTime;$/;"	m	class:CriticalityTC
commitTime	TaskContext.cpp	/^GStatsCntr *TaskContext::commitTime=0;$/;"	m	class:TaskContext	file:
commitTime	TaskContext.h	/^  static GStatsCntr *commitTime;$/;"	m	class:TaskContext
commitTokenOwnerNumber	BulkManager.cpp	/^CPU_t PredefinedBulkManager::commitTokenOwnerNumber=0;$/;"	m	class:PredefinedBulkManager	file:
commitTokenOwnerNumber	BulkManager.h	/^  static CPU_t  commitTokenOwnerNumber; $/;"	m	class:PredefinedBulkManager
commited	CavaManager.h	/^    bool commited;$/;"	m	class:CavaManager::CkpInfoEntry
commitedCkpSizeHist	CavaManager.h	/^  GStatsHist commitedCkpSizeHist;$/;"	m	class:CavaManager
committingChunk	BulkManager.h	/^  Chunk *committingChunk;$/;"	m	class:BulkManager
committingChunkSet	BulkManager.cpp	/^BulkManager::ChunkSet BulkManager::committingChunkSet;$/;"	m	class:BulkManager	file:
committingChunkSet	BulkManager.h	/^  static ChunkSet committingChunkSet;$/;"	m	class:BulkManager
compare	Epoch.h	/^    CmpResult compare(const VClock &other) const{$/;"	f	class:tls::VClock
compareSClock	Epoch.cpp	/^  Epoch::CmpResult Epoch::compareSClock(const Epoch *otherEpoch) const{$/;"	f	class:tls::Epoch
complete	Epoch.cpp	/^  void Epoch::complete(void){$/;"	f	class:tls::Epoch
completeChunk	BulkManager.cpp	/^void BulkManager::completeChunk()$/;"	f	class:BulkManager
completeChunk	BulkManager.cpp	/^void ParPredefinedBulkManager::completeChunk()$/;"	f	class:ParPredefinedBulkManager
completeChunk	BulkManager.cpp	/^void PredefinedBulkManager::completeChunk()$/;"	f	class:PredefinedBulkManager
completeMReq	CavaManager.cpp	/^void CavaManager::completeMReq(MemRequest *mreq)$/;"	f	class:CavaManager
completeMReq	RatsManager.cpp	/^void RatsManager::completeMReq()$/;"	f	class:RatsManager
completePrediction	CavaManager.cpp	/^void CavaManager::completePrediction(unsigned long predId)$/;"	f	class:CavaManager
completitionTime	BulkManager.h	/^    Time_t completitionTime;\/\/time the chunk was completed$/;"	m	class:BulkManager::Chunk
compressedStaticId	TaskContext.cpp	/^HASH_MAP<int,int> TaskContext::compressedStaticId;$/;"	m	class:TaskContext	file:
compressedStaticId	TaskContext.h	/^  static HASH_MAP<int,int> compressedStaticId;$/;"	m	class:TaskContext
computeBulkCacheEvents	TaskContext.cpp	/^void TaskContext::computeBulkCacheEvents(TaskContext *tc)$/;"	f	class:TaskContext
computenUpperCaches	MemObj.cpp	/^void MemObj::computenUpperCaches() $/;"	f	class:MemObj
conf	CriticalityPredictor.h	/^  bool conf;$/;"	m	class:EdgeState
confidence	ValueTable.h	/^    int confidence;$/;"	m	class:ValueTable::PredEntry
confident	BPred.cpp	/^bool BPOgehl::confident(const Instruction *inst, InstID oracleID){ $/;"	f	class:BPOgehl
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BP2BcgSkew
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BP2bit
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BP2level
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPBTB
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPCRap
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPHybrid
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPNotTaken
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPOracle
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPRap
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPRas
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPStatic
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPTaken
confident	BPred.h	/^  bool confident(const Instruction *inst, InstID oracleID){return false;}$/;"	f	class:BPyags
consPolicy	GProcessor.h	/^  ConsistencyPolicy *consPolicy;$/;"	m	class:GProcessor
consPrefetchDone	DInst.h	/^  bool consPrefetchDone;$/;"	m	class:DInst
consumed	CavaManager.h	/^    bool consumed;$/;"	m	class:CavaManager::PredInfo
contextSwitch	OSSim.cpp	/^Pid_t OSSim::contextSwitch(CPU_t cpu, Pid_t nPid)$/;"	f	class:OSSim
convertAtRestart	RatsManager.h	/^  bool convertAtRestart;$/;"	m	class:RatsManager
convertPr	CriticalityManager.h	/^  static int convertPr(float pr) {$/;"	f	class:CriticalityManager
convertPr	CriticalityPredictor.h	/^  static int convertPr(float pr) {$/;"	f	class:CriticalityPredictor
convertPrComplement	CriticalityManager.h	/^  static int convertPrComplement(float pr) {$/;"	f	class:CriticalityManager
convertPrComplement	CriticalityPredictor.h	/^  static int convertPrComplement(float pr) {$/;"	f	class:CriticalityPredictor
copyStats	ProcessId.cpp	/^void ProcessId::copyStats(bool destroy)$/;"	f	class:ProcessId
correct	BPred.h	/^    char correct;$/;"	m	class:BPCRap::PathEntry
correct	BPred.h	/^    char correct;$/;"	m	class:BPRap::PathHistoryEntry
correct	HVersion.cpp	/^GStatsCntr **HVersion::IDP::correct;$/;"	m	class:HVersion::IDP	file:
correct	HVersion.h	/^    static GStatsCntr **correct;$/;"	m	class:HVersion::IDP
count	Epoch.h	/^      size_t count;$/;"	m	struct:tls::Epoch::VersionCount
countBMsReadyToCommit	BulkManager.cpp	/^size_t BulkManager::countBMsReadyToCommit()$/;"	f	class:BulkManager
countConflictingCommits	BulkManager.cpp	/^void BulkManager::countConflictingCommits(Chunk *cc)$/;"	f	class:BulkManager
countMap	Epoch.h	/^      CountMap countMap;$/;"	m	struct:tls::Epoch::VersionCounts
cpAddr	TaskContext.h	/^  PAddr         cpAddr;$/;"	m	class:TaskContext
cpContext	TaskContext.h	/^  ThreadContext cpContext;$/;"	m	class:TaskContext
cpNES	TaskContext.h	/^  long          cpNES;$/;"	m	class:TaskContext
cpPredHashHistoryMask	CPBuilder.cpp	/^ulonglong  CPBuilder::cpPredHashHistoryMask;$/;"	m	class:CPBuilder	file:
cpPredHashHistoryMask	CPBuilder.h	/^    static ulonglong cpPredHashHistoryMask;$/;"	m	class:CPBuilder
cpTraceBinary	OSSim.h	/^  bool cpTraceBinary;$/;"	m	class:OSSim
cpTraceText	OSSim.h	/^  bool cpTraceText;$/;"	m	class:OSSim
cpu	CriticalityTC.h	/^  CPU_t               cpu;$/;"	m	class:SubtaskContext
cpu	ProcessId.h	/^  CPU_t   cpu;$/;"	m	class:ProcessId
cpuAffinity	ProcessId.h	/^  BIT_VECTOR cpuAffinity;$/;"	m	class:ProcessId
cpuAllowed	ProcessId.h	/^  BIT_VECTOR cpuAllowed;$/;"	m	class:ProcessId
cpuId	FetchEngine.h	/^  const int cpuId;$/;"	m	class:FetchEngine
cpuVector	RunningProcs.h	/^  std::vector<GProcessor *> cpuVector;$/;"	m	class:RunningProcs
cpus	OSSim.h	/^  RunningProcs cpus;$/;"	m	class:OSSim
create	ASVersion.cpp	/^HVersion *HVersion::create(TaskContext *t)$/;"	f	class:HVersion
create	Cluster.cpp	/^Cluster *Cluster::create(const char *clusterName, GMemorySystem *ms, GProcessor *gproc)$/;"	f	class:Cluster
create	CriticalityBuilder.cpp	/^CriticalityBuilderIface *CriticalityBuilderIface::create(const char* section)$/;"	f	class:CriticalityBuilderIface
create	CriticalityController.cpp	/^CriticalityController *CriticalityController::create(const char *section)$/;"	f	class:CriticalityController
create	CriticalityManager.cpp	/^CriticalityManager *CriticalityManager::create(const char *section)$/;"	f	class:CriticalityManager
create	CriticalityPredictor.cpp	/^CriticalityPredictor* CriticalityPredictor::create(CritPredictor_t pred,$/;"	f	class:CriticalityPredictor
create	HVersion.cpp	/^HVersion *HVersion::create(TaskContext *t)$/;"	f	class:HVersion
create	HVersion.cpp	/^HVersionDomain *HVersionDomain::create() $/;"	f	class:HVersionDomain
create	MemBuffer.cpp	/^MemBuffer *MemBuffer::create(const HVersion *ver)$/;"	f	class:MemBuffer
create	MemBuffer.cpp	/^MemBufferEntry *MemBufferEntry::create(const HVersion *v, ulong ci, RAddr addr, ulong iaddr)$/;"	f	class:MemBufferEntry
create	MemRequest.cpp	/^CBMemRequest *CBMemRequest::create(TimeDelta_t lat, MemObj *m$/;"	f	class:CBMemRequest
create	MemRequest.cpp	/^void DMemRequest::create(DInst *dinst, GMemorySystem *gmem, MemOperation mop)$/;"	f	class:DMemRequest
create	MemRequest.cpp	/^void IMemRequest::create(DInst *dinst, GMemorySystem *gmem, IBucket *bb)$/;"	f	class:IMemRequest
create	MemRequest.h	/^  static ReqPathEntry *create(const char *memobj, $/;"	f	class:ReqPathEntry
create	ProcessId.cpp	/^ProcessId *ProcessId::create(Pid_t ppid, Pid_t id, long flags)$/;"	f	class:ProcessId
createBulkLogger	BulkManager.cpp	/^BulkLogger *BulkLogger::createBulkLogger(const char *type)$/;"	f	class:BulkLogger
createCheckpoint	TaskContext.cpp	/^int TaskContext::createCheckpoint()$/;"	f	class:TaskContext
createChunk	BulkManager.h	/^    static Chunk* createChunk(BulkManager *bm){$/;"	f	class:BulkManager::Chunk
createCkp	CavaManager.cpp	/^unsigned int CavaManager::createCkp(TaskContext *tc) $/;"	f	class:CavaManager
createClone	HVersion.cpp	/^HVersion *HVersion::createClone(TaskContext *t)$/;"	f	class:HVersion
createCloneRat	TaskContext.cpp	/^int TaskContext::createCloneRat(int cpu, const HVersion *safe)$/;"	f	class:TaskContext
createConsistencyPolicy	ConsistencyPolicy.cpp	/^ConsistencyPolicy* ConsistencyPolicy::createConsistencyPolicy(GProcessor* gproc)$/;"	f	class:ConsistencyPolicy
createContId	CriticalityTC.h	/^  long  createContId(int aSid) { return (aSid << 10) ^ (aSid&0x3FF); };$/;"	f	class:CriticalityTC
createContext	Epoch.h	/^    void createContext(ThreadContext *context){$/;"	f	class:tls::Epoch
createDInst	DInst.cpp	/^DInst *DInst::createDInst(const Instruction *inst, VAddr va, int cId)$/;"	f	class:DInst
createGroup	CriticalityBuilder.cpp	/^CPNodeGroup* CriticalityBuilder::createGroup(CritID id, long sid, long hSid, Time_t startTime,$/;"	f	class:CriticalityBuilder
createGroup	CriticalityManager.cpp	/^CPNodeGroup* CriticalityBase::createGroup(CritID id, long sid, Time_t startTime,$/;"	f	class:CriticalityBase
createInst	DInst.cpp	/^DInst *DInst::createInst(InstID pc, VAddr va, int cId)$/;"	f	class:DInst
createMemBufferDomain	MemBuffer.cpp	/^MemBufferDomain* MemBuffer::createMemBufferDomain()$/;"	f	class:MemBuffer
createSubthread	TaskContext.cpp	/^int TaskContext::createSubthread(int cpu)$/;"	f	class:TaskContext
createSuccessor	ASVersion.cpp	/^HVersion *HVersion::createSuccessor(TaskContext *t, bool atomic)$/;"	f	class:HVersion
createSuccessor	HVersion.cpp	/^HVersion *HVersion::createSuccessor(TaskContext *t)$/;"	f	class:HVersion
createTextId	CriticalityTC.cpp	/^long CriticalityTC::createTextId()$/;"	f	class:CriticalityTC
createTime	CriticalityTC.h	/^  Time_t createTime;$/;"	m	class:CriticalityTC
createdNotSafeCount	Epoch.cpp	/^  size_t Epoch::createdNotSafeCount=0;$/;"	m	class:tls::Epoch	file:
createdNotSafeCount	Epoch.h	/^    static size_t createdNotSafeCount;$/;"	m	class:tls::Epoch
creationTime	BulkManager.h	/^    Time_t creationTime;\/\/time the chunk was object was created, still empty$/;"	m	class:BulkManager::Chunk
crit	CriticalityPredictor.h	/^    bool crit;$/;"	m	class:OracularCPred::OraclePredInfo
crit	CriticalityPredictor.h	/^  ProcessId *crit;$/;"	m	class:OracularCPred
critCnt	CriticalityPredictor.h	/^  int critCnt;$/;"	m	class:SpawnState
critMask	CriticalityController.h	/^  BIT_VECTOR critMask;$/;"	m	class:CriticalityController
critMask	CriticalityManager.h	/^  BIT_VECTOR critMask;$/;"	m	class:CriticalityManager
critPred	CriticalityManager.h	/^  CGPredictor *critPred;$/;"	m	class:CritScheduler
critSatCounter	CPPred.h	/^  int critSatCounter;$/;"	m	class:CPPredEntry
critTC	TaskContext.h	/^  CriticalityTC critTC;$/;"	m	class:TaskContext
critVersion	CriticalityPredictor.h	/^  HVersion   *critVersion;$/;"	m	class:EdgeCPred
critical	CriticalityManager.h	/^  CritLifetime critical; \/\/ parent critical$/;"	m	class:PredData
ctableNotTaken	BPred.h	/^  SCTable ctableNotTaken;$/;"	m	class:BPyags
ctableTaken	BPred.h	/^  SCTable ctableTaken;$/;"	m	class:BPyags
ctrl	CriticalityController.cpp	/^CriticalityController *CriticalityController::ctrl=NULL;$/;"	m	class:CriticalityController	file:
ctrl	CriticalityController.h	/^  static CriticalityController *ctrl;$/;"	m	class:CriticalityController
curr	ValueTable.h	/^    int curr;$/;"	m	class:ValueTable::PredEntry
currCrit	CriticalityPredictor.h	/^  size_t currCrit;$/;"	m	class:OracularCPred
currHoist	Profile.h	/^    long long currHoist;$/;"	m	class:Profile::TaskInfo
currLSpec	CriticalityPredictor.h	/^  size_t currLSpec;$/;"	m	class:OracularCPred
currSafe	CriticalityPredictor.h	/^  size_t currSafe;$/;"	m	class:OracularCPred
currTaskID	Profile.h	/^  int currTaskID;$/;"	m	class:Profile
currTime	Profile.h	/^  Time_t currTime;      \/\/Virtual time, TLS execution time$/;"	m	class:Profile
current	CriticalityPredictor.h	/^  ProcessId *current; \/\/head of current chain$/;"	m	class:EdgeCPred
current	CriticalityPredictor.h	/^  ProcessId *current;$/;"	m	class:PathCPred
currentBranchPredictor	TaskContext.h	/^  BPred *currentBranchPredictor;$/;"	m	class:TaskContext
currentCPU	CriticalityTC.h	/^  CritID currentCPU() {$/;"	f	class:CriticalityTC
currentCPU	RunningProcs.h	/^  GProcessor *currentCPU;$/;"	m	class:RunningProcs
currentChunk	BulkManager.h	/^  Chunk *currentChunk;$/;"	m	class:BulkManager
currentClockStamp	MemRequest.h	/^  Time_t currentClockStamp;$/;"	m	class:MemRequest
currentFinished	CriticalityTC.h	/^  bool currentFinished() {$/;"	f	class:CriticalityTC
currentFlow	Processor.cpp	/^FetchEngine *Processor::currentFlow()$/;"	f	class:Processor
currentFlow	SMTProcessor.cpp	/^FetchEngine *SMTProcessor::currentFlow()$/;"	f	class:SMTProcessor
currentID	DInst.cpp	/^long DInst::currentID=0;$/;"	m	class:DInst	file:
currentID	DInst.h	/^  static long currentID;$/;"	m	class:DInst
currentIPC	BulkManager.h	/^  float currentIPC;$/;"	m	class:PredefinedBulkManager
currentId	CriticalityTC.h	/^  CritID currentId() {$/;"	f	class:CriticalityTC
currentMemObj	MemRequest.h	/^  MemObj *currentMemObj;$/;"	m	class:MemRequest
currentParentSid	CriticalityTC.h	/^  int currentParentSid() {$/;"	f	class:CriticalityTC
currentSid	CriticalityTC.h	/^  long currentSid() {$/;"	f	class:CriticalityTC
currentSimpoint	OSSim.h	/^  int currentSimpoint;$/;"	m	class:OSSim
currentStartTime	CriticalityTC.h	/^  Time_t currentStartTime() {$/;"	f	class:CriticalityTC
currentSyncBecomeSafe	CriticalityTC.h	/^  bool currentSyncBecomeSafe() {$/;"	f	class:CriticalityTC
currentUnused	CriticalityTC.h	/^  bool currentUnused() {$/;"	f	class:CriticalityTC
cvm	CavaManager.h	/^    CavaManager *cvm;$/;"	m	class:CavaManager::CkpInfoEntry
cycletons	EnergyMgr.cpp	/^double EnergyMgr::cycletons(double clk) $/;"	f	class:EnergyMgr
dAddrV	Epoch.h	/^      Address   dAddrV;$/;"	m	struct:tls::Epoch::RaceAddrInfo
dAddrV	Epoch.h	/^      Address   dAddrV;$/;"	m	struct:tls::Epoch::RaceInfo
dAddrV	Epoch.h	/^      Address dAddrV;$/;"	m	class:tls::Epoch::TraceAccessEvent
dAddrV0	RatsManager.h	/^  VAddr dAddrV0;$/;"	m	class:RatsManager
dHoistOccThrd	Profile.h	/^  float dHoistOccThrd;$/;"	m	class:Profile
dInstPool	DInst.h	/^  static pool<DInst> dInstPool;$/;"	m	class:DInst
data	BPred.h	/^  BTBCache *data;$/;"	m	class:BPBTB
data	BPred.h	/^  CacheType *data;$/;"	m	class:BPCRap
data	Checkpoint.cpp	/^    unsigned long long data[blockSize\/sizeof(unsigned long long)];$/;"	m	class:tls::Checkpoint::BlockData	file:
data	MemBuffer.h	/^  unsigned long long data; \/\/ First variable of the class to be 8 bytes align$/;"	m	class:MemBufferEntry
dataDepViolation	TaskContext.h	/^  bool dataDepViolation; \/\/ true if the task has a pending restart$/;"	m	class:TaskContext
dataDepViolationID	DInst.h	/^  int         dataDepViolationID;$/;"	m	class:DInst
dataDepViolationID	TaskContext.h	/^  int dataDepViolationID; \/\/ Latest restart to wait for$/;"	m	class:TaskContext
dataRacesIgnored	Epoch.cpp	/^  bool Epoch::dataRacesIgnored;$/;"	m	class:tls::Epoch	file:
dataRacesIgnored	Epoch.h	/^    static bool dataRacesIgnored;$/;"	m	class:tls::Epoch
dataReq	MemRequest.h	/^  bool dataReq; \/\/ data or icache request$/;"	m	class:MemRequest
dataSizeFreq	MemAnalyzer.h	/^  GStatsHist dataSizeFreq;      $/;"	m	class:MemAnalyzer
dataSource	GMemorySystem.h	/^  MemObj *dataSource;$/;"	m	class:GMemorySystem
dcPrivateEnabled	BulkManager.cpp	/^bool BulkManager::dcPrivateEnabled;$/;"	m	class:BulkManager	file:
dcPrivateEnabled	BulkManager.h	/^  static bool dcPrivateEnabled;$/;"	m	class:BulkManager
ddis	DepWindow.h	/^  DDIS ddis;$/;"	m	class:DepWindow
deactivated	HVersion.h	/^    static bool deactivated() { return nChildMax == 0; }$/;"	f	class:HVersion::IDP
deadInst	DInst.h	/^  bool deadInst;$/;"	m	class:DInst
deadStore	DInst.h	/^  bool deadStore;$/;"	m	class:DInst
dec	Epoch.h	/^      void dec(void){$/;"	f	struct:tls::Epoch::VersionCount
decOutsPredictions	CavaManager.cpp	/^void CavaManager::decOutsPredictions(unsigned int ci, bool un)$/;"	f	class:CavaManager
decOutsReqs	ASVersion.cpp	/^void HVersion::decOutsReqs() $/;"	f	class:HVersion
decOutsReqs	HVersion.cpp	/^void HVersion::decOutsReqs() $/;"	f	class:HVersion
decSpawnConf	CriticalityPredictor.h	/^  int decSpawnConf;$/;"	m	class:EdgeStateX
decSquashConf	CriticalityPredictor.h	/^  int decSquashConf;$/;"	m	class:EdgeStateX
decStoreCounter	Resource.cpp	/^void FUMemory::decStoreCounter(FUStore *r)$/;"	f	class:FUMemory
decStoreCounterCB	Resource.h	/^                         &FUMemory::decStoreCounter,300> decStoreCounterCB;$/;"	t	class:FUMemory
decSuspendedCounter	ProcessId.cpp	/^void ProcessId::decSuspendedCounter(){$/;"	f	class:ProcessId
declareMemoryObj	GMemorySystem.cpp	/^MemObj *GMemorySystem::declareMemoryObj(const char *block, const char *field)$/;"	f	class:GMemorySystem
delEntry	Cluster.h	/^  void delEntry() {$/;"	f	class:Cluster
delXProcSrc2Dep	DInst.cpp	/^void DInst::delXProcSrc2Dep(){$/;"	f	class:DInst
delay	MultiManager.h	/^  bool delay;$/;"	m	class:MultiPathManager
delayFork	MultiManager.h	/^  DInst * delayFork;$/;"	m	class:MultiPathManager
delayedRelease	MultiManager.cpp	/^void MultiPathManager::delayedRelease(int cid){$/;"	f	class:MultiPathManager
dense	RatsManager.h	/^  SCTable dense;$/;"	m	class:RatsManager
dense	TaskContext.h	/^  int dense;$/;"	m	class:TaskContext
depTime	CriticalityTC.h	/^  std::vector<Time_t> depTime;$/;"	m	class:CriticalityTC
deps	Profile.h	/^    DepInfoType deps;$/;"	m	class:Profile::TaskInfo
depsAtRetire	DInst.h	/^  bool depsAtRetire;$/;"	m	class:DInst
depth	CriticalityPredictor.h	/^  int depth;$/;"	m	class:EdgeChain
dequeued	ASVersion.h	/^  bool dequeued;$/;"	m	class:HVersion
dequeued	HVersion.h	/^  bool dequeued;$/;"	m	class:HVersion
derefId	CriticalityBuilder.cpp	/^void CriticalityBuilder::derefId(CritID id)$/;"	f	class:CriticalityBuilder
derefId	CriticalityManager.cpp	/^void CriticalityBase::derefId(CritID id)$/;"	f	class:CriticalityBase
descheduleTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::descheduleTask(CPU_t i, CritID id)$/;"	f	class:CriticalityBuilder
descheduleTask	CriticalityManager.cpp	/^void CriticalityBase::descheduleTask(CPU_t i, CritID id)$/;"	f	class:CriticalityBase
descheduleTask	CriticalityTC.cpp	/^void CriticalityTC::descheduleTask()$/;"	f	class:CriticalityTC
descrSection	MemObj.h	/^  const char *descrSection;$/;"	m	class:MemObj
destroy	BulkManager.h	/^    void destroy(){$/;"	f	class:BulkManager::Chunk
destroy	CPBuilder.cpp	/^void CPBuilder::destroy()$/;"	f	class:CPBuilder
destroy	CriticalityTC.cpp	/^void CriticalityTC::destroy()$/;"	f	class:CriticalityTC
destroy	DInst.cpp	/^void DInst::destroy()$/;"	f	class:DInst
destroy	MemRequest.cpp	/^void CBMemRequest::destroy() $/;"	f	class:CBMemRequest
destroy	MemRequest.cpp	/^void DMemRequest::destroy() $/;"	f	class:DMemRequest
destroy	MemRequest.cpp	/^void IMemRequest::destroy() $/;"	f	class:IMemRequest
destroy	MemRequest.cpp	/^void StaticCBMemRequest::destroy() $/;"	f	class:StaticCBMemRequest
destroy	MemRequest.h	/^  void destroy() {$/;"	f	class:ReqPathEntry
destroy	ProcessId.cpp	/^void ProcessId::destroy()$/;"	f	class:ProcessId
destroy	TaskContext.cpp	/^void TaskContext::destroy()$/;"	f	class:TaskContext
destroyAll	ProcessId.cpp	/^void ProcessId::destroyAll() $/;"	f	class:ProcessId
detWinVersCounts	Epoch.cpp	/^  Epoch::VersionCounts Epoch::detWinVersCounts;$/;"	m	class:tls::Epoch	file:
detWinVersCounts	Epoch.h	/^    static VersionCounts detWinVersCounts;$/;"	m	class:tls::Epoch
dinst	DInst.h	/^  DInst *dinst;$/;"	m	class:DInstNext
dinst	MemRequest.h	/^  DInst *dinst;$/;"	m	class:MemRequest
dinstAck	MemRequest.cpp	/^void DMemRequest::dinstAck(DInst *dinst, MemOperation memOp, TimeDelta_t lat)$/;"	f	class:DMemRequest
dinstFetch	XactionManager.cpp	/^void XactionManager::dinstFetch(DInst *dinst)$/;"	f	class:XactionManager
disambiguate	BulkManager.cpp	/^void BulkManager::disambiguate(Chunk *cc)$/;"	f	class:BulkManager
disambiguateWithTheRest	BulkManager.cpp	/^void BulkManager::disambiguateWithTheRest(Chunk *cc)$/;"	f	class:BulkManager
discardCheckpoint	CavaManager.cpp	/^void CavaManager::discardCheckpoint(unsigned int ci) $/;"	f	class:CavaManager
discardCheckpoint	TaskContext.cpp	/^void TaskContext::discardCheckpoint()$/;"	f	class:TaskContext
discardedCkps	CavaManager.h	/^  DiscardedSet discardedCkps;$/;"	m	class:CavaManager
dispatchedInstruction	ConsistencyPolicy.cpp	/^void SCConsistencyPolicy::dispatchedInstruction(DInst* dinst)$/;"	f	class:SCConsistencyPolicy
dispatchedInstruction	ConsistencyPolicy.h	/^  virtual void dispatchedInstruction(DInst* dinst) { }$/;"	f	class:DefaultConsistencyPolicy
displaced	CriticalityPredictor.h	/^  int displaced;$/;"	m	class:EdgeStateX
displaced	MemAnalyzer.h	/^  virtual void displaced(PAddr addr) { }$/;"	f	class:GAddressPredictor
distance	Profile.h	/^    long long distance;   \/* # instruction between write and read *\/$/;"	m	class:Profile::DepInfo
dl	MemAnalyzer.cpp	/^DelinquentLoad *DelinquentLoad::dl;$/;"	m	class:DelinquentLoad	file:
dl	MemAnalyzer.h	/^  DelinquentLoad dl;$/;"	m	class:MemAnalyzer
dl	MemAnalyzer.h	/^  static DelinquentLoad *dl;$/;"	m	class:DelinquentLoad
doAtExecuted	DInst.cpp	/^void DInst::doAtExecuted()$/;"	f	class:DInst
doAtExecutedCB	DInst.h	/^  StaticCallbackMember0<DInst,&DInst::doAtExecuted> doAtExecutedCB;$/;"	m	class:DInst
doAtSimTime	DInst.cpp	/^void DInst::doAtSimTime()$/;"	f	class:DInst
doAtSimTimeCB	DInst.h	/^  StaticCallbackMember0<DInst,&DInst::doAtSimTime>  doAtSimTimeCB;$/;"	m	class:DInst
doCheckpoint	TaskContext.h	/^  bool doCheckpoint()     const    { return nInstructions >= nInstB4Ckp;}$/;"	f	class:TaskContext
doDelayedRestart	TaskContext.cpp	/^void TaskContext::doDelayedRestart(HVersion *v)$/;"	f	class:TaskContext
doFence	Resource.cpp	/^void FUStore::doFence() {$/;"	f	class:FUStore
doFenceDelay	Resource.cpp	/^void FUStore::doFenceDelay() {$/;"	f	class:FUStore
doFenceDelayCB	Resource.h	/^                         &FUStore::doFenceDelay> doFenceDelayCB;$/;"	t	class:FUStore
doInvalidate	MemObj.cpp	/^void DummyMemObj::doInvalidate(PAddr addr, ushort size)$/;"	f	class:DummyMemObj
doInvalidate	MemObj.h	/^  virtual void doInvalidate(PAddr addr, ushort size) { I(0); }$/;"	f	class:MemObj
doInvalidateCB	MemObj.h	/^                         &MemObj::doInvalidate, 101> doInvalidateCB;$/;"	t	class:MemObj
doLateDisamb	TaskContext.cpp	/^void TaskContext::doLateDisamb(HVersion *memVer)$/;"	f	class:TaskContext
doLazyRestart	TaskContext.cpp	/^void TaskContext::doLazyRestart(HVersion *memVer)$/;"	f	class:TaskContext
doPredict	BPred.h	/^  PredType doPredict(const Instruction *inst, InstID oracleID, bool doUpdate) {$/;"	f	class:BPred
doPredict	GProcessor.h	/^  bool doPredict(PAddr iPC,PAddr addr, bool squash, bool doUpdate){$/;"	f	class:SqPred
doPredictCon	BPred.h	/^  int doPredictCon(const Instruction *inst, InstID oracleID) {$/;"	f	class:BPred
doPrediction	VPred.cpp	/^bool ConfidenceEstimator::doPrediction(PAddr iPC, bool vhit, bool update)$/;"	f	class:ConfidenceEstimator
doRetire	Resource.cpp	/^void FUStore::doRetire(DInst *dinst)$/;"	f	class:FUStore
doSchedule	CriticalityController.cpp	/^void CriticalityController::doSchedule()$/;"	f	class:CriticalityController
doSchedule2	CriticalityController.cpp	/^void CriticalityController::doSchedule2()$/;"	f	class:CriticalityController
doVP	CavaManager.cpp	/^bool CavaManager::doVP(PAddr addr, PAddr iPC, unsigned value, bool countAcc)$/;"	f	class:CavaManager
doVP	RatsManager.cpp	/^bool RatsManager::doVP(PAddr addr, PAddr iPC, unsigned value, bool countAcc)$/;"	f	class:RatsManager
doingAnalysis	Epoch.cpp	/^  bool Epoch::doingAnalysis=false;$/;"	m	class:tls::Epoch	file:
doingAnalysis	Epoch.h	/^    static bool doingAnalysis;$/;"	m	class:tls::Epoch
done	SysCall.cpp	/^void SysCallClose::done(){$/;"	f	class:SysCallClose
done	SysCall.cpp	/^void SysCallSescSpawn::done(void){$/;"	f	class:SysCallSescSpawn
done	SysCall.cpp	/^void SysCallWrite::done(void){$/;"	f	class:SysCallWrite
done	SysCall.h	/^  virtual void done(void){};$/;"	f	class:SysCall
doneInstr	Epoch.h	/^    void doneInstr(void){$/;"	f	class:tls::Epoch
doneInstrCount	Epoch.h	/^    long long doneInstrCount;$/;"	m	class:tls::Epoch
doneItem	Pipeline.cpp	/^void Pipeline::doneItem(IBucket *b) $/;"	f	class:Pipeline
dstAnomalyFound	Epoch.h	/^    void dstAnomalyFound(void){$/;"	f	class:tls::Epoch
dstRaceFound	Epoch.h	/^    void dstRaceFound(void){$/;"	f	class:tls::Epoch
dtlb	GMemoryOS.h	/^  DTLBCache *dtlb;$/;"	m	class:DummyMemoryOS
dualMode	RatsManager.h	/^  bool dualMode;$/;"	m	class:RatsManager
dump	ASVersion.cpp	/^void HVersion::dump(const char *str, bool shortVersion) const$/;"	f	class:HVersion
dump	BPred.cpp	/^void BPredictor::dump(const char *str) const$/;"	f	class:BPredictor
dump	BulkManager.cpp	/^void BulkManager::Chunk::dump()$/;"	f	class:BulkManager::Chunk
dump	CPBuilder.h	/^    const char* dump() {$/;"	f	class:TokenContainer
dump	DInst.cpp	/^void DInst::dump(const char *str)$/;"	f	class:DInst
dump	FetchEngine.cpp	/^void FetchEngine::dump(const char *str) const$/;"	f	class:FetchEngine
dump	HVersion.cpp	/^void HVersion::dump(const char *str, bool shortVersion) const$/;"	f	class:HVersion
dump	HVersion.h	/^      void dump(const char *str) {$/;"	f	class:HVersion::IDP::PredEntry
dump	LDSTBuffer.cpp	/^void LDSTBuffer::dump(const char *str)$/;"	f	class:LDSTBuffer
dump	MemBuffer.cpp	/^void MemBufferEntry::dump(const char *str) const$/;"	f	class:MemBufferEntry
dump	MemObj.cpp	/^void MemObj::dump() const$/;"	f	class:MemObj
dumpAll	ASVersion.cpp	/^void HVersion::dumpAll() const$/;"	f	class:HVersion
dumpAll	HVersion.cpp	/^void HVersion::dumpAll() const$/;"	f	class:HVersion
dumpAll	TaskContext.cpp	/^void TaskContext::dumpAll()$/;"	f	class:TaskContext
dumpPath	MemRequest.cpp	/^void MemRequest::dumpPath()$/;"	f	class:MemRequest
dumpPathSumm	MemRequest.cpp	/^void MemRequest::dumpPathSumm()$/;"	f	class:MemRequest
dumpROB	GProcessor.cpp	/^void GProcessor::dumpROB()$/;"	f	class:GProcessor
dumpReset	MemAnalyzer.cpp	/^void AVSeries::dumpReset()$/;"	f	class:AVSeries
dumpString	CPBuilder.h	/^    char dumpString[NTOKENS+1];$/;"	m	class:TokenContainer
duplicate	ASVersion.h	/^  HVersion *duplicate() {$/;"	f	class:HVersion
duplicate	HVersion.h	/^  HVersion *duplicate() {$/;"	f	class:HVersion
dynPrivateEnabled	BulkManager.cpp	/^bool BulkManager::dynPrivateEnabled;$/;"	m	class:BulkManager	file:
dynPrivateEnabled	BulkManager.h	/^  static bool dynPrivateEnabled;$/;"	m	class:BulkManager
dynVoltScaling	EnergyMgr.cpp	/^void EnergyMgr::dynVoltScaling(CPU_t cpuId, int pairId, int maxPair)$/;"	f	class:EnergyMgr
dynVoltScaling	EnergyMgr.h	/^  static void dynVoltScaling(int cpuId, int pairId, int maxPair) {$/;"	f	class:EnergyMgr
dynamicHoistThrd	Profile.h	/^  int   dynamicHoistThrd;$/;"	m	class:Profile
e	CriticalityPredictor.h	/^  CritEvent_t e;$/;"	m	class:CPSchedEvent
eager	CavaManager.h	/^  enum VPMode { eager, atHeadROB, whenStall };$/;"	e	enum:CavaManager::VPMode
earlyRecycle	Resource.cpp	/^void FUBranch::earlyRecycle(DInst *dinst)$/;"	f	class:FUBranch
earlyRecycle	Resource.cpp	/^void FUEvent::earlyRecycle(DInst *dinst)$/;"	f	class:FUEvent
earlyRecycle	Resource.cpp	/^void FUGeneric::earlyRecycle(DInst *dinst)$/;"	f	class:FUGeneric
earlyRecycle	Resource.cpp	/^void FULoad::earlyRecycle(DInst *dinst)$/;"	f	class:FULoad
earlyRecycle	Resource.cpp	/^void FUMemory::earlyRecycle(DInst *dinst)$/;"	f	class:FUMemory
earlyRecycle	Resource.cpp	/^void FUStore::earlyRecycle(DInst *dinst)$/;"	f	class:FUStore
earlyRecycled	DInst.h	/^  bool earlyRecycled;$/;"	m	class:DInst
edgeCache	CriticalityPredictor.h	/^  EdgePredCache *edgeCache;$/;"	m	class:EdgeCPred
edgeStats	CriticalityPredictor.h	/^  EdgeStateStat edgeStats;$/;"	m	class:EdgeCPred
eliminated	Profile.h	/^    bool eliminated;            \/\/mark it if it is going to be eliminated$/;"	m	class:Profile::TaskInfo
empty	Checkpoint.cpp	/^    bool empty(void) const{$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
empty	Checkpoint.cpp	/^  bool Checkpoint::ExeOrder::empty() const{$/;"	f	class:tls::Checkpoint::ExeOrder
enStore	EnergyMgr.cpp	/^EnergyStore *EnergyMgr::enStore=0;$/;"	m	class:EnergyMgr	file:
enStore	EnergyMgr.h	/^  static EnergyStore *enStore;$/;"	m	class:EnergyMgr
enableAfterSquash	CriticalityController.h	/^  bool enableAfterSquash() {$/;"	f	class:CriticalityController
enableCacheModel	BulkManager.cpp	/^bool BulkManager::enableCacheModel;$/;"	m	class:BulkManager	file:
enableCacheModel	BulkManager.h	/^  static bool enableCacheModel;$/;"	m	class:BulkManager
enableCacheRestarts	BulkManager.cpp	/^bool BulkManager::enableCacheRestarts;$/;"	m	class:BulkManager	file:
enableCacheRestarts	BulkManager.h	/^  static bool enableCacheRestarts;$/;"	m	class:BulkManager
enableDeadInst	CavaManager.h	/^  const bool enableDeadInst;$/;"	m	class:CavaManager
enableDump	CriticalityBuilder.h	/^  bool enableDump;$/;"	m	class:CriticalityBuilder
enableDump	CriticalityManager.h	/^  bool enableDump;$/;"	m	class:CriticalityBase
enableFenceBreak	BulkManager.cpp	/^bool BulkManager::enableFenceBreak;$/;"	m	class:BulkManager	file:
enableFenceBreak	BulkManager.h	/^  static bool enableFenceBreak;$/;"	m	class:BulkManager
enableICache	FetchEngine.h	/^  bool enableICache;$/;"	m	class:FetchEngine
end	OSSim.h	/^    ulong end;$/;"	m	struct:OSSim::__anon5
endAcquire	Epoch.cpp	/^  void Epoch::endAcquire(void){$/;"	f	class:tls::Epoch
endCall	MemAnalyzer.h	/^  GStatsCntr endCall;$/;"	m	class:DelinquentLoad
endCurrentExe	Epoch.h	/^    Time_t endCurrentExe;$/;"	m	class:tls::Epoch
endDecisionExe	Epoch.h	/^    Time_t endDecisionExe;$/;"	m	class:tls::Epoch
endRelease	Epoch.cpp	/^  void Epoch::endRelease(void){$/;"	f	class:tls::Epoch
endTaskExecuted	TaskContext.cpp	/^void TaskContext::endTaskExecuted(Pid_t fpid)$/;"	f	class:TaskContext
endThread	Epoch.h	/^    void endThread(int exitCode){$/;"	f	class:tls::Epoch
endTrain	CriticalityManager.h	/^  void endTrain() {$/;"	f	class:CritScheduler
endedWaitMerge	Epoch.cpp	/^  EpochSet Epoch::endedWaitMerge;$/;"	m	class:tls::Epoch	file:
endedWaitMerge	Epoch.h	/^    static EpochSet endedWaitMerge;$/;"	m	class:tls::Epoch
endedWaitSafe	Epoch.cpp	/^  EpochSet Epoch::endedWaitSafe;$/;"	m	class:tls::Epoch	file:
endedWaitSafe	Epoch.h	/^    static EpochSet endedWaitSafe;$/;"	m	class:tls::Epoch
enoughMTMarks1	OSSim.h	/^  bool enoughMTMarks1() const {$/;"	f	class:OSSim
enoughMTMarks1	OSSim.h	/^  bool enoughMTMarks1(int pid,bool justMe) const {$/;"	f	class:OSSim
enoughMarks1	OSSim.h	/^  bool enoughMarks1() const { return !useSimMarks || simMarks.total > simMarks.begin; }$/;"	f	class:OSSim
enoughMarks1	OSSim.h	/^  bool enoughMarks1(int id) const {$/;"	f	class:OSSim
enoughMarks2	OSSim.h	/^  bool enoughMarks2() const { return useSimMarks && simMarks.total > simMarks.end; }$/;"	f	class:OSSim
enoughMarks2	OSSim.h	/^  bool enoughMarks2(int id) const {$/;"	f	class:OSSim
entered	MemAnalyzer.cpp	/^bool DelinquentLoad::entered = false;$/;"	m	class:DelinquentLoad	file:
entered	MemAnalyzer.h	/^  static bool entered;$/;"	m	class:DelinquentLoad
entrymax	BulkManager.h	/^  size_t entrymax;$/;"	m	class:BasicLogger
entrypos	BulkManager.h	/^  size_t entrypos;$/;"	m	class:BasicLogger
eof	CriticalityPredictor.h	/^  bool eof;$/;"	m	class:OracularCPred
epoch	Epoch.h	/^      Epoch *epoch;$/;"	m	class:tls::Epoch::BufferBlock
epoch1	Epoch.h	/^      Epoch     *epoch1;      $/;"	m	struct:tls::Epoch::RaceInfo
epoch2	Epoch.h	/^      Epoch     *epoch2;$/;"	m	struct:tls::Epoch::RaceInfo
eraseBlock	Epoch.cpp	/^  void Epoch::eraseBlock(Address baseAddr){$/;"	f	class:tls::Epoch
eraseBuffer	Epoch.cpp	/^  void Epoch::eraseBuffer(void){$/;"	f	class:tls::Epoch
eraseMember	AdvancedStats.cpp	/^  void Group::eraseMember(Group *newMember){$/;"	f	class:Stats::Group
estHighConfValueHit	VPred.h	/^  GStatsCntr estHighConfValueHit;$/;"	m	class:ConfidenceEstimator
estHighConfValueMiss	VPred.h	/^  GStatsCntr estHighConfValueMiss;$/;"	m	class:ConfidenceEstimator
estHit	VPred.h	/^  GStatsCntr estHit;$/;"	m	class:ConfidenceEstimator
estLowConfValueHit	VPred.h	/^  GStatsCntr estLowConfValueHit;$/;"	m	class:ConfidenceEstimator
estLowConfValueMiss	VPred.h	/^  GStatsCntr estLowConfValueMiss;$/;"	m	class:ConfidenceEstimator
estMiss	VPred.h	/^  GStatsCntr estMiss;$/;"	m	class:ConfidenceEstimator
estimatePower	CriticalityBuilder.h	/^  bool estimatePower;$/;"	m	class:CriticalityBuilder
estimatePower	CriticalityManager.h	/^  bool estimatePower;$/;"	m	class:CriticalityBase
estimatePrCritical	CriticalityManager.cpp	/^float CritScheduler::estimatePrCritical(TaskContext *tc,$/;"	f	class:CritScheduler
estimatePrSquash	CriticalityManager.cpp	/^float CritScheduler::estimatePrSquash(TaskContext *tc,$/;"	f	class:CritScheduler
etop	EnergyMgr.cpp	/^double EnergyMgr::etop(double energy) $/;"	f	class:EnergyMgr
etop	EnergyMgr.h	/^  static double etop(double energy) {$/;"	f	class:EnergyMgr
evList	CriticalityPredictor.h	/^  CPEventList evList;$/;"	m	class:CriticalityPredictor
eventBeginSimPoint	CriticalityController.cpp	/^void CriticalityController::eventBeginSimPoint(int num)$/;"	f	class:CriticalityController
eventBeginSimPoint	CriticalityManager.cpp	/^void CriticalityManager::eventBeginSimPoint(int num)$/;"	f	class:CriticalityManager
eventBeginTrain	CriticalityController.cpp	/^void CriticalityController::eventBeginTrain()$/;"	f	class:CriticalityController
eventBeginTrain	CriticalityManager.cpp	/^void CriticalityManager::eventBeginTrain()$/;"	f	class:CriticalityManager
eventCommit	CriticalityController.cpp	/^void CriticalityController::eventCommit(TaskContext *tc)$/;"	f	class:CriticalityController
eventCommit	CriticalityManager.cpp	/^void CriticalityManager::eventCommit(TaskContext *tc)$/;"	f	class:CriticalityManager
eventEndSimPoint	CriticalityController.cpp	/^void CriticalityController::eventEndSimPoint()$/;"	f	class:CriticalityController
eventEndSimPoint	CriticalityManager.cpp	/^void CriticalityManager::eventEndSimPoint()$/;"	f	class:CriticalityManager
eventEndTrain	CriticalityController.cpp	/^void CriticalityController::eventEndTrain()$/;"	f	class:CriticalityController
eventEndTrain	CriticalityManager.cpp	/^void CriticalityManager::eventEndTrain()$/;"	f	class:CriticalityManager
eventException	CriticalityController.cpp	/^void CriticalityController::eventException(TaskContext *tc)$/;"	f	class:CriticalityController
eventException	CriticalityManager.cpp	/^void CriticalityManager::eventException(TaskContext *tc)$/;"	f	class:CriticalityManager
eventExit	OSSim.cpp	/^void OSSim::eventExit(Pid_t cpid, int err)$/;"	f	class:OSSim
eventFinish	CriticalityController.cpp	/^void CriticalityController::eventFinish(TaskContext *tc)$/;"	f	class:CriticalityController
eventFinish	CriticalityManager.cpp	/^void CriticalityManager::eventFinish(TaskContext *tc)$/;"	f	class:CriticalityManager
eventFinish	CriticalityPredictor.cpp	/^void CriticalityPredictor::eventFinish(ProcessId *finish)$/;"	f	class:CriticalityPredictor
eventFinish	CriticalityPredictor.cpp	/^void EdgeCPred::eventFinish(ProcessId *afinish)$/;"	f	class:EdgeCPred
eventFinish	CriticalityPredictor.cpp	/^void OracularCPred::eventFinish(ProcessId *f)$/;"	f	class:OracularCPred
eventFinish	CriticalityPredictor.cpp	/^void PathCPred::eventFinish(ProcessId *afinish)$/;"	f	class:PathCPred
eventGetInstructionPointer	OSSim.cpp	/^icode_ptr OSSim::eventGetInstructionPointer(Pid_t pid)$/;"	f	class:OSSim
eventGetPPid	OSSim.cpp	/^Pid_t OSSim::eventGetPPid(Pid_t pid)$/;"	f	class:OSSim
eventGetconf	OSSim.cpp	/^long OSSim::eventGetconf(Pid_t curPid, Pid_t targPid)$/;"	f	class:OSSim
eventKilled	CriticalityController.cpp	/^void CriticalityController::eventKilled(TaskContext *tc)$/;"	f	class:CriticalityController
eventKilled	CriticalityManager.cpp	/^void CriticalityManager::eventKilled(TaskContext *tc)$/;"	f	class:CriticalityManager
eventLoadContext	OSSim.cpp	/^void OSSim::eventLoadContext(Pid_t pid)$/;"	f	class:OSSim
eventRemove	CriticalityPredictor.cpp	/^void CriticalityPredictor::eventRemove(ProcessId *r)$/;"	f	class:CriticalityPredictor
eventRemove	CriticalityPredictor.cpp	/^void EdgeCPred::eventRemove(ProcessId *r)$/;"	f	class:EdgeCPred
eventRemove	CriticalityPredictor.cpp	/^void PathCPred::eventRemove(ProcessId *r)$/;"	f	class:PathCPred
eventResume	OSSim.cpp	/^int OSSim::eventResume(Pid_t cpid, Pid_t pid)$/;"	f	class:OSSim
eventRetire	CriticalityPredictor.cpp	/^void OracularCPred::eventRetire(ProcessId *r)$/;"	f	class:OracularCPred
eventRetire	CriticalityPredictor.h	/^  virtual void eventRetire(ProcessId *r) { eventRemove(r); }$/;"	f	class:CriticalityPredictor
eventSafe	CriticalityController.cpp	/^void CriticalityController::eventSafe(TaskContext *tc)$/;"	f	class:CriticalityController
eventSafe	CriticalityManager.cpp	/^void CriticalityManager::eventSafe(TaskContext *tc)$/;"	f	class:CriticalityManager
eventSafest	CriticalityController.cpp	/^void CriticalityController::eventSafest(TaskContext *tc)$/;"	f	class:CriticalityController
eventSafest	CriticalityManager.cpp	/^void CriticalityManager::eventSafest(TaskContext *tc)$/;"	f	class:CriticalityManager
eventSaveContext	OSSim.cpp	/^void OSSim::eventSaveContext(Pid_t pid)$/;"	f	class:OSSim
eventSchedule	CriticalityController.cpp	/^void CriticalityController::eventSchedule() {$/;"	f	class:CriticalityController
eventSchedule	CriticalityManager.cpp	/^void CriticalityManager::eventSchedule() {$/;"	f	class:CriticalityManager
eventSetInstructionPointer	OSSim.cpp	/^void OSSim::eventSetInstructionPointer(Pid_t pid, icode_ptr picode){$/;"	f	class:OSSim
eventSetPPid	OSSim.cpp	/^void OSSim::eventSetPPid(Pid_t pid, Pid_t ppid)$/;"	f	class:OSSim
eventSimulationMark	OSSim.h	/^  void eventSimulationMark() {$/;"	f	class:OSSim
eventSimulationMark	OSSim.h	/^  void eventSimulationMark(int id,Pid_t pid) {$/;"	f	class:OSSim
eventSpawn	CriticalityController.cpp	/^void CriticalityController::eventSpawn(TaskContext *parent, TaskContext *child)$/;"	f	class:CriticalityController
eventSpawn	CriticalityManager.cpp	/^void CriticalityManager::eventSpawn(TaskContext *parent, TaskContext *child)$/;"	f	class:CriticalityManager
eventSpawn	CriticalityPredictor.cpp	/^void CriticalityPredictor::eventSpawn(ProcessId *parent, ProcessId *child)$/;"	f	class:CriticalityPredictor
eventSpawn	CriticalityPredictor.cpp	/^void EdgeCPred::eventSpawn(ProcessId *parent, ProcessId *child)$/;"	f	class:EdgeCPred
eventSpawn	CriticalityPredictor.cpp	/^void PathCPred::eventSpawn(ProcessId *parent, ProcessId *child)$/;"	f	class:PathCPred
eventSpawn	OSSim.cpp	/^void OSSim::eventSpawn(Pid_t ppid, Pid_t fid, long flags, bool stopped)$/;"	f	class:OSSim
eventSpawnOpcode	OSSim.h	/^  virtual void eventSpawnOpcode(int pid, const int *params, int nParams) {$/;"	f	class:OSSim
eventSquash	CriticalityController.cpp	/^void CriticalityController::eventSquash(TaskContext *from, TaskContext *to)$/;"	f	class:CriticalityController
eventSquash	CriticalityManager.cpp	/^void CriticalityManager::eventSquash(TaskContext *from, TaskContext *to)$/;"	f	class:CriticalityManager
eventSquash	CriticalityPredictor.cpp	/^void CriticalityPredictor::eventSquash(ProcessId *from, ProcessId *to)$/;"	f	class:CriticalityPredictor
eventSquash	CriticalityPredictor.cpp	/^void EdgeCPred::eventSquash(ProcessId *from, ProcessId *to)$/;"	f	class:EdgeCPred
eventSquash	CriticalityPredictor.cpp	/^void PathCPred::eventSquash(ProcessId *from, ProcessId *to)$/;"	f	class:PathCPred
eventSuspend	OSSim.cpp	/^int OSSim::eventSuspend(Pid_t cpid, Pid_t pid)$/;"	f	class:OSSim
eventSyncSafe	CriticalityController.cpp	/^void CriticalityController::eventSyncSafe(TaskContext *tc)$/;"	f	class:CriticalityController
eventSyncSafe	CriticalityPredictor.cpp	/^void CriticalityPredictor::eventSyncSafe(ProcessId *p)$/;"	f	class:CriticalityPredictor
eventSysconf	OSSim.cpp	/^void OSSim::eventSysconf(Pid_t ppid, Pid_t fid, long flags)$/;"	f	class:OSSim
eventWait	OSSim.cpp	/^void OSSim::eventWait(Pid_t cpid)$/;"	f	class:OSSim
eventYield	OSSim.cpp	/^int OSSim::eventYield(Pid_t curPid, Pid_t yieldPid)$/;"	f	class:OSSim
everCauseSquash	CriticalityTC.h	/^  bool everCauseSquash()    { return numCausedSquashes > 0; }$/;"	f	class:CriticalityTC
everRestarted	CriticalityTC.h	/^  bool everRestarted() { return restartFrom.size()>0 || numExceptions>0; }$/;"	f	class:CriticalityTC
exce	TaskContext.h	/^  bool exce;$/;"	m	class:TaskContext
exception	CriticalityTC.cpp	/^void CriticalityTC::exception()$/;"	f	class:CriticalityTC
exception	TaskContext.cpp	/^void TaskContext::exception()$/;"	f	class:TaskContext
exeOrder	Checkpoint.h	/^    ExeOrder exeOrder;$/;"	m	class:tls::Checkpoint
exeTime	DInst.h	/^  Time_t exeTime;$/;"	m	class:DInst
exec	Epoch.h	/^      enum ExecEnum {Spawning, Running, Waiting, Completed}    exec : 2;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::ExecEnum
exec	SysCall.cpp	/^void SysCallClose::exec(ThreadContext *context, icode_ptr picode){$/;"	f	class:SysCallClose
exec	SysCall.cpp	/^void SysCallExit::exec(ThreadContext *context,icode_ptr picode){$/;"	f	class:SysCallExit
exec	SysCall.cpp	/^void SysCallFree::exec(ThreadContext *context, icode_ptr picode){$/;"	f	class:SysCallFree
exec	SysCall.cpp	/^void SysCallMalloc::exec(ThreadContext *context, icode_ptr picode){$/;"	f	class:SysCallMalloc
exec	SysCall.cpp	/^void SysCallMmap::exec(ThreadContext *context, icode_ptr picode){$/;"	f	class:SysCallMmap
exec	SysCall.cpp	/^void SysCallMunmap::exec(ThreadContext *context, icode_ptr picode){$/;"	f	class:SysCallMunmap
exec	SysCall.cpp	/^void SysCallOpen::exec(ThreadContext *context,icode_ptr picode){$/;"	f	class:SysCallOpen
exec	SysCall.cpp	/^void SysCallRead::exec(ThreadContext *context,icode_ptr picode){$/;"	f	class:SysCallRead
exec	SysCall.cpp	/^void SysCallSescSpawn::exec(ThreadContext *context,icode_ptr picode){$/;"	f	class:SysCallSescSpawn
exec	SysCall.cpp	/^void SysCallWait::exec(ThreadContext *context,icode_ptr picode){$/;"	f	class:SysCallWait
exec	SysCall.cpp	/^void SysCallWrite::exec(ThreadContext *context,icode_ptr picode){$/;"	f	class:SysCallWrite
exec	SysCall.h	/^  virtual void exec(ThreadContext *context,icode_ptr picode){$/;"	f	class:SysCallTimes
execInstr	Epoch.h	/^    void execInstr(void){$/;"	f	class:tls::Epoch
execInstrCount	Epoch.h	/^    long long execInstrCount; $/;"	m	class:tls::Epoch
executed	Cluster.cpp	/^void ExecutedCluster::executed(DInst *dinst)$/;"	f	class:ExecutedCluster
executed	Cluster.cpp	/^void RetiredCluster::executed(DInst *dinst)$/;"	f	class:RetiredCluster
executed	DInst.h	/^  bool executed;$/;"	m	class:DInst
executed	DepWindow.cpp	/^void DepWindow::executed(DInst *dinst)$/;"	f	class:DepWindow
executed	HVersion.cpp	/^void HVersion::IDP::executed(Pid_t pid, PAddr addr, size_t nChild)$/;"	f	class:HVersion::IDP
executed	LDSTQ.cpp	/^bool LDSTQ::executed(DInst *dinst)$/;"	f	class:LDSTQ
executed	ProcessId.h	/^  bool executed;$/;"	m	class:ProcessId
executed	Resource.cpp	/^void FUBranch::executed(DInst *dinst)$/;"	f	class:FUBranch
executed	Resource.cpp	/^void FUGeneric::executed(DInst *dinst)$/;"	f	class:FUGeneric
executed	Resource.cpp	/^void FULoad::executed(DInst* dinst)$/;"	f	class:FULoad
executed	Resource.cpp	/^void FUStore::executed(DInst *dinst)$/;"	f	class:FUStore
executed	Resource.cpp	/^void Resource::executed(DInst *dinst)$/;"	f	class:Resource
executed	SysCall.h	/^  bool executed;$/;"	m	class:SysCall
executedLoad	ConsistencyPolicy.cpp	/^void SCConsistencyPolicy::executedLoad(DInst* dinst)$/;"	f	class:SCConsistencyPolicy
executedLoad	ConsistencyPolicy.h	/^  virtual void executedLoad(DInst* dinst) { }$/;"	f	class:DefaultConsistencyPolicy
executedStore	ConsistencyPolicy.cpp	/^void RCWPFConsistencyPolicy::executedStore(DInst* dinst)$/;"	f	class:RCWPFConsistencyPolicy
executedStore	ConsistencyPolicy.cpp	/^void SCConsistencyPolicy::executedStore(DInst* dinst)$/;"	f	class:SCConsistencyPolicy
executedStore	ConsistencyPolicy.cpp	/^void SCWPFConsistencyPolicy::executedStore(DInst* dinst)$/;"	f	class:SCWPFConsistencyPolicy
executedStore	ConsistencyPolicy.h	/^  virtual void executedStore(DInst* dinst) { }$/;"	f	class:DefaultConsistencyPolicy
exists_token	CPBuilder.h	/^    bool exists_token(int tokenId) {$/;"	f	class:TokenContainer
exitAtEnd	Epoch.h	/^    bool exitAtEnd;$/;"	m	class:tls::Thread
exitCalled	Epoch.h	/^    void exitCalled(int exitCode){$/;"	f	class:tls::Thread
extraWorkRate	Profile.h	/^  float extraWorkRate;$/;"	m	class:Profile
extractRaceAddresses	Epoch.h	/^    void extractRaceAddresses(void){$/;"	f	class:tls::Epoch
fake	DInst.h	/^  bool fake;$/;"	m	class:DInst
fakeFetch	FetchEngine.cpp	/^void FetchEngine::fakeFetch(IBucket *bucket, int fetchMax)$/;"	f	class:FetchEngine
fastWakeUpAndSelect	Cluster.h	/^  void fastWakeUpAndSelect(DInst* dinst){$/;"	f	class:Cluster
fastWakeUpAndSelect	DepWindow.cpp	/^void DepWindow::fastWakeUpAndSelect(DInst *dinst)$/;"	f	class:DepWindow
fenceClearTime	Resource.h	/^  GStatsHist   fenceClearTime;$/;"	m	class:FUStore
fenceLocallyPerformed	LDSTBuffer.cpp	/^void LDSTBuffer::fenceLocallyPerformed(DInst *dinst)$/;"	f	class:LDSTBuffer
fenceRetireTime	Resource.h	/^  Time_t fenceRetireTime;$/;"	m	class:FUStore
fenceStallCycles	Resource.h	/^  GStatsCntr   fenceStallCycles;$/;"	m	class:FUStore
fences	LDSTBuffer.cpp	/^LDSTBuffer::FenceEntryType LDSTBuffer::fences;$/;"	m	class:LDSTBuffer	file:
fences	LDSTBuffer.h	/^  static FenceEntryType fences;$/;"	m	class:LDSTBuffer
fetch	DInst.h	/^  FetchEngine *fetch;$/;"	m	class:DInst
fetch	FetchEngine.cpp	/^void FetchEngine::fetch(IBucket *bucket, int fetchMax)$/;"	f	class:FetchEngine
fetchDebugRegisters	FetchEngine.cpp	/^void FetchEngine::fetchDebugRegisters(const DInst *dinst)$/;"	f	class:FetchEngine
fetchDist	SMTProcessor.h	/^  GStatsHist fetchDist;$/;"	m	class:SMTProcessor
fetchFromSafe	SMTProcessor.h	/^  GStatsAvg fetchFromSafe;$/;"	m	class:SMTProcessor
fetchFromSpec	SMTProcessor.h	/^  GStatsAvg fetchFromSpec;$/;"	m	class:SMTProcessor
fetchTime	DInst.h	/^  Time_t fetchTime;$/;"	m	class:DInst
ffd	MemAnalyzer.h	/^  FILE *ffd;$/;"	m	class:AVSeries
fillPredList	CriticalityPredictor.cpp	/^void OracularCPred::fillPredList()$/;"	f	class:OracularCPred
finalize	MemAnalyzer.cpp	/^void MemAnalyzer::finalize()$/;"	f	class:MemAnalyzer
finalize	RiskLoadProf.cpp	/^void RiskLoadProf::finalize() $/;"	f	class:RiskLoadProf
findBlockPosition	Epoch.cpp	/^  Epoch::BlockVersions::findBlockPosition(const BufferBlock *block){$/;"	f	class:tls::Epoch::BlockVersions
findCreateLVID	GMemorySystem.cpp	/^GLVID *DummyMemorySystem::findCreateLVID(HVersion *ver) $/;"	f	class:DummyMemorySystem
findFetch	SMTProcessor.cpp	/^SMTProcessor::Fetch *SMTProcessor::findFetch(Pid_t pid) const$/;"	f	class:SMTProcessor
findPos	Epoch.h	/^    static EpochList::iterator findPos(ClockValue sClock, EpochList::iterator hint=allEpochs.begin()){$/;"	f	class:tls::Epoch
findReadConflicts	Epoch.cpp	/^  Epoch::BlockVersions::findReadConflicts(const BufferBlock *currBlock, size_t chunkIndx,$/;"	f	class:tls::Epoch::BlockVersions
findVictimPid	Processor.cpp	/^Pid_t Processor::findVictimPid() const$/;"	f	class:Processor
findVictimPid	SMTProcessor.cpp	/^Pid_t SMTProcessor::findVictimPid() const$/;"	f	class:SMTProcessor
findWriteConflicts	Epoch.cpp	/^  void Epoch::BlockVersions::findWriteConflicts(const BufferBlock *currBlock, size_t chunkIndx,$/;"	f	class:tls::Epoch::BlockVersions
finish	CriticalityPredictor.h	/^  bool finish;$/;"	m	class:EdgeCPred
finish	CriticalityPredictor.h	/^  bool finish;$/;"	m	class:PathCPred
finish	CriticalityTC.cpp	/^void CriticalityTC::finish()$/;"	f	class:CriticalityTC
finish	TaskContext.h	/^  static void finish() {$/;"	f	class:TaskContext
finishInflight	CavaManager.h	/^  void finishInflight(PAddr addr) { inflight.erase(addr); }$/;"	f	class:CavaManager
finishOps	CriticalityTC.cpp	/^void CriticalityTC::finishOps()$/;"	f	class:CriticalityTC
finishOpsTime	CriticalityTC.h	/^  Time_t finishOpsTime; \/\/done all ops (later)$/;"	m	class:CriticalityTC
finishTime	CriticalityTC.h	/^  Time_t finishTime;    \/\/done executing$/;"	m	class:SubtaskContext
finishV	CriticalityPredictor.h	/^  HASH_SET<ProcessId*,hash_pointer> finishV;$/;"	m	class:CriticalityPredictor
finishWorkNow	RunningProcs.cpp	/^void RunningProcs::finishWorkNow()$/;"	f	class:RunningProcs
finishWorkNowCB	OSSim.h	/^  StaticCallbackMember0<RunningProcs, &RunningProcs::finishWorkNow> finishWorkNowCB;$/;"	m	class:OSSim
finished	CriticalityPredictor.h	/^    bool finished;$/;"	m	class:OracularCPred::OraclePredInfo
finished	HVersion.h	/^  bool finished; \/\/ Task finished execution (all threads)$/;"	m	class:HVersion
finishedChunks	BulkManager.h	/^  ChunkDQ finishedChunks;$/;"	m	class:BulkManager
first	DInst.h	/^  DInstNext *first; \/\/ instrs that depend on this instr$/;"	m	class:DInst
firstContext	SMTProcessor.h	/^  const int firstContext;$/;"	m	class:SMTProcessor
firstId	CriticalityTC.h	/^  CritID firstId() {$/;"	f	class:CriticalityTC
firstInLineTime	BulkManager.h	/^    Time_t firstInLineTime;\/\/time the chunk made it to the top of the list$/;"	m	class:BulkManager::Chunk
firstParentSid	CriticalityTC.h	/^  int firstParentSid() {$/;"	f	class:CriticalityTC
firstSid	CriticalityTC.h	/^  int firstSid() {$/;"	f	class:CriticalityTC
firstSubtask	CriticalityTC.h	/^  bool firstSubtask() {$/;"	f	class:CriticalityTC
firstWOFCalled	Resource.h	/^  Time_t firstWOFCalled;$/;"	m	class:FUStore
fixPrivateSet	BulkManager.cpp	/^bool BulkManager::Chunk::fixPrivateSet(PAddr addr)$/;"	f	class:BulkManager::Chunk
flags	SysCall.h	/^    int flags;$/;"	m	struct:SysCallFileIO::OpenFileInfo
flow	FetchEngine.h	/^  ExecutionFlow flow;$/;"	m	class:FetchEngine
flow	FetchEngine.h	/^  TraceFlow flow;$/;"	m	class:FetchEngine
flow	SMTProcessor.h	/^  FetchContainer flow;$/;"	m	class:SMTProcessor
fname	BulkManager.cpp	/^char* BulkLogger::fname=0;$/;"	m	class:BulkLogger	file:
fname	BulkManager.h	/^  static char* fname;$/;"	m	class:BulkLogger
forwardBusEnergy	DepWindow.h	/^  GStatsEnergy *forwardBusEnergy;$/;"	m	class:DepWindow
foundSpawn	CriticalityPredictor.h	/^  int foundSpawn;$/;"	m	class:EdgeStateX
foundSquash	CriticalityPredictor.h	/^  int foundSquash;$/;"	m	class:EdgeStateX
fout	RiskLoadProf.h	/^  FILE *fout;$/;"	m	class:RiskLoadProf
freeBranches	Resource.h	/^  int freeBranches;$/;"	m	class:FUBranch
freeChainList	CriticalityPredictor.h	/^  ChainList freeChainList;$/;"	m	class:EdgeCPred
freeEntries	Resource.h	/^  int freeEntries() const { return freeLoads; }$/;"	f	class:FULoad
freeEntries	Resource.h	/^  int freeEntries() const { return freeStores; }$/;"	f	class:FUStore
freeIndices	Epoch.cpp	/^  Thread::IndexSet  Thread::freeIndices;$/;"	m	class:tls::Thread	file:
freeIndices	Epoch.h	/^    static IndexSet freeIndices;$/;"	m	class:tls::Thread
freeLoads	Resource.h	/^  int freeLoads;$/;"	m	class:FULoad
freeStores	Resource.h	/^  int               freeStores;$/;"	m	class:FUStore
freeThread	TaskContext.cpp	/^void TaskContext::freeThread(Pid_t pid)$/;"	f	class:TaskContext
freqScale	MemObj.h	/^  bool freqScale;$/;"	m	class:MemObj
frequency	OSSim.h	/^  double  frequency;$/;"	m	class:OSSim
from	CriticalityPredictor.h	/^  HASH_MAP<int,int> from;$/;"	m	class:SquashState
from	CriticalityPredictor.h	/^  ProcessId  *from;$/;"	m	class:CPSchedEvent
fromId	MemRequest.h	/^  int fromId;$/;"	m	class:ReqPathEntry
fuEnergy	Resource.h	/^  GStatsEnergyCG *fuEnergy;$/;"	m	class:FUGeneric
fullGraph	CriticalityBuilder.h	/^  bool fullGraph;$/;"	m	class:CriticalityBuilder
fullGraph	CriticalityManager.h	/^  bool fullGraph;$/;"	m	class:CriticalityBase
fullReplay	BulkManager.h	/^  bool fullReplay;$/;"	m	class:PredefinedBulkManager
futureAddresses	MemAnalyzer.h	/^    std::vector<PAddr> futureAddresses;$/;"	m	class:MarkovAP::PrefState
gAll	CriticalityManager.h	/^  GStatsCntr gAll;$/;"	m	class:CritLifetime
gID	HVersion.cpp	/^int HVersion::gID=0;$/;"	m	class:HVersion	file:
gID	HVersion.h	/^  static int gID;$/;"	m	class:HVersion
gLocal	CriticalityManager.h	/^  gLocal$/;"	e	enum:__anon1
gNo	CriticalityManager.h	/^  GStatsCntr gNo;$/;"	m	class:CritLifetime
gNo	CriticalityManager.h	/^  GStatsCntr gNo;$/;"	m	class:NonCritLifetime
gRAT	SMTProcessor.h	/^  DInst ***gRAT;$/;"	m	class:SMTProcessor
gStatTaskCritHist	CriticalityBuilder.h	/^  GStatsHist gStatTaskCritHist;$/;"	m	class:CriticalityBuilder
gStatTaskCritHist	CriticalityManager.h	/^  GStatsHist gStatTaskCritHist;$/;"	m	class:CriticalityBase
gTot	CriticalityManager.h	/^  GStatsCntr gTot;$/;"	m	class:CritLifetime
gTot	CriticalityManager.h	/^  GStatsCntr gTot;$/;"	m	class:NonCritLifetime
garbageCollect	ASVersion.cpp	/^void HVersion::garbageCollect(bool noTC)$/;"	f	class:HVersion
garbageCollect	GLVID.cpp	/^void GLVIDDummy::garbageCollect() $/;"	f	class:GLVIDDummy
garbageCollect	HVersion.cpp	/^void HVersion::garbageCollect(bool noTC)$/;"	f	class:HVersion
gen	Cluster.cpp	/^  PortGeneric *gen;$/;"	m	struct:UnitEntry	file:
gen	Resource.h	/^  PortGeneric *const gen;$/;"	m	class:Resource
genCurrentParentWithHist	CriticalityTC.h	/^  int genCurrentParentWithHist() {$/;"	f	class:CriticalityTC
genCurrentWithHist	CriticalityTC.h	/^  int genCurrentWithHist() {$/;"	f	class:CriticalityTC
genFirstParentWithHist	CriticalityTC.h	/^  int genFirstParentWithHist() {$/;"	f	class:CriticalityTC
genFirstWithHist	CriticalityTC.h	/^  int genFirstWithHist() {$/;"	f	class:CriticalityTC
genIdWithHist	CriticalityTC.cpp	/^int CriticalityTC::genIdWithHist(int aSid, bool parent)$/;"	f	class:CriticalityTC
genIndex	CriticalityPredictor.cpp	/^unsigned int CriticalityPredictor::genIndex(int sid, int parentSid)$/;"	f	class:CriticalityPredictor
genKey	Profile.h	/^  int genKey(int wInst, int rInst) {$/;"	f	class:Profile
genPreviousWithHist	CriticalityTC.h	/^  int genPreviousWithHist() {$/;"	f	class:CriticalityTC
geoidx	BPred.cpp	/^int BPOgehl::geoidx(long long Add, long long *histo, long long phisto, int m, int funct)$/;"	f	class:BPOgehl
get	EnergyMgr.cpp	/^double EnergyMgr::get(const char *block, const char *name, int procId)$/;"	f	class:EnergyMgr
get	EnergyMgr.cpp	/^double EnergyMgr::get(const char* name, int procId)$/;"	f	class:EnergyMgr
get	EnergyMgr.h	/^  static double get(const char *block, const char *name, int procId=0) {$/;"	f	class:EnergyMgr
get	EnergyMgr.h	/^  static double get(const char* name, int procId=0) {$/;"	f	class:EnergyMgr
getAccessType	Epoch.h	/^      AccessType getAccessType(void) const{$/;"	f	class:tls::Epoch::TraceAccessEvent
getAddr	MemBuffer.h	/^  RAddr getAddr()                 const { return (RAddr)(&data);  }$/;"	f	class:MemBufferEntry
getAddr	MemBuffer.h	/^  RAddr getAddr(RAddr addr)       const { return (RAddr)(&data)+calcChunkOffset(addr);  }$/;"	f	class:MemBufferEntry
getAllSubtaskSids	CriticalityTC.cpp	/^std::vector<int> CriticalityTC::getAllSubtaskSids()$/;"	f	class:CriticalityTC
getAndClearnGradInsts	FetchEngine.h	/^  long long getAndClearnGradInsts() {$/;"	f	class:FetchEngine
getAndClearnGradInsts	Processor.cpp	/^long long Processor::getAndClearnGradInsts(Pid_t pid)$/;"	f	class:Processor
getAndClearnGradInsts	SMTProcessor.cpp	/^long long SMTProcessor::getAndClearnGradInsts(Pid_t pid)$/;"	f	class:SMTProcessor
getAndClearnWPathInsts	FetchEngine.h	/^  long long getAndClearnWPathInsts() {$/;"	f	class:FetchEngine
getAndClearnWPathInsts	Processor.cpp	/^long long Processor::getAndClearnWPathInsts(Pid_t pid)$/;"	f	class:Processor
getAndClearnWPathInsts	SMTProcessor.cpp	/^long long SMTProcessor::getAndClearnWPathInsts(Pid_t pid)$/;"	f	class:SMTProcessor
getAvailableFlow	Processor.cpp	/^FetchEngine *Processor::getAvailableFlow()  $/;"	f	class:Processor
getAvailableFlow	SMTProcessor.cpp	/^FetchEngine* SMTProcessor::getAvailableFlow()$/;"	f	class:SMTProcessor
getAvailableProcessor	RunningProcs.cpp	/^GProcessor *RunningProcs::getAvailableProcessor(ProcessId *proc)$/;"	f	class:RunningProcs
getAvailableProcessor	RunningProcs.cpp	/^GProcessor *RunningProcs::getAvailableProcessor(void)$/;"	f	class:RunningProcs
getBPHistory	TaskContext.cpp	/^BPred::HistoryType TaskContext::getBPHistory(BPred::HistoryType cHistory)$/;"	f	class:TaskContext
getBPred	BPred.cpp	/^BPred *BPredictor::getBPred(int id, const char *sec)$/;"	f	class:BPredictor
getBPred	FetchEngine.h	/^  BPredictor *getBPred() const { return bpred; }$/;"	f	class:FetchEngine
getBPred	TaskContext.h	/^  BPred * getBPred() { return currentBranchPredictor; }$/;"	f	class:TaskContext
getBank	DInst.h	/^  long getBank() const { return bank; }$/;"	f	class:DInst
getBase	ASVersion.h	/^  VType getBase() { return base; }$/;"	f	class:HVersion
getBase	HVersion.h	/^  VType getBase() const { return base; }$/;"	f	class:HVersion
getBenchName	OSSim.h	/^  static const char *getBenchName(){$/;"	f	class:OSSim
getBenchSectionName	OSSim.h	/^  const char *getBenchSectionName() const {$/;"	f	class:OSSim
getBestPredEntry	CriticalityManager.h	/^  PredData * getBestPredEntry(int pSid) {$/;"	f	class:PredData
getBestPredEntry	CriticalityManager.h	/^  PredData *getBestPredEntry(int sid, int pSid=-1) {$/;"	f	class:CritScheduler
getBestPredEntry	CriticalityManager.h	/^  PredData *getBestPredEntry(int sid, int pSid=-1) {$/;"	f	class:CriticalityManager
getBlockCount	Epoch.h	/^      static size_t getBlockCount(void){$/;"	f	class:tls::Epoch::BufferBlock
getBoolPred	CPBuilder.cpp	/^bool CPBuilder::getBoolPred(ulonglong uniqueId) {$/;"	f	class:CPBuilder
getBrHist	MemAnalyzer.h	/^  unsigned getBrHist() const { return brHist; }$/;"	f	class:MemAnalyzer
getBufferBlock	Epoch.h	/^    BufferBlock *getBufferBlock(Address blockBase){$/;"	f	class:tls::Epoch
getBulkManager	GProcessor.h	/^  BulkManager *getBulkManager(){return bsc;}$/;"	f	class:GProcessor
getByIndex	Epoch.h	/^    static Thread *getByIndex(ThreadIndex index){$/;"	f	class:tls::Thread
getCPU	ProcessId.h	/^  CPU_t getCPU() const     { return cpu;  }$/;"	f	class:ProcessId
getCPUId	FetchEngine.h	/^  int getCPUId() const { return cpuId; }$/;"	f	class:FetchEngine
getCavaManager	GProcessor.h	/^  CavaManager *getCavaManager() { return cava; }$/;"	f	class:GProcessor
getCheckpoint	Checkpoint.cpp	/^  Checkpoint *Checkpoint::getCheckpoint(ClockValue epochClock){$/;"	f	class:tls::Checkpoint
getChild	SysCall.h	/^  Pid_t getChild(void){$/;"	f	class:SysCallWait
getChunkIndex	MemBuffer.h	/^  ulong getChunkIndex()           const { return cIndex;          }$/;"	f	class:MemBufferEntry
getCkpId	DInst.h	/^  unsigned long getCkpId()        { return ckpId; }$/;"	f	class:DInst
getCkpId	HVersion.h	/^  unsigned int getCkpId()        { return ckpId; }$/;"	f	class:HVersion
getCkpId	TaskContext.h	/^  unsigned int getCkpId() { return memVer->getCkpId(); }$/;"	f	class:TaskContext
getClock	Epoch.h	/^    ClockValue getClock(void){$/;"	f	class:tls::Epoch
getClock	Pipeline.h	/^  Time_t getClock() const { return clock; }$/;"	f	class:IBucket
getClockStamp	MemRequest.h	/^  Time_t getClockStamp() {$/;"	f	class:MemRequest
getClockTicks	GProcessor.h	/^  Time_t getClockTicks() const { return clockTicks; }$/;"	f	class:GProcessor
getClockTimer	RatsManager.h	/^  Time_t getClockTimer() const { return clockTimer;}$/;"	f	class:RatsManager
getClone	HVersion.h	/^  const HVersion *getClone(void) const {return cloneVer;}$/;"	f	class:HVersion
getCloneFlow	Processor.cpp	/^FetchEngine *Processor::getCloneFlow()  $/;"	f	class:Processor
getCloneFlow	SMTProcessor.cpp	/^FetchEngine* SMTProcessor::getCloneFlow()$/;"	f	class:SMTProcessor
getCluster	Resource.h	/^  Cluster *getCluster() { return cluster; }$/;"	f	class:Resource
getCluster	Resource.h	/^  const Cluster *getCluster() const { return cluster; }$/;"	f	class:Resource
getCntr	ValueTable.cpp	/^GStatsCntr *ValueTable::getCntr=0;$/;"	m	class:ValueTable	file:
getCntr	ValueTable.h	/^  static GStatsCntr *getCntr;$/;"	m	class:ValueTable
getCommitTokenOwner	BulkManager.cpp	/^BulkManager* PredefinedBulkManager::getCommitTokenOwner()$/;"	f	class:PredefinedBulkManager
getCompressedStaticId	TaskContext.cpp	/^int TaskContext::getCompressedStaticId(int staticId)$/;"	f	class:TaskContext
getConfidence	BPred.h	/^  bool getConfidence(const Instruction *inst){ return false;}$/;"	f	class:BPOgehl
getConsPref	DInst.h	/^  bool getConsPref() { return consPrefetchDone; }$/;"	f	class:DInst
getConsistencyPolicy	GProcessor.h	/^  ConsistencyPolicy* getConsistencyPolicy() const {return consPolicy;}$/;"	f	class:GProcessor
getContext	OSSim.cpp	/^ThreadContext *OSSim::getContext(Pid_t pid)$/;"	f	class:OSSim
getContextId	DInst.h	/^  int getContextId() const { return cId; }$/;"	f	class:DInst
getContextRegister	OSSim.cpp	/^long OSSim::getContextRegister(Pid_t pid, int regnum)$/;"	f	class:OSSim
getCritLevel	GProcessor.h	/^  CritLevel getCritLevel() { return cLevel; }$/;"	f	class:GProcessor
getCritLevel	TaskContext.h	/^  CritLevel getCritLevel() { return cLevel; }$/;"	f	class:TaskContext
getCritMask	CriticalityController.h	/^  BIT_VECTOR& getCritMask()    { return critMask;    }$/;"	f	class:CriticalityController
getCritMask	CriticalityManager.h	/^  BIT_VECTOR& getCritMask()    { return critMask;    }$/;"	f	class:CriticalityManager
getCritPrediction	CPPred.cpp	/^int CPPred::getCritPrediction(ulonglong uniqueId) {$/;"	f	class:CPPred
getCritSuccessor	CriticalityBuilder.cpp	/^int  CriticalityBuilderIface::getCritSuccessor( CPNodeGroup *g )$/;"	f	class:CriticalityBuilderIface
getCriticalVersion	CriticalityPredictor.cpp	/^HVersion * EdgeCPred::getCriticalVersion() {$/;"	f	class:EdgeCPred
getCurrentCPU	RunningProcs.h	/^  GProcessor *getCurrentCPU() const {$/;"	f	class:RunningProcs
getCurrentIcode	TaskContext.h	/^  icode_ptr getCurrentIcode() const { return sContext.getPicode(); }$/;"	f	class:TaskContext
getCurrentMemObj	MemRequest.h	/^  MemObj *getCurrentMemObj() const { return currentMemObj; }$/;"	f	class:MemRequest
getCurrentSid	CriticalityPredictor.cpp	/^int EdgeCPred::getCurrentSid(ProcessId *proc) {$/;"	f	class:EdgeCPred
getDInst	DInst.h	/^  DInst *getDInst() const { return dinst; }$/;"	f	class:DInstNext
getDInst	MemRequest.h	/^  DInst *getDInst() {$/;"	f	class:MemRequest
getDataAddr	Epoch.h	/^      Address getDataAddr(void) const{$/;"	f	class:tls::Epoch::TraceAccessEvent
getDataIfNeeded	MemBuffer.cpp	/^bool MemBufferEntry::getDataIfNeeded(const MemBufferEntry *stEntry, BitMaskType cpmask)$/;"	f	class:MemBufferEntry
getDataSource	GMemorySystem.cpp	/^MemObj *GMemorySystem::getDataSource()  const $/;"	f	class:GMemorySystem
getDescrSection	MemObj.h	/^  const char *getDescrSection() const { return descrSection; }$/;"	f	class:MemObj
getEntry	CriticalityPredictor.h	/^  EdgeStateX *getEntry(int tag, int sid=-1, int to=-1) {$/;"	f	class:EdgeStateStat
getEntry	ValueTable.cpp	/^ValueTable::PredEntry *ValueTable::PredEntry::getEntry(int i)$/;"	f	class:ValueTable::PredEntry
getEpoch	Epoch.h	/^    static Epoch *getEpoch(Pid_t pid){$/;"	f	class:tls::Epoch
getFenceEntry	LDSTBuffer.cpp	/^void LDSTBuffer::getFenceEntry(DInst *dinst) $/;"	f	class:LDSTBuffer
getFetch	DInst.h	/^  FetchEngine *getFetch() const {$/;"	f	class:DInst
getFirst	DInst.h	/^  const DInstNext *getFirst() const { return first; }$/;"	f	class:DInst
getFirstPending	DInst.h	/^  const DInst *getFirstPending() const { return first->getDInst(); }$/;"	f	class:DInst
getFlow	FetchEngine.h	/^  GFlow *getFlow(){ return &flow ; }$/;"	f	class:FetchEngine
getFlow	GProcessor.h	/^  FetchEngine *getFlow(){return currentFlow();}  $/;"	f	class:GProcessor
getFlowId	Processor.cpp	/^FetchEngine * Processor::getFlowId(int id){$/;"	f	class:Processor
getFlowId	SMTProcessor.cpp	/^FetchEngine * SMTProcessor::getFlowId(int id){$/;"	f	class:SMTProcessor
getFrequency	OSSim.h	/^  double getFrequency() const { return frequency; }$/;"	f	class:OSSim
getFromVFPair	EnergyMgr.cpp	/^double EnergyMgr::getFromVFPair(const char *name, int pairId) $/;"	f	class:EnergyMgr
getFromVFPair	EnergyMgr.h	/^  static double getFromVFPair(const char *name, int pairId=0) {$/;"	f	class:EnergyMgr
getGProcessor	Cluster.h	/^  GProcessor *getGProcessor() const { return gproc; }$/;"	f	class:Cluster
getGProcessor	DInst.cpp	/^GProcessor* DInst::getGProcessor() const{$/;"	f	class:DInst
getGProcessor	FetchEngine.h	/^  GProcessor* getGProcessor() { return gproc; }$/;"	f	class:FetchEngine
getGProcessor	MemRequest.h	/^  GProcessor *getGProcessor() {$/;"	f	class:MemRequest
getGlobalTimeline	TimelineManager.h	/^  static Timeline* getGlobalTimeline() { return &global; }$/;"	f	class:TimelineManager
getGradInsts	FetchEngine.h	/^  long long getGradInsts() {$/;"	f	class:FetchEngine
getGradInsts	Processor.cpp	/^long long Processor::getGradInsts(Pid_t pid)$/;"	f	class:Processor
getGradInsts	SMTProcessor.cpp	/^long long SMTProcessor::getGradInsts(Pid_t pid)$/;"	f	class:SMTProcessor
getHashHistoryMask	CPBuilder.h	/^    static ulonglong getHashHistoryMask(){ return cpPredHashHistoryMask;}$/;"	f	class:CPBuilder
getID	DInst.h	/^  long getID() const { return ID; }$/;"	f	class:DInst
getID	Epoch.h	/^    ThreadID getID(void) const{$/;"	f	class:tls::Thread
getIPCTracer	GProcessor.h	/^  IPCTracer *getIPCTracer() { return ipcTracer; }$/;"	f	class:GProcessor
getId	BulkManager.h	/^  BM_t getId()const{return bmId;}$/;"	f	class:BulkManager
getId	FetchEngine.h	/^  int getId() const {return Id;}$/;"	f	class:FetchEngine
getId	GMemorySystem.cpp	/^int GMemorySystem::getId() const$/;"	f	class:GMemorySystem
getId	GProcessor.h	/^  CPU_t getId() const { return Id; }$/;"	f	class:GProcessor
getId	HVersion.h	/^  int getId() const { return 0; }$/;"	f	class:HVersion
getId	HVersion.h	/^  int getId() const { return id; }$/;"	f	class:HVersion
getId	HVersion.h	/^  int getId() { return pos; }$/;"	f	class:HVersionDomain
getIdForName	DVFSManager.h	/^  static int getIdForName(const char *name) { return vfpairId[name]; }$/;"	f	class:DVFSManager
getInCriticalNode	CriticalityBuilder.cpp	/^int  CriticalityBuilderIface::getInCriticalNode( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
getInCriticalNode	CriticalityManager.cpp	/^int CriticalityManager::getInCriticalNode( CPVertex *v )$/;"	f	class:CriticalityManager
getIndex	Epoch.h	/^    ThreadIndex getIndex(void) const{$/;"	f	class:tls::Thread
getIndex	VPred.cpp	/^unsigned ConfidenceEstimator::getIndex(PAddr iPC)$/;"	f	class:ConfidenceEstimator
getIndex	VPred.cpp	/^unsigned Selector::getIndex(PAddr iPC)$/;"	f	class:Selector
getIndexUb	Epoch.h	/^    static ThreadIndex getIndexUb(void){$/;"	f	class:tls::Thread
getInfinite	Epoch.h	/^    static const VClock &getInfinite(void){$/;"	f	class:tls::VClock
getInitial	Epoch.h	/^    static const VClock &getInitial(void){$/;"	f	class:tls::VClock
getInst	DInst.h	/^  const Instruction *getInst() const { return inst; }$/;"	f	class:DInst
getInstAddr	MemBuffer.h	/^  ulong getInstAddr()             const { return instAddr;        }$/;"	f	class:MemBufferEntry
getInstrOffset	Epoch.h	/^      size_t getInstrOffset(void) const{$/;"	f	class:tls::Epoch::TraceEvent
getInstrSource	GMemorySystem.cpp	/^MemObj *GMemorySystem::getInstrSource() const $/;"	f	class:GMemorySystem
getInstructionPointer	FetchEngine.h	/^  icode_ptr getInstructionPointer(void){$/;"	f	class:FetchEngine
getInstructionPointer	Processor.cpp	/^icode_ptr Processor::getInstructionPointer(Pid_t pid)$/;"	f	class:Processor
getInstructionPointer	SMTProcessor.cpp	/^icode_ptr SMTProcessor::getInstructionPointer(Pid_t pid)$/;"	f	class:SMTProcessor
getInstructions	TaskContext.h	/^  long getInstructions()  const    { return nInstructions; }$/;"	f	class:TaskContext
getInsts	ProcessId.cpp	/^long long ProcessId::getInsts(){$/;"	f	class:ProcessId
getL1Retry	DInst.h	/^  bool getL1Retry() { return l1Retry; }$/;"	f	class:DInst
getL2MissDetection	MemRequest.h	/^  Time_t getL2MissDetection()            { return l2MissDetection; }$/;"	f	class:MemRequest
getLSQ	GProcessor.h	/^  LDSTQ *getLSQ() { return &lsq; }$/;"	f	class:GProcessor
getLVID	DInst.h	/^  GLVID   *getLVID() const { return lvid; }$/;"	f	class:DInst
getLVID	MemRequest.h	/^  GLVID *getLVID() const { $/;"	f	class:MemRequest
getLastSpawnCrit	CriticalityTC.h	/^  bool getLastSpawnCrit() {$/;"	f	class:CriticalityTC
getLastSquashCrit	CriticalityTC.h	/^  bool getLastSquashCrit() {$/;"	f	class:CriticalityTC
getLastTaskId	CriticalityTC.cpp	/^CritID CriticalityTC::getLastTaskId()$/;"	f	class:CriticalityTC
getLeastSpecRunning	CriticalityPredictor.cpp	/^ProcessId *EdgeCPred::getLeastSpecRunning()$/;"	f	class:EdgeCPred
getLine	CriticalityPredictor.h	/^  ELine* getLine(int tag) {$/;"	f	class:EdgeCPred
getLoadEntry	LDSTBuffer.cpp	/^void LDSTBuffer::getLoadEntry(DInst *dinst) $/;"	f	class:LDSTBuffer
getLogger	BulkManager.h	/^  static BulkLogger* getLogger(){return logger;}$/;"	f	class:BulkLogger
getLowerLevel	MemObj.h	/^  const LevelType *getLowerLevel() const { return &lowerLevel; }$/;"	f	class:MemObj
getLowestPriority	CriticalityPredictor.cpp	/^ProcessId * EdgeCPred::getLowestPriority()$/;"	f	class:EdgeCPred
getMax	Epoch.h	/^      size_t getMax(void) const{$/;"	f	struct:tls::Epoch::VersionCounts
getMaxFlows	GProcessor.h	/^  size_t getMaxFlows(void) const { return MaxFlows; }$/;"	f	class:GProcessor
getMaxNotRdOnly	Epoch.h	/^      size_t getMaxNotRdOnly(void) const{$/;"	f	struct:tls::Epoch::VersionCounts
getMemAnalyzer	OSSim.h	/^  MemAnalyzer *getMemAnalyzer() const {$/;"	f	class:OSSim
getMemBuffer	TaskContext.h	/^  MemBuffer * getMemBuffer() { return memBuffer; } $/;"	f	class:TaskContext
getMemBufferDomain	HVersion.h	/^  MemBufferDomain* getMemBufferDomain() const {$/;"	f	class:HVersion
getMemBufferDomain	HVersion.h	/^  MemBufferDomain* getMemBufferDomain() {$/;"	f	class:HVersionDomain
getMemObjVector	GMemorySystem.h	/^  void getMemObjVector(std::vector<MemObj*> &objV) {$/;"	f	class:MemoryObjContainer
getMemOpSerialNumber	DInst.h	/^  long int getMemOpSerialNumber() const {return memOpSerialNumber;}$/;"	f	class:DInst
getMemOperation	MemRequest.h	/^  MemOperation getMemOperation() const { return memOp; }$/;"	f	class:MemRequest
getMemValue	DInst.h	/^  ValueType getMemValue() const   { return memValue; }$/;"	f	class:DInst
getMemoryOS	GMemorySystem.cpp	/^GMemoryOS *GMemorySystem::getMemoryOS() const $/;"	f	class:GMemorySystem
getMemoryObjContainer	GMemorySystem.h	/^  MemoryObjContainer *getMemoryObjContainer(bool shared) {$/;"	f	class:GMemorySystem
getMemoryObjContainer	GMemorySystem.h	/^  const MemoryObjContainer *getMemoryObjContainer(bool shared) const {$/;"	f	class:GMemorySystem
getMemorySystem	GProcessor.h	/^  GMemorySystem *getMemorySystem() const { return memorySystem; }$/;"	f	class:GProcessor
getMultiManager	GProcessor.h	/^  MultiPathManager *getMultiManager() { return multi;}$/;"	f	class:GProcessor
getNChilds	ProcessId.h	/^  ulong getNChilds() const { return nChilds; }$/;"	f	class:ProcessId
getNDomains	HVersion.h	/^  static int getNDomains() { return vdVec.size(); }$/;"	f	class:HVersionDomain
getNGradInsts	ProcessId.cpp	/^long long ProcessId::getNGradInsts() {$/;"	f	class:ProcessId
getNRdHit	Profile.h	/^  long getNRdHit()  const { return nRdHit; }$/;"	f	class:ProfCache
getNRdMiss	Profile.h	/^  long getNRdMiss() const { return nRdMiss;}$/;"	f	class:ProfCache
getNWrHit	Profile.h	/^  long getNWrHit()  const { return nWrHit; }$/;"	f	class:ProfCache
getNWrMiss	Profile.h	/^  long getNWrMiss() const { return nWrMiss;}$/;"	f	class:ProfCache
getNewestRef	ASVersion.h	/^  static const HVersion *getNewestRef() { I(0); return NULL; }$/;"	f	class:HVersion
getNewestRef	HVersion.h	/^  static const HVersion *getNewestRef(const HVersionDomain *vd) { $/;"	f	class:HVersion
getNext	DInst.h	/^  DInstNext *getNext() { return nextDep; }$/;"	f	class:DInstNext
getNext	DInst.h	/^  const DInstNext *getNext() const { return nextDep; }$/;"	f	class:DInstNext
getNextBM	BulkManager.cpp	/^BulkManager* PredefinedBulkManager::getNextBM(BM_t bmId)$/;"	f	class:PredefinedBulkManager
getNextEpoch	Checkpoint.cpp	/^    void getNextEpoch(ClockValue parClk,$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
getNextEpoch	Checkpoint.cpp	/^  void Checkpoint::ExeOrder::getNextEpoch(ThreadID tid, ClockValue parClk,$/;"	f	class:tls::Checkpoint::ExeOrder
getNextFreeCycle	MemObj.cpp	/^Time_t DummyMemObj::getNextFreeCycle() const$/;"	f	class:DummyMemObj
getNextPending	DInst.h	/^  DInst *getNextPending() {$/;"	f	class:DInst
getNextRef	ASVersion.h	/^  const HVersion *getNextRef() const { I(0); return NULL; }$/;"	f	class:HVersion
getNextRef	HVersion.h	/^  const HVersion *getNextRef() const { return next; }$/;"	f	class:HVersion
getNextSuitableId	CriticalityBuilder.cpp	/^CritID CriticalityBuilder::getNextSuitableId(CPU_t i)$/;"	f	class:CriticalityBuilder
getNextSuitableId	CriticalityManager.cpp	/^CritID CriticalityBase::getNextSuitableId(CPU_t i)$/;"	f	class:CriticalityBase
getNonCloneFlow	Processor.cpp	/^FetchEngine *Processor::getNonCloneFlow()  $/;"	f	class:Processor
getNonCloneFlow	SMTProcessor.cpp	/^FetchEngine* SMTProcessor::getNonCloneFlow()$/;"	f	class:SMTProcessor
getNonCritMask	CriticalityController.h	/^  BIT_VECTOR& getNonCritMask() { return nonCritMask; }$/;"	f	class:CriticalityController
getNonCritMask	CriticalityManager.h	/^  BIT_VECTOR& getNonCritMask() { return nonCritMask; }$/;"	f	class:CriticalityManager
getNonCriticalTasks	CriticalityManager.cpp	/^std::vector<ProcessId*> CritScheduler::getNonCriticalTasks()$/;"	f	class:CritScheduler
getNumCPUs	OSSim.h	/^  size_t getNumCPUs() const { return cpus.size(); }$/;"	f	class:OSSim
getNumCachesInUpperLevels	MemObj.h	/^  const ulong getNumCachesInUpperLevels() const {$/;"	f	class:MemObj
getNumDInstsInROB	GProcessor.h	/^  size_t getNumDInstsInROB() const {return ROB.size();}$/;"	f	class:GProcessor
getNumLiveDInstsROB	GProcessor.cpp	/^size_t GProcessor::getNumLiveDInstsROB() const { $/;"	f	class:GProcessor
getNumRunningProcs	RunningProcs.h	/^  size_t getNumRunningProcs()const {$/;"	f	class:RunningProcs
getNumRunningThreads	ProcessId.h	/^  static unsigned int getNumRunningThreads() { return processQueue.size();  }$/;"	f	class:ProcessId
getNumSimPoints	OSSim.h	/^  int getNumSimPoints() {$/;"	f	class:OSSim
getNumSpawns	CriticalityTC.h	/^  int getNumSpawns() {$/;"	f	class:CriticalityTC
getNumThreads	ProcessId.cpp	/^unsigned int ProcessId::getNumThreads()$/;"	f	class:ProcessId
getNumThreadsNew	ProcessId.cpp	/^unsigned int ProcessId::getNumThreadsNew()$/;"	f	class:ProcessId
getOldestDuplicate	ASVersion.h	/^  static HVersion *getOldestDuplicate() { I(0); return NULL; }$/;"	f	class:HVersion
getOldestDuplicate	HVersion.h	/^  static HVersion *getOldestDuplicate(const HVersionDomain *vd) { $/;"	f	class:HVersion
getOldestRef	ASVersion.h	/^  static const HVersion *getOldestRef() { I(0); return NULL; }$/;"	f	class:HVersion
getOldestRef	HVersion.h	/^  static const HVersion *getOldestRef(const HVersionDomain *vd) { $/;"	f	class:HVersion
getOldestTaskContextRef	ASVersion.h	/^  static const HVersion *getOldestTaskContextRef() { I(0); return NULL; }$/;"	f	class:HVersion
getOldestTaskContextRef	HVersion.h	/^  static const HVersion *getOldestTaskContextRef(const HVersionDomain *vd) { $/;"	f	class:HVersion
getPAddr	MemRequest.h	/^  PAddr getPAddr() const { return pAddr; }$/;"	f	class:MemRequest
getPPid	ProcessId.h	/^  Pid_t getPPid() const    { return ppid; }$/;"	f	class:ProcessId
getPageSize	GMemorySystem.h	/^  static long  getPageSize()  { return 1<<Log2PageSize; }$/;"	f	class:GMemorySystem
getParent	HVersion.h	/^  const HVersion *getParent(void) const {return parent;}$/;"	f	class:HVersion
getParentDInst	DInst.h	/^  DInst *getParentDInst() const { return parentDInst; }$/;"	f	class:DInstNext
getParentSid	CriticalityBuilder.cpp	/^int  CriticalityBuilderIface::getParentSid( CPVertex *v, bool hist )$/;"	f	class:CriticalityBuilderIface
getParentSid	CriticalityManager.cpp	/^int CriticalityManager::getParentSid( CPVertex *v )$/;"	f	class:CriticalityManager
getParentSrc1	DInst.h	/^  DInst *getParentSrc1() const { return pend[0].getParentDInst(); }$/;"	f	class:DInst
getParentSrc2	DInst.h	/^  DInst *getParentSrc2() const { return pend[1].getParentDInst(); }$/;"	f	class:DInst
getPendEvent	DInst.h	/^  CallbackBase *getPendEvent() {$/;"	f	class:DInst
getPhaseConfig	CriticalityController.cpp	/^int CriticalityController::getPhaseConfig()$/;"	f	class:CriticalityController
getPhaseConfig	CriticalityManager.cpp	/^int CritScheduler::getPhaseConfig()$/;"	f	class:CritScheduler
getPid	Epoch.h	/^    Pid_t getPid(void) const{$/;"	f	class:tls::Epoch
getPid	FetchEngine.h	/^  Pid_t getPid() const { return pid; }$/;"	f	class:FetchEngine
getPid	ProcessId.h	/^  Pid_t getPid()  const    { return pid;  }$/;"	f	class:ProcessId
getPid	TaskContext.h	/^  Pid_t  getPid()  const { return tid; }$/;"	f	class:TaskContext
getPipelineId	Pipeline.h	/^  Time_t getPipelineId() const { return pipeId; }$/;"	f	class:IBucket
getPolicy	DVFSManager.h	/^  static DVFSPolicy_t getPolicy() {$/;"	f	class:DVFSManager
getPredEntry	CriticalityManager.h	/^  PredData * getPredEntry(int pSid) {$/;"	f	class:PredData
getPredEntry	CriticalityManager.h	/^  PredData *getPredEntry(int sid, int pSid=-1) {$/;"	f	class:CritScheduler
getPredEntry	CriticalityManager.h	/^  PredData *getPredEntry(int sid, int pSid=-1) {$/;"	f	class:CriticalityManager
getPredId	DInst.h	/^  unsigned int getPredId()        { return predId; }$/;"	f	class:DInst
getPredictionPolicy	CPBuilder.cpp	/^PredIndexPolicy CPBuilder::getPredictionPolicy()$/;"	f	class:CPBuilder
getPrevRef	ASVersion.h	/^  const HVersion *getPrevRef() const { I(0); return NULL; }$/;"	f	class:HVersion
getPrevRef	HVersion.h	/^  const HVersion *getPrevRef() const { return prev; }$/;"	f	class:HVersion
getPrevVersion	Epoch.h	/^      BufferBlock *getPrevVersion(bool getEquals) const{$/;"	f	class:tls::Epoch::BufferBlock
getPrio	ASVersion.h	/^  int  getPrio() const { $/;"	f	class:HVersion
getPrio	HVersion.h	/^  int  getPrio() const { $/;"	f	class:HVersion
getPriority	CriticalityManager.cpp	/^int CriticalityManager::getPriority(TaskContext *tc)$/;"	f	class:CriticalityManager
getPriority	MemRequest.h	/^  int  getPriority() { return priority; }$/;"	f	class:MemRequest
getPriority	OSSim.cpp	/^int OSSim::getPriority(Pid_t pid)$/;"	f	class:OSSim
getPriority	ProcessId.h	/^  int getPriority(void) const { return priority; }$/;"	f	class:ProcessId
getProcTimeline	TimelineManager.h	/^  static Timeline* getProcTimeline(int cpu) { return proc2Timeline[cpu]; }$/;"	f	class:TimelineManager
getProcessId	ProcessId.cpp	/^ProcessId *ProcessId::getProcessId(Pid_t pid)$/;"	f	class:ProcessId
getProcessor	OSSim.h	/^  GProcessor *getProcessor(CPU_t id) {$/;"	f	class:OSSim
getProcessor	RunningProcs.h	/^  GProcessor *getProcessor(CPU_t cpu) const {$/;"	f	class:RunningProcs
getProfPhase	OSSim.h	/^  int getProfPhase() const {$/;"	f	class:OSSim
getProfSectionName	OSSim.h	/^  const char *getProfSectionName() const {$/;"	f	class:OSSim
getProfiler	OSSim.h	/^  Profile *getProfiler() const {$/;"	f	class:OSSim
getRASHistory	TaskContext.h	/^  InstID *getRASHistory() { return rasStack; }$/;"	f	class:TaskContext
getRASIndex	TaskContext.h	/^  int     getRASIndex() { return rasIndex; }$/;"	f	class:TaskContext
getRAT	Processor.cpp	/^DInst **Processor::getRAT(const DInst *dinst)$/;"	f	class:Processor
getRAT	SMTProcessor.cpp	/^DInst **SMTProcessor::getRAT(const DInst *dinst)$/;"	f	class:SMTProcessor
getROBSize	GProcessor.h	/^  size_t getROBSize() const {return MaxROBSize;}$/;"	f	class:GProcessor
getRatsManager	GProcessor.h	/^  RatsManager *getRatsManager() { return rats;}$/;"	f	class:GProcessor
getReachedHeadOfROB	DInst.h	/^  Time_t getReachedHeadOfROB() { return reachedHeadOfROB; }$/;"	f	class:DInst
getReadSet	MemBuffer.h	/^  AddressSet& getReadSet() { return readSet; }$/;"	f	class:MemBuffer
getRealAddr	MemBuffer.h	/^  RAddr getRealAddr() const { return realAddr; }$/;"	f	class:MemBufferEntry
getReplayQInsts	GProcessor.cpp	/^void GProcessor::getReplayQInsts(FastQueue<DInst*>* newQ){$/;"	f	class:GProcessor
getReplayQSize	GProcessor.h	/^  size_t getReplayQSize() const {return replayQ.size();}$/;"	f	class:GProcessor
getReportFileName	OSSim.h	/^  const char *getReportFileName(){$/;"	f	class:OSSim
getResource	Cluster.h	/^  Resource *getResource(InstType type) const {$/;"	f	class:Cluster
getResource	Cluster.h	/^  Resource *getResource(InstType type) const {$/;"	f	class:ClusterManager
getResource	DInst.h	/^  Resource *getResource() const { return resource; }$/;"	f	class:DInst
getRestartVerRef	DInst.h	/^  const HVersion *getRestartVerRef() const { return restartVer; }$/;"	f	class:DInst
getRestartVerRef	MemRequest.h	/^  const HVersion *getRestartVerRef() const { $/;"	f	class:MemRequest
getSCDependent	DInst.h	/^  DInst *getSCDependent() const {$/;"	f	class:DInst
getSCPrev	DInst.h	/^  DInst* getSCPrev() const{$/;"	f	class:DInst
getSPred	GProcessor.cpp	/^SqPred *SPredictor::getSPred(int id, const char *sec)$/;"	f	class:SPredictor
getSchedMask	CriticalityManager.h	/^  BIT_VECTOR& getSchedMask(CritLevel l) {$/;"	f	class:CriticalityManager
getSerialNumber	DInst.h	/^  unsigned getSerialNumber() { return serialNumber; }$/;"	f	class:DInst
getSharedMemObjVector	GMemorySystem.h	/^  static void getSharedMemObjVector(std::vector<MemObj*> &v) {$/;"	f	class:GMemorySystem
getSimPoint	OSSim.h	/^  int getSimPoint() {$/;"	f	class:OSSim
getSimulationMark	OSSim.h	/^  ulong getSimulationMark() const { return simMarks.total; }$/;"	f	class:OSSim
getSimulationMark	OSSim.h	/^  ulong getSimulationMark(int id) const {$/;"	f	class:OSSim
getSimulationMark1	OSSim.h	/^  ulong getSimulationMark1() const { return simMarks.begin; }$/;"	f	class:OSSim
getSimulationMark1	OSSim.h	/^  ulong getSimulationMark1(int id) const {$/;"	f	class:OSSim
getSimulationMark2	OSSim.h	/^  ulong getSimulationMark2() const { return simMarks.end; }$/;"	f	class:OSSim
getSimulationMark2	OSSim.h	/^  ulong getSimulationMark2(int id) const {$/;"	f	class:OSSim
getSpawnAddr	TaskContext.h	/^  PAddr getSpawnAddr() const { return spawnAddr; }$/;"	f	class:TaskContext
getSquashPred	CriticalityPredictor.cpp	/^bool EdgeCPred::getSquashPred(ProcessId *from, ProcessId *to)$/;"	f	class:EdgeCPred
getSquashTaskId	CriticalityTC.cpp	/^CritID CriticalityTC::getSquashTaskId()$/;"	f	class:CriticalityTC
getState	OSSim.cpp	/^ProcessIdState OSSim::getState(Pid_t pid)$/;"	f	class:OSSim
getState	ProcessId.h	/^  ProcessIdState getState() const{ return state; }$/;"	f	class:ProcessId
getStaticId	TaskContext.h	/^  int getStaticId() const { return staticId; }$/;"	f	class:TaskContext
getStatus	GProcessor.cpp	/^int GProcessor::getStatus(void){$/;"	f	class:GProcessor
getStoreEntry	LDSTBuffer.cpp	/^void LDSTBuffer::getStoreEntry(DInst *dinst) $/;"	f	class:LDSTBuffer
getSubLVID	DInst.h	/^  SubLVIDType getSubLVID() const { return subLVID; }$/;"	f	class:DInst
getSubLVID	GLVID.cpp	/^SubLVIDType GLVIDDummy::getSubLVID() const $/;"	f	class:GLVIDDummy
getSubLVID	MemRequest.h	/^  SubLVIDType getSubLVID() const { $/;"	f	class:MemRequest
getSuccessorSid	CriticalityBuilder.cpp	/^int  CriticalityBuilderIface::getSuccessorSid( CPVertex *v, bool hist )$/;"	f	class:CriticalityBuilderIface
getSumLine	CriticalityPredictor.h	/^  ELine* getSumLine(int tag) {$/;"	f	class:EdgeCPred
getSuspendedCounter	ProcessId.h	/^  int getSuspendedCounter() const  { return suspendedCounter; }$/;"	f	class:ProcessId
getSymbolicName	MemObj.h	/^  const char *getSymbolicName() const { return symbolicName; }$/;"	f	class:MemObj
getTag	HVersion.h	/^      PredEntryTag getTag() const { return tag; }$/;"	f	class:HVersion::IDP::PredEntry
getTaskContext	ASVersion.h	/^  TaskContext *getTaskContext() const { return tc; }$/;"	f	class:HVersion
getTaskContext	HVersion.h	/^  TaskContext *getTaskContext() const { return tc; }$/;"	f	class:HVersion
getTaskContext	TaskContext.h	/^  static TaskContext *getTaskContext(Pid_t tid) {$/;"	f	class:TaskContext
getThread	Epoch.h	/^    Thread *getThread(void) const{$/;"	f	class:tls::Epoch
getThreadContext	FetchEngine.h	/^  ThreadContext *getThreadContext(void){$/;"	f	class:FetchEngine
getThreadContext	Processor.cpp	/^ThreadContext *Processor::getThreadContext(Pid_t pid)$/;"	f	class:Processor
getThreadContext	SMTProcessor.cpp	/^ThreadContext *SMTProcessor::getThreadContext(Pid_t pid)$/;"	f	class:SMTProcessor
getTid	Epoch.h	/^    ThreadID getTid(void) const{$/;"	f	class:tls::Epoch
getTime	DInst.h	/^  Time_t getTime(void){return when;}$/;"	f	class:DInst
getTime	Epoch.h	/^      Time_t getTime(void) const{$/;"	f	class:tls::Epoch::TraceEvent
getTimeline	GProcessor.h	/^  Timeline* getTimeline() const { return timeline; }$/;"	f	class:GProcessor
getTmpTotInst	TaskContext.h	/^  long long getTmpTotInst(void) const {return tmpTotInst;}$/;"	f	class:TaskContext
getTmpWaitTime	TaskContext.h	/^  long long  getTmpWaitTime(void)  { return tmpWaitTime;}$/;"	f	class:TaskContext
getToken	CPBuilder.cpp	/^int CPBuilder::getToken()$/;"	f	class:CPBuilder
getUniqueId	CriticalityTC.cpp	/^CritID CriticalityTC::getUniqueId()$/;"	f	class:CriticalityTC
getUpperLevel	MemObj.h	/^  const LevelType *getUpperLevel() const { return &upperLevel; }$/;"	f	class:MemObj
getUpperLevelSize	MemObj.h	/^  const ulong getUpperLevelSize() const { return upperLevel.size(); }$/;"	f	class:MemObj
getVClock	Epoch.h	/^    const VClock &getVClock(void) const{$/;"	f	class:tls::Epoch
getVDomain	HVersion.h	/^  static HVersionDomain* getVDomain(int id) { return vdVec[id]; }$/;"	f	class:HVersionDomain
getVFId	DVFSManager.h	/^  static int getVFId(CPU_t i) { return vfpairs[(size_t)i]; }$/;"	f	class:DVFSManager
getVMemReq	MemRequest.h	/^  VMemReq *getVMemReq() const {$/;"	f	class:MemRequest
getVaddr	DInst.h	/^  VAddr getVaddr() const { return vaddr;  }$/;"	f	class:DInst
getVaddr	MemRequest.cpp	/^VAddr CBMemRequest::getVaddr() const $/;"	f	class:CBMemRequest
getVaddr	MemRequest.cpp	/^VAddr DMemRequest::getVaddr() const $/;"	f	class:DMemRequest
getVaddr	MemRequest.cpp	/^VAddr IMemRequest::getVaddr() const $/;"	f	class:IMemRequest
getVaddr	MemRequest.cpp	/^VAddr StaticCBMemRequest::getVaddr() const $/;"	f	class:StaticCBMemRequest
getValue	VPred.cpp	/^ValueType BHLVPred::getValue(PAddr addr, PAddr iPC)$/;"	f	class:BHLVPred
getValue	VPred.cpp	/^ValueType LVPred::getValue(PAddr addr, PAddr iPC)$/;"	f	class:LVPred
getValue	VPred.cpp	/^ValueType Selector::getValue(PAddr addr, PAddr iPC)$/;"	f	class:Selector
getValue	VPred.h	/^  ValueType getValue(PAddr addr, PAddr iPC) { return lastValue; }$/;"	f	class:GlobalLVPred
getValue	VPred.h	/^  virtual ValueType getValue(PAddr addr, PAddr iPC) { return 0; }$/;"	f	class:GValuePredictor
getVersion	CriticalityPredictor.cpp	/^HVersion * CriticalityPredictor::getVersion(ProcessId *p) {$/;"	f	class:CriticalityPredictor
getVersion	TaskContext.h	/^  HVersion *getVersion() const { return memVer; }$/;"	f	class:TaskContext
getVersionDomain	HVersion.h	/^  HVersionDomain* getVersionDomain() const {$/;"	f	class:HVersion
getVersionDuplicate	TaskContext.h	/^  HVersion *getVersionDuplicate() const { $/;"	f	class:TaskContext
getVersionRef	DInst.h	/^  const HVersion *getVersionRef() const { return lvidVersion; }$/;"	f	class:DInst
getVersionRef	MemBuffer.h	/^  const HVersion *getVersionRef() const { return memVer; }$/;"	f	class:MemBuffer
getVersionRef	MemBuffer.h	/^  const HVersion *getVersionRef() const { return ver;             }$/;"	f	class:MemBufferEntry
getVersionRef	MemRequest.h	/^  const HVersion *getVersionRef() const { $/;"	f	class:MemRequest
getVersionRef	TaskContext.h	/^  const HVersion *getVersionRef() const { return memVer; }$/;"	f	class:TaskContext
getVersions	Epoch.h	/^      BlockVersions *getVersions(void) const{$/;"	f	class:tls::Epoch::BufferBlock
getVersions	Epoch.h	/^      static BlockVersions *getVersions(Address blockBase){$/;"	f	class:tls::Epoch::BlockVersions
getWakeUpTime	DInst.h	/^  Time_t getWakeUpTime() const { return wakeUpTime; }$/;"	f	class:DInst
getWinHead	CriticalityBuilder.h	/^  size_t getWinHead() { return winHead; }$/;"	f	class:CriticalityBuilder
getWinHead	CriticalityManager.h	/^  size_t getWinHead() { return winHead; }$/;"	f	class:CriticalityBase
getWindow	CriticalityBuilder.h	/^  CPNodeGroup * getWindow(size_t i) { return window[i]; }$/;"	f	class:CriticalityBuilder
getWindow	CriticalityManager.h	/^  CPNodeGroup * getWindow(size_t i) { return window[i]; }$/;"	f	class:CriticalityBase
getWriteSet	MemBuffer.h	/^  AddressSet& getWriteSet() { return writeSet; }$/;"	f	class:MemBuffer
getWriteSnapshot	MemBuffer.h	/^  AddressSet& getWriteSnapshot() { return writeSnapshot; }$/;"	f	class:MemBuffer
getconf	ProcessId.cpp	/^long ProcessId::getconf(void)$/;"	f	class:ProcessId
getnChild	HVersion.h	/^      size_t getnChild() const { return nChild; }$/;"	f	class:HVersion::IDP::PredEntry
getnInst2Sim	OSSim.h	/^  long long getnInst2Sim() const { return nInst2Sim;  }$/;"	f	class:OSSim
getnInst2Skip	OSSim.h	/^  long long getnInst2Skip() const { return nInst2Skip;  }$/;"	f	class:OSSim
getnInstCommited2Sim	OSSim.h	/^  long long getnInstCommited2Sim() const { return nInstCommited2Sim; }$/;"	f	class:OSSim
getnOutsReqs	HVersion.h	/^  int  getnOutsReqs() const { return nOutsReqs; }$/;"	f	class:HVersion
gh	BPred.h	/^  HistoryType gh;$/;"	m	class:BPred
ghist	BPred.h	/^  long long *ghist;$/;"	m	class:BPOgehl
ghist	CriticalityManager.h	/^  HASH_MAP<int,PredData*> ghist; \/\/1-level global history$/;"	m	class:PredData
glength	BPred.h	/^  const int glength;$/;"	m	class:BPOgehl
global	TimelineManager.h	/^  static GlobalTimeline global;$/;"	m	class:TimelineManager
globalCkpId	HVersion.cpp	/^unsigned int HVersionDomain::globalCkpId = 0;$/;"	m	class:HVersionDomain	file:
globalCkpId	HVersion.h	/^  static unsigned int globalCkpId;$/;"	m	class:HVersionDomain
globalSafe	Epoch.h	/^    static EpochList::iterator globalSafe;$/;"	m	class:tls::Epoch
globalSafeAvailable	Epoch.cpp	/^  bool Epoch::globalSafeAvailable=true;$/;"	m	class:tls::Epoch	file:
globalSafeAvailable	Epoch.h	/^    static bool globalSafeAvailable;$/;"	m	class:tls::Epoch
globalSave	Epoch.cpp	/^  void Epoch::globalSave(void){$/;"	f	class:tls::Epoch
globalTable	BPred.h	/^  SCTable globalTable;$/;"	m	class:BP2level
globalTable	BPred.h	/^  SCTable globalTable;$/;"	m	class:BPHybrid
glvid	GMemorySystem.h	/^  GLVIDDummy glvid;$/;"	m	class:DummyMemorySystem
gms	FetchEngine.h	/^  GMemorySystem *gms;$/;"	m	class:FetchEngine
goDown	MemRequest.h	/^  void goDown(TimeDelta_t lat, MemObj *newMemObj) {$/;"	f	class:MemRequest
goDownAbs	MemRequest.h	/^  void goDownAbs(Time_t time, MemObj *newMemObj) {$/;"	f	class:MemRequest
goRabbitMode	FetchEngine.h	/^  void goRabbitMode(long long n2Skip) {$/;"	f	class:FetchEngine
goRabbitMode	Processor.cpp	/^void Processor::goRabbitMode(long long n2Skip)$/;"	f	class:Processor
goRabbitMode	SMTProcessor.cpp	/^void SMTProcessor::goRabbitMode(long long n2Skip)$/;"	f	class:SMTProcessor
goUp	MemRequest.h	/^  void goUp(TimeDelta_t lat) {$/;"	f	class:MemRequest
goUpAbs	MemRequest.h	/^  void goUpAbs(Time_t time) {$/;"	f	class:MemRequest
goingHigher	MemAnalyzer.h	/^    bool goingHigher;$/;"	m	class:StrideAP::PrefState
good	ValueTable.h	/^    void good() {$/;"	f	class:ValueTable::PredEntry
goodCntr	ValueTable.cpp	/^GStatsCntr *ValueTable::goodCntr=0;$/;"	m	class:ValueTable	file:
goodCntr	ValueTable.h	/^    GStatsCntr goodCntr;$/;"	m	class:ValueTable::PredEntry
goodCntr	ValueTable.h	/^  static GStatsCntr *goodCntr;$/;"	m	class:ValueTable
gproc	BulkManager.h	/^  GProcessor  *gproc;$/;"	m	class:BulkManager
gproc	Cluster.h	/^  GProcessor *const gproc;$/;"	m	class:Cluster
gproc	ConsistencyPolicy.h	/^  GProcessor* gproc; $/;"	m	class:ConsistencyPolicy
gproc	DepWindow.h	/^  GProcessor* gproc;$/;"	m	class:DepWindow
gproc	FetchEngine.h	/^  GProcessor *gproc;$/;"	m	class:FetchEngine
gproc	LDSTQ.h	/^  GProcessor *gproc;$/;"	m	class:LDSTQ
gproc	MemRequest.h	/^  GProcessor *gproc;$/;"	m	class:MemRequest
gprocCat	CriticalityController.h	/^  std::vector< std::set< GProcessor* > > gprocCat;$/;"	m	class:CriticalityController
gprocCat	CriticalityManager.h	/^  std::vector< std::set< GProcessor* > > gprocCat;$/;"	m	class:CritScheduler
gprocCatMask	CriticalityController.h	/^  std::vector< BIT_VECTOR > gprocCatMask;$/;"	m	class:CriticalityController
gprocCatMask	CriticalityManager.h	/^  std::vector< BIT_VECTOR > gprocCatMask;$/;"	m	class:CritScheduler
graphWin	CriticalityBuilder.h	/^  CGraphCache *graphWin;$/;"	m	class:CriticalityBuilder
graphWin	CriticalityManager.h	/^  CGraphCache *graphWin;$/;"	m	class:CriticalityBase
groupMembers	AdvancedStats.h	/^    GroupMap groupMembers;$/;"	m	class:Stats::Group
groupOrder	AdvancedStats.h	/^    GroupList groupOrder;$/;"	m	class:Stats::Group
hChunkSizeAtOwner	BulkManager.h	/^  static GStatsHist  hChunkSizeAtOwner;$/;"	m	class:PredefinedBulkManager
hIPCdifference	BulkManager.h	/^  static GStatsHist  hIPCdifference;$/;"	m	class:PredefinedBulkManager
hasAffinity	ProcessId.h	/^  bool hasAffinity;$/;"	m	class:ProcessId
hasCanBeRecycled	DInst.h	/^  bool hasCanBeRecycled() const { return canBeRecycled; }$/;"	f	class:DInst
hasDataDepViolation	DInst.h	/^  bool hasDataDepViolation() const {$/;"	f	class:DInst
hasDataDepViolation	MemRequest.h	/^  bool hasDataDepViolation() const {$/;"	f	class:MemRequest
hasDataDepViolation	TaskContext.h	/^  bool hasDataDepViolation() const { return dataDepViolation; }$/;"	f	class:TaskContext
hasDepTableSpace	Cluster.h	/^  bool hasDepTableSpace(const DInst *dinst) const { return window.hasDepTableSpace(dinst); }$/;"	f	class:Cluster
hasDepTableSpace	DepWindow.h	/^  bool hasDepTableSpace(const DInst *dinst) const { return ddis.hasDepTableSpace(dinst); }$/;"	f	class:DepWindow
hasDeps	DInst.h	/^  bool hasDeps()     const { $/;"	f	class:DInst
hasDepsAtRetire	DInst.h	/^  bool hasDepsAtRetire() const { return depsAtRetire; }$/;"	f	class:DInst
hasMisprediction	CavaManager.h	/^    bool hasMisprediction;$/;"	m	class:CavaManager::CkpInfoEntry
hasNewRaces	Epoch.h	/^    bool hasNewRaces(void){$/;"	f	class:tls::Epoch
hasNextEpoch	Checkpoint.cpp	/^    bool hasNextEpoch(ClockValue parClk){$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
hasNextEpoch	Checkpoint.cpp	/^  bool Checkpoint::ExeOrder::hasNextEpoch(ThreadID tid, ClockValue parClk){$/;"	f	class:tls::Checkpoint::ExeOrder
hasOutsReqs	ASVersion.h	/^  bool hasOutsReqs()  const { return (nOutsReqs > 0); }$/;"	f	class:HVersion
hasOutsReqs	HVersion.h	/^  bool hasOutsReqs()  const { return (nOutsReqs > 0); }$/;"	f	class:HVersion
hasOutstandingItems	Pipeline.cpp	/^bool Pipeline::hasOutstandingItems() const$/;"	f	class:Pipeline
hasPending	DInst.h	/^  bool hasPending()  const { return first != 0;  }$/;"	f	class:DInst
hasReachedHeadOfROB	DInst.h	/^  bool hasReachedHeadOfROB()   { return reachedHeadOfROB != 0; }$/;"	f	class:DInst
hasRegisterRecycled	DInst.h	/^  bool hasRegisterRecycled() const { return registerRecycled; }$/;"	f	class:DInst
hasSCDependents	DInst.h	/^  bool hasSCDependents() const {$/;"	f	class:DInst
hasWork	FetchEngine.h	/^  bool hasWork()  { $/;"	f	class:FetchEngine
hasWork	OSSim.h	/^  bool hasWork() const { return cpus.hasWork(); }$/;"	f	class:OSSim
hasWork	Pipeline.h	/^  bool hasWork() const {$/;"	f	class:PipeQueue
hasWork	Processor.cpp	/^bool Processor::hasWork() $/;"	f	class:Processor
hasWork	RunningProcs.h	/^  bool hasWork() const {$/;"	f	class:RunningProcs
hasWork	SMTProcessor.cpp	/^bool SMTProcessor::hasWork() $/;"	f	class:SMTProcessor
head	CriticalityPredictor.h	/^  ProcessId *head;$/;"	m	class:EdgeChain
headROB	CavaManager.cpp	/^void CavaManager::headROB(DInst *dinst)$/;"	f	class:CavaManager
highest	MemObj.h	/^  bool highest;$/;"	m	class:MemObj
histCpleteCkMode	BulkManager.h	/^  static GStatsHist histCpleteCkMode;$/;"	m	class:ParPredefinedBulkManager
histLength	BPred.h	/^  int *histLength;$/;"	m	class:BPOgehl
histNoParCommitReason	BulkManager.h	/^  static GStatsHist histNoParCommitReason;$/;"	m	class:ParPredefinedBulkManager
histNumChunksWaiting	BulkManager.h	/^  static GStatsHist histNumChunksWaiting;$/;"	m	class:BulkManager
histSize	CriticalityPredictor.h	/^  int histSize;$/;"	m	class:SquashOnlyCPred
history	BPred.h	/^  HistoryType history;$/;"	m	class:BP2BcgSkew
history	BPred.h	/^  HistoryType history;$/;"	m	class:BPCRap
history	BPred.h	/^  HistoryType history;$/;"	m	class:BPRap
historyMask	BPred.h	/^  const HistoryType historyMask;$/;"	m	class:BP2level
historyMask	BPred.h	/^  const HistoryType historyMask;$/;"	m	class:BPCRap
historyMask	BPred.h	/^  const HistoryType historyMask;$/;"	m	class:BPHybrid
historyMask	BPred.h	/^  const HistoryType historyMask;$/;"	m	class:BPRap
historySize	BPred.h	/^  const ushort historySize;$/;"	m	class:BP2level
historySize	BPred.h	/^  const ushort historySize;$/;"	m	class:BPCRap
historySize	BPred.h	/^  const ushort historySize;$/;"	m	class:BPHybrid
historySize	BPred.h	/^  const ushort historySize;$/;"	m	class:BPRap
historyTable	BPred.h	/^  HistoryType *historyTable;$/;"	m	class:BP2level
historyTable	BPred.h	/^  HistoryType *historyTable;$/;"	m	class:BPHybrid
hit	MemAnalyzer.h	/^  GStatsCntr hit;$/;"	m	class:GAddressPredictor
hit	VPred.h	/^  GStatsCntr hit;$/;"	m	class:GValuePredictor
hit	VPred.h	/^  GStatsCntr hit;$/;"	m	class:Selector
iAddrV	Epoch.h	/^      Address  iAddrV;$/;"	m	class:tls::Epoch::TraceEvent
iAluEnergy	Resource.h	/^  GStatsEnergy *iAluEnergy;$/;"	m	class:MemResource
iCount	Checkpoint.cpp	/^    size_t     iCount;     \/\/ Number of instructions in this epoch$/;"	m	struct:tls::ExeOrderEntry	file:
id	BPred.h	/^  const int id;$/;"	m	class:BPred
id	BPred.h	/^  const int id;$/;"	m	class:BPredictor
id	CriticalityTC.h	/^  CritID id; \/\/ always unique in dynamic execution (NOT an ordering mechanism)$/;"	m	class:SubtaskContext
id	GProcessor.h	/^  int id;$/;"	m	class:SPredictor
id	GProcessor.h	/^  int id;$/;"	m	class:SqPred
id	HVersion.h	/^  int id;$/;"	m	class:HVersion
id	ValueTable.h	/^    const int id;$/;"	m	class:ValueTable::PredEntry
id2GProcessor	OSSim.cpp	/^GProcessor *OSSim::id2GProcessor(CPU_t cpu)$/;"	f	class:OSSim
id2Group	CriticalityBuilder.h	/^  HASH_MAP<CritID, CPNodeGroup*, ll_hash> id2Group;$/;"	m	class:CriticalityBuilder
id2Group	CriticalityManager.h	/^  HASH_MAP<CritID, CPNodeGroup*, ll_hash> id2Group;   $/;"	m	class:CriticalityBase
idCntr	CriticalityTC.cpp	/^CritID CriticalityTC::idCntr = 1;$/;"	m	class:CriticalityTC	file:
idCntr	CriticalityTC.h	/^  static CritID idCntr;$/;"	m	class:CriticalityTC
idRefCount	CriticalityBuilder.h	/^  HASH_MAP<CritID,int,ll_hash> idRefCount;$/;"	m	class:CriticalityBuilder
idRefCount	CriticalityManager.h	/^  HASH_MAP<CritID,int,ll_hash> idRefCount;$/;"	m	class:CriticalityBase
idSimMarks	OSSim.h	/^  std::map<int,SimulationMark_t> idSimMarks;$/;"	m	class:OSSim
ignoreExit	TaskContext.cpp	/^int TaskContext::ignoreExit()$/;"	f	class:TaskContext
inWindow	CriticalityBuilder.h	/^  HASH_SET<CPNodeGroup*,CPNodeGroup_hash> inWindow;$/;"	m	class:CriticalityBuilder
inWindow	CriticalityManager.h	/^  HASH_SET<CPNodeGroup*,CPNodeGroup_hash> inWindow;$/;"	m	class:CriticalityBase
inc	CriticalityManager.h	/^  void inc(int n) {$/;"	f	class:CritLifetime
inc	CriticalityPredictor.h	/^  void inc() { occCnt++; rollingCnt++; update(); }$/;"	f	class:PredictorCnt
inc	Epoch.h	/^      void inc(void){$/;"	f	struct:tls::Epoch::VersionCount
incInst	MemAnalyzer.h	/^  void incInst() { instCount++; if((instCount % avsPeriod) == 0) avs.dumpReset(); }$/;"	f	class:MemAnalyzer
incInstructions	TaskContext.h	/^  void incInstructions()           { nInstructions++; }$/;"	f	class:TaskContext
incOnlyHit	VPred.h	/^  virtual void incOnlyHit() { onlyHit.inc(); }$/;"	f	class:GValuePredictor
incOutsReqs	ASVersion.h	/^  void incOutsReqs() { nOutsReqs++; }$/;"	f	class:HVersion
incOutsReqs	HVersion.h	/^  void incOutsReqs() { nOutsReqs++; }$/;"	f	class:HVersion
incSpawnConf	CriticalityPredictor.h	/^  int incSpawnConf;$/;"	m	class:EdgeStateX
incSquashConf	CriticalityPredictor.h	/^  int incSquashConf;$/;"	m	class:EdgeStateX
incSuspendedCounter	ProcessId.h	/^  void incSuspendedCounter() { suspendedCounter++; }$/;"	f	class:ProcessId
incTmpComL2HalfMisses	TaskContext.h	/^  void incTmpComL2HalfMisses(void) { tmpComL2HalfMisses++;}$/;"	f	class:TaskContext
incTmpComL2Misses	TaskContext.h	/^  void incTmpComL2Misses(void)     { tmpComL2Misses++;}$/;"	f	class:TaskContext
includeAll	CriticalityController.h	/^  bool includeAll;$/;"	m	class:CriticalityController
incorrect	HVersion.cpp	/^GStatsCntr **HVersion::IDP::incorrect;$/;"	m	class:HVersion::IDP	file:
incorrect	HVersion.h	/^    static GStatsCntr **incorrect;$/;"	m	class:HVersion::IDP
indent	AdvancedStats.cpp	/^  void Group::indent(size_t num){$/;"	f	class:Stats::Group
index	BPred.h	/^  int index;$/;"	m	class:BPRas
index	Epoch.h	/^    size_type index(void) const{$/;"	f	class:tls::VClock
indexCounts	Epoch.h	/^    static IndexCounts indexCounts;$/;"	m	class:tls::VClock
inexactDisamb	BulkManager.cpp	/^bool BulkManager::inexactDisamb;$/;"	m	class:BulkManager	file:
inexactDisamb	BulkManager.h	/^  static bool inexactDisamb;$/;"	m	class:BulkManager
inexactDisamb	TaskContext.cpp	/^bool TaskContext::inexactDisamb = false;$/;"	m	class:TaskContext	file:
inexactDisamb	TaskContext.h	/^  static bool inexactDisamb;$/;"	m	class:TaskContext
infinite	Epoch.cpp	/^  VClock VClock::infinite;$/;"	m	class:tls::VClock	file:
infinite	Epoch.h	/^    static VClock infinite;$/;"	m	class:tls::VClock
infiniteClockValue	Epoch.h	/^  const ClockValue infiniteClockValue=0x7fffffffl;$/;"	v
inflight	CavaManager.h	/^  InflightSet inflight;$/;"	m	class:CavaManager
inflightInsts	LDSTQ.h	/^  DInstSet inflightInsts;$/;"	m	class:LDSTQ
init	CriticalityTC.cpp	/^void CriticalityTC::init(int aSid)$/;"	f	class:CriticalityTC
init	CriticalityTC.h	/^  void init() {$/;"	f	class:SubtaskContext
init	DInst.h	/^  void init(DInst *d) {$/;"	f	class:DInstNext
init	DVFSManager.cpp	/^void DVFSManager::init ()$/;"	f	class:DVFSManager
init	EnergyMgr.cpp	/^void EnergyMgr::init()$/;"	f	class:EnergyMgr
init	EnergyMgr.h	/^  static void init(){$/;"	f	class:EnergyMgr
initBoot	OSSim.cpp	/^void OSSim::initBoot()$/;"	f	class:OSSim
initPermutation	BulkManager.cpp	/^void BulkManager::initPermutation()$/;"	f	class:BulkManager
initial	Epoch.cpp	/^  VClock VClock::initial;$/;"	m	class:tls::VClock	file:
initial	Epoch.h	/^    static VClock initial;$/;"	m	class:tls::VClock
initialClockValue	Epoch.h	/^  const ClockValue initialClockValue =0x00000000l;$/;"	v
initialContext	Checkpoint.cpp	/^    ThreadContext *initialContext;$/;"	m	class:tls::Checkpoint::ExeOrder::ThreadExeOrder	file:
initialEpoch	Epoch.cpp	/^  Epoch *Epoch::initialEpoch(ThreadID tid){$/;"	f	class:tls::Epoch
initialize	BPred.h	/^    void initialize(CacheGeneric<PathEntry, HistoryType>* c) { $/;"	f	class:BPCRap::PathEntry
initialize	CPBuilder.h	/^    void initialize() {$/;"	f	class:TokenContainer
initialize	HVersion.h	/^      void initialize(CacheGeneric<PredEntry, PredEntryTag> *c) {$/;"	f	class:HVersion::IDP::PredEntry
initializeData	MemBuffer.cpp	/^void MemBufferEntry::initializeData(MemOpsType::iterator mit)$/;"	f	class:MemBufferEntry
initializeData	MemBuffer.h	/^  void initializeData(const MemBufferEntry *srcEntry) {$/;"	f	class:MemBufferEntry
insert	LDSTQ.cpp	/^void LDSTQ::insert(DInst *dinst)$/;"	f	class:LDSTQ
insert	RiskLoadProf.cpp	/^void RiskLoadProf::insert(ulong ldInst)$/;"	f	class:RiskLoadProf
insertKilledEdge	CriticalityBuilder.cpp	/^void CriticalityBuilder::insertKilledEdge(CPNodeGroup *earlier,$/;"	f	class:CriticalityBuilder
insertKilledEdge	CriticalityManager.cpp	/^void CriticalityBase::insertKilledEdge(CPNodeGroup *earlier,$/;"	f	class:CriticalityBase
insertMember	AdvancedStats.cpp	/^  void Group::insertMember(Group *newMember){$/;"	f	class:Stats::Group
insertSquashEdge	CriticalityBuilder.cpp	/^CPEdge* CriticalityBuilder::insertSquashEdge(CPVertex *st, CritID from,$/;"	f	class:CriticalityBuilder
insertSquashEdge	CriticalityManager.cpp	/^void CriticalityBase::insertSquashEdge(CPVertex *st, CritID from,$/;"	f	class:CriticalityBase
inst	BPred.h	/^    InstID inst;$/;"	m	class:BPBTB::BTBState
inst	DInst.h	/^  const Instruction *inst;$/;"	m	class:DInst
instAddr	MemBuffer.h	/^  ulong  instAddr; \/\/ the ST\/LD instruction -- first$/;"	m	class:MemBufferEntry
instCount	MemAnalyzer.h	/^  long long instCount;$/;"	m	class:MemAnalyzer
instMap	LDSTQ.h	/^  AddrDInstQMap instMap;$/;"	m	class:LDSTQ
instPos	Profile.h	/^    long long instPos; \/\/spawn position$/;"	m	class:Profile::SpawnInfo
instPos	Profile.h	/^    long long instPos;$/;"	m	class:Profile::WriteInfo
instQueue	Pipeline.h	/^  FastQueue<IBucket *> instQueue;$/;"	m	class:PipeQueue
instrOffset	Epoch.h	/^      size_t   instrOffset;$/;"	m	class:tls::Epoch::TraceEvent
instrSource	GMemorySystem.h	/^  MemObj *instrSource;$/;"	m	class:GMemorySystem
insts	CriticalityTC.h	/^  long long insts;$/;"	m	class:SubtaskContext
instsFinished	CavaManager.h	/^    bool instsFinished;$/;"	m	class:CavaManager::CkpInfoEntry
intlMemoryObjContainer	GMemorySystem.h	/^  StrToMemoryObjMapper intlMemoryObjContainer;$/;"	m	class:MemoryObjContainer
invSpawnTable	CriticalityPredictor.h	/^  HASH_MAP<ProcessId*,ProcessId*,hash_pointer> invSpawnTable;$/;"	m	class:CriticalityPredictor
invSquashTable	CriticalityPredictor.h	/^  HASH_MAP<ProcessId*,ProcessId*,hash_pointer> invSquashTable;$/;"	m	class:CriticalityPredictor
invUpperLevel	MemObj.h	/^  void invUpperLevel(PAddr addr, ushort size, MemObj *oc) {$/;"	f	class:MemObj
invalidIndex	Epoch.h	/^    static const size_type invalidIndex=static_cast<size_type>(-1);$/;"	m	class:tls::VClock
invalidMemAccess	TaskContext.cpp	/^void TaskContext::invalidMemAccess(int rID, DataDepViolationAt rAt,$/;"	f	class:TaskContext
invalidate	CPBuilder.h	/^      void invalidate() { tc = NULL; uniqueId = ~0; timer = -1; }$/;"	f	struct:CPBuilder::Token
invalidate	HVersion.h	/^      void invalidate() { tag = 0; }$/;"	f	class:HVersion::IDP::PredEntry
invalidate	MemObj.cpp	/^void DummyMemObj::invalidate(PAddr addr, ushort size, MemObj *oc)$/;"	f	class:DummyMemObj
invertList	CriticalityPredictor.cpp	/^void CriticalityPredictor::invertList(std::vector<ProcessId*> &procVec,$/;"	f	class:CriticalityPredictor
ipcTracer	GProcessor.h	/^  IPCTracer *ipcTracer;$/;"	m	class:GProcessor
isAccessed	Epoch.h	/^      bool isAccessed(void){$/;"	f	class:tls::Epoch::BufferBlock
isActiveHead	CriticalityPredictor.h	/^  bool isActiveHead(ProcessId *p) {$/;"	f	class:EdgeCPred
isAfterSquash	CriticalityBuilder.cpp	/^int CriticalityBuilder::isAfterSquash( CPVertex *v )$/;"	f	class:CriticalityBuilder
isAfterSquash	CriticalityManager.cpp	/^int CriticalityBase::isAfterSquash( CPVertex *v )$/;"	f	class:CriticalityBase
isAtomic	ASVersion.h	/^  bool isAtomic() const { return base; }$/;"	f	class:HVersion
isBad	ValueTable.h	/^    bool isBad() const {$/;"	f	class:ValueTable::PredEntry
isBlockRetire	GProcessor.h	/^  bool isBlockRetire() const {return blockRetire;} $/;"	f	class:GProcessor
isCache	MemObj.h	/^  virtual const bool isCache() const { return false; }$/;"	f	class:MemObj
isChainHead	CriticalityPredictor.h	/^  bool isChainHead(ProcessId *p) {$/;"	f	class:EdgeCPred
isCheckpointable	TaskContext.h	/^  bool isCheckpointable() const    { return checkpointable; }$/;"	f	class:TaskContext
isCheckpointed	DInst.h	/^  bool isCheckpointed() const     { return checkpointed; }$/;"	f	class:DInst
isCheckpointed	HVersion.h	/^  bool isCheckpointed() { return checkpointed; }$/;"	f	class:HVersionDomain
isCheckpointed	TaskContext.h	/^  bool isCheckpointed()   const    { return checkpointed; }$/;"	f	class:TaskContext
isClone	HVersion.h	/^  bool isClone() const { return rat;}$/;"	f	class:HVersion
isClone	TaskContext.h	/^  bool isClone()        const {return clone;}$/;"	f	class:TaskContext
isCloneAtSpawn	RatsManager.h	/^  bool isCloneAtSpawn(void) const {return cloneAtSpawn;}$/;"	f	class:RatsManager
isCloneMostSpec	RatsManager.h	/^  bool isCloneMostSpec(void) const {return cloneMostSpec;}$/;"	f	class:RatsManager
isCloned	TaskContext.h	/^  bool isCloned()       const {return cloned;}$/;"	f	class:TaskContext
isConflict	BulkManager.cpp	/^bool BulkManager::isConflict(Chunk *cc, Chunk *oc)$/;"	f	class:BulkManager
isConsumer	Epoch.h	/^      bool isConsumer;$/;"	m	class:tls::Epoch::BufferBlock
isCritical	CriticalityController.cpp	/^bool CriticalityController::isCritical(Pid_t pid)$/;"	f	class:CriticalityController
isCritical	CriticalityManager.cpp	/^bool CritScheduler::isCritical(Pid_t pid)$/;"	f	class:CritScheduler
isCriticalCPU	CriticalityController.h	/^  bool isCriticalCPU(CPU_t cpu) {$/;"	f	class:CriticalityController
isCriticalCPU	CriticalityManager.h	/^  bool isCriticalCPU(CPU_t cpu) {$/;"	f	class:CritScheduler
isCriticalCPU	CriticalityManager.h	/^  bool isCriticalCPU(CPU_t cpu) {$/;"	f	class:CriticalityManager
isDataReq	MemRequest.h	/^  bool isDataReq() const { return dataReq; }$/;"	f	class:MemRequest
isDeadInst	DInst.h	/^  bool isDeadInst() { return deadInst; }$/;"	f	class:DInst
isDeadStore	DInst.h	/^  bool isDeadStore() const { return deadStore; }$/;"	f	class:DInst
isDualMode	RatsManager.h	/^  bool isDualMode(void) const {return dualMode;}$/;"	f	class:RatsManager
isEarlyRecycled	DInst.h	/^  bool isEarlyRecycled() const { return earlyRecycled; }$/;"	f	class:DInst
isEarlyRecycled	DInst.h	/^  bool isEarlyRecycled() const { return false; }$/;"	f	class:DInst
isExecuted	DInst.h	/^  bool isExecuted() const { return executed; }$/;"	f	class:DInst
isExecuted	ProcessId.h	/^  bool isExecuted() const { return executed;  }$/;"	f	class:ProcessId
isFake	DInst.h	/^  bool isFake() const  { return fake; }$/;"	f	class:DInst
isFake	DInst.h	/^  bool isFake() const  { return false; }$/;"	f	class:DInst
isFinishCritical	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::isFinishCritical( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
isFinishPredCritical	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::isFinishPredCritical( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
isFinished	ASVersion.h	/^  bool isFinished() const { return false; }$/;"	f	class:HVersion
isFinished	CriticalityPredictor.cpp	/^bool EdgeCPred::isFinished(ProcessId *p) {$/;"	f	class:EdgeCPred
isFinished	HVersion.h	/^  bool isFinished() const { $/;"	f	class:HVersion
isFlowSource	Epoch.h	/^      bool isFlowSource(void) const{$/;"	f	class:tls::Epoch::BufferBlock
isHasAffinityCPU	ProcessId.h	/^  bool isHasAffinityCPU(CPU_t i) { return (!useAffinity || (useAffinity && hasAffinity && cpuAllowed[i] && cpuAffinity[i])); } $/;"	f	class:ProcessId
isHighestLevel	MemObj.h	/^  bool isHighestLevel() const { return highest; }$/;"	f	class:MemObj
isIssued	DInst.h	/^  bool isIssued() const { return issued; }$/;"	f	class:DInst
isKamLoadAware	RatsManager.h	/^  bool isKamLoadAware(void) const {return kamLoadAware;}$/;"	f	class:RatsManager
isKilled	ASVersion.h	/^  bool isKilled() const { return killed; }$/;"	f	class:HVersion
isKilled	GLVID.cpp	/^bool GLVIDDummy::isKilled() const$/;"	f	class:GLVIDDummy
isKilled	HVersion.h	/^  bool isKilled() const { return killed; }$/;"	f	class:HVersion
isLoadForwarded	DInst.h	/^  bool isLoadForwarded() const { return loadForwarded; }$/;"	f	class:DInst
isLoadSent	DInst.h	/^  bool isLoadSent() const { return loadSent; }$/;"	f	class:DInst
isLocked	HVersion.h	/^      bool isLocked () const {$/;"	f	class:HVersion::IDP::PredEntry
isLowConfidence	DInst.h	/^  bool isLowConfidence() const   { return lowConfidence; }$/;"	f	class:DInst
isMemoryIssued	DInst.h	/^  bool isMemoryIssued() const { return memoryIssued; }$/;"	f	class:DInst
isMigrable	ProcessId.h	/^  bool isMigrable() const  { return migrable; }$/;"	f	class:ProcessId
isNewest	ASVersion.h	/^  bool isNewest() const { return base; }$/;"	f	class:HVersion
isNewest	HVersion.h	/^  bool isNewest() const { return next == 0; }$/;"	f	class:HVersion
isOOtask	TaskContext.h	/^  bool isOOtask() const { return ooTask; }$/;"	f	class:TaskContext
isOldest	ASVersion.h	/^  bool isOldest() const { return ! base; }$/;"	f	class:HVersion
isOldest	HVersion.h	/^  bool isOldest() const { return prev == 0; }$/;"	f	class:HVersion
isOldestTaskContext	ASVersion.h	/^  bool isOldestTaskContext() const { return ! base; }$/;"	f	class:HVersion
isOldestTaskContext	HVersion.h	/^  bool isOldestTaskContext() const { return vDomain->oldestTC == this; }$/;"	f	class:HVersion
isOnly	HVersion.h	/^  bool isOnly() const { GI(isOldest() && isNewest(), isSafe()); return (isOldest() && isNewest()); }$/;"	f	class:HVersion
isParentCritical	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::isParentCritical( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
isParentCritical	CriticalityManager.cpp	/^bool CriticalityManager::isParentCritical( CPVertex *v )$/;"	f	class:CriticalityManager
isPinned	ProcessId.h	/^  bool isPinned() const    { return pinned;   }$/;"	f	class:ProcessId
isPredLoad	DInst.h	/^  bool isPredLoad()      { return predLoad; }$/;"	f	class:DInst
isPredicted	DInst.h	/^  bool isPredicted() const   { return predicted; }$/;"	f	class:DInst
isPrefetch	MemRequest.h	/^  bool isPrefetch() const {return prefetch; }$/;"	f	class:MemRequest
isPresched	DInst.h	/^  bool isPresched() const { return presched; }$/;"	f	class:DInst
isProducer	Epoch.h	/^      bool isProducer;$/;"	m	class:tls::Epoch::BufferBlock
isRat	ASVersion.h	/^  bool isRat() const { return rat;}$/;"	f	class:HVersion
isRat	HVersion.h	/^  bool isRat() const { return rat;}$/;"	f	class:HVersion
isRatable	TaskContext.h	/^  bool isRatable() const { return ratable;}$/;"	f	class:TaskContext
isRdOnly	Epoch.h	/^      bool isRdOnly(void) const{$/;"	f	class:tls::Epoch::BlockVersions
isResolved	DInst.h	/^  bool isResolved() const { return resolved; }$/;"	f	class:DInst
isSCDependent	DInst.h	/^  bool isSCDependent() const {$/;"	f	class:DInst
isSafe	ASVersion.h	/^  bool isSafe() const { return !base; }$/;"	f	class:HVersion
isSafe	HVersion.h	/^  bool isSafe() const { $/;"	f	class:HVersion
isSafeId	ProcessId.cpp	/^bool ProcessId::isSafeId(Pid_t pid)$/;"	f	class:ProcessId
isSameDomain	HVersion.h	/^  bool isSameDomain(const HVersion &v) const {$/;"	f	class:HVersion
isSelectedCPU	ProcessId.h	/^  bool isSelectedCPU(CPU_t i) { return ((!selective) || cpuAllowed[i]); }$/;"	f	class:ProcessId
isSelective	ProcessId.h	/^  bool isSelective() { return selective && migrable; }$/;"	f	class:ProcessId
isSelectiveKill	RatsManager.h	/^  bool isSelectiveKill(void) const {return selectiveKill;}$/;"	f	class:RatsManager
isSeqRat	RatsManager.h	/^  bool isSeqRat(void) const {return seqRAT;}$/;"	f	class:RatsManager
isSpawnCritical	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::isSpawnCritical( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
isSpawnCritical	CriticalityManager.cpp	/^bool CriticalityManager::isSpawnCritical( CPVertex *v )$/;"	f	class:CriticalityManager
isSpawnLikelySquashed	CriticalityPredictor.cpp	/^bool EdgeCPred::isSpawnLikelySquashed(ProcessId *from, ProcessId *to)$/;"	f	class:EdgeCPred
isSpawnParent	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::isSpawnParent( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
isSpawnPredCritical	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::isSpawnPredCritical( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
isSquashLikely	CriticalityPredictor.cpp	/^bool EdgeCPred::isSquashLikely(ProcessId *from, ProcessId *to, ProcessId **conflict )$/;"	f	class:EdgeCPred
isSrc1Ready	DInst.h	/^  bool isSrc1Ready() const { return !pend[0].isUsed; }$/;"	f	class:DInst
isSrc2Ready	DInst.h	/^  bool isSrc2Ready() const { return !pend[1].isUsed; }$/;"	f	class:DInst
isStackData	DInst.h	/^  bool isStackData() const {return stackData;}$/;"	f	class:DInst
isStale	Epoch.h	/^      bool isStale(void) const{$/;"	f	class:tls::Epoch::BufferBlock
isStall	GProcessor.h	/^  virtual bool isStall() const { return (stallUntil >= globalClock); }$/;"	f	class:GProcessor
isStoreGloballyPerformed	DInst.h	/^  bool isStoreGloballyPerformed() const { return storeGloballyPerformed; }$/;"	f	class:DInst
isStoreRetired	DInst.h	/^  bool isStoreRetired() const { return storeRetired; }$/;"	f	class:DInst
isStoreSent	DInst.h	/^  bool isStoreSent() const { return storeSent; }$/;"	f	class:DInst
isSyncCritical	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::isSyncCritical( CPVertex *v )$/;"	f	class:CriticalityBuilderIface
isSyncCritical	CriticalityManager.cpp	/^bool CriticalityManager::isSyncCritical( CPVertex *v )$/;"	f	class:CriticalityManager
isTaskLastScheduled	CriticalityBuilder.h	/^  bool isTaskLastScheduled(CPU_t i, CritID id) {$/;"	f	class:CriticalityBuilder
isTaskLastScheduled	CriticalityManager.h	/^  bool isTaskLastScheduled(CPU_t i, CritID id) {$/;"	f	class:CriticalityBase
isTaskScheduled	CriticalityBuilder.cpp	/^bool CriticalityBuilder::isTaskScheduled(CPU_t i, CritID id)$/;"	f	class:CriticalityBuilder
isTaskScheduled	CriticalityManager.cpp	/^bool CriticalityBase::isTaskScheduled(CPU_t i, CritID id)$/;"	f	class:CriticalityBase
isTopLevel	MemRequest.h	/^  bool isTopLevel() const { return memStack.empty();  }$/;"	f	class:MemRequest
isUpperCache	MemObj.h	/^  bool isUpperCache(MemObj *cache) {$/;"	f	class:MemObj
isUseMSHR	RatsManager.h	/^  bool isUseMSHR(void) const {return useMSHR;}$/;"	f	class:RatsManager
isUsed	DInst.h	/^  bool       isUsed; \/\/ true while non-satisfied RAW dependence$/;"	m	class:DInstNext
isUsingSimPoints	OSSim.h	/^  bool isUsingSimPoints() {$/;"	f	class:OSSim
isValid	CPBuilder.h	/^      bool isValid() { return (timer >= 0) && (uniqueId != (ulonglong)(~0)); }$/;"	f	struct:CPBuilder::Token
isValid	CriticalityBuilder.h	/^  bool isValid() { return true; }$/;"	f	class:GraphState
isValid	CriticalityPredictor.h	/^  bool isValid() { return sid!=-1; }$/;"	f	class:SpawnState
isValid	CriticalityPredictor.h	/^  bool isValid() { return true; }$/;"	f	class:EdgeState
isValid	CriticalityPredictor.h	/^  bool isValid() { return true; }$/;"	f	class:SquashState
isValid	HVersion.h	/^      bool isValid() const { return tag; }$/;"	f	class:HVersion::IDP::PredEntry
isValueHit	VPred.cpp	/^bool BHLVPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:BHLVPred
isValueHit	VPred.cpp	/^bool ELVPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:ELVPred
isValueHit	VPred.cpp	/^bool FCMPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:FCMPred
isValueHit	VPred.cpp	/^bool FWPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:FWPred
isValueHit	VPred.cpp	/^bool GlobalLVPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:GlobalLVPred
isValueHit	VPred.cpp	/^bool LVPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:LVPred
isValueHit	VPred.cpp	/^bool SPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:SPred
isValueHit	VPred.cpp	/^bool ZeroPred::isValueHit(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:ZeroPred
isValuePredHit	DInst.h	/^  bool isValuePredHit() const   { return valuePredHit; }$/;"	f	class:DInst
isWWLineConflict	TaskContext.cpp	/^bool TaskContext::isWWLineConflict(AddressSet &w1, AddressSet &w2)$/;"	f	class:TaskContext
isWaiting	ProcessId.h	/^  bool isWaiting() const  { return waiting;   }$/;"	f	class:ProcessId
isWrite	MemRequest.h	/^  bool isWrite() const { return wToRLevel != -1 || memOp == MemWrite; }$/;"	f	class:MemRequest
isWritten	Epoch.h	/^      bool isWritten(void){$/;"	f	class:tls::Epoch::BufferBlock
issue	GProcessor.cpp	/^int GProcessor::issue(PipeQueue &pipeQ)$/;"	f	class:GProcessor
issueFromReplayQ	GProcessor.cpp	/^int GProcessor::issueFromReplayQ()$/;"	f	class:GProcessor
issueTime	DInst.h	/^  Time_t issueTime;$/;"	m	class:DInst
issueWrongPath	FetchEngine.h	/^  bool issueWrongPath;$/;"	m	class:FetchEngine
issued	DInst.h	/^  bool issued;$/;"	m	class:DInst
issuer	MemRequest.h	/^  MemObj *issuer;$/;"	m	class:MemRequest
iter	Epoch.h	/^      enum IterEnum {Initial, PartReplay, FullReplay, Merging} iter : 2;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::IterEnum
itlb	GMemoryOS.h	/^  DTLBCache *itlb;$/;"	m	class:DummyMemoryOS
justDestroy	MemBuffer.cpp	/^void MemBuffer::justDestroy()$/;"	f	class:MemBuffer
justDestroy	MemBuffer.cpp	/^void MemBufferEntry::justDestroy()$/;"	f	class:MemBufferEntry
justTest	OSSim.h	/^  bool justTest;$/;"	m	class:OSSim
kamLoadAware	RatsManager.h	/^  bool kamLoadAware;$/;"	m	class:RatsManager
keepToken	BulkManager.h	/^  bool keepToken;$/;"	m	class:PredefinedBulkManager
key	BPred.h	/^    HistoryType key;$/;"	m	class:BPRap::PathHistoryEntry
key2pos	BPred.h	/^  Key2PosType key2pos;$/;"	m	class:BPRap
kill	CriticalityManager.h	/^  GStatsCntr kill;$/;"	m	class:PredData
kill	ProcessId.h	/^void kill(bool inv) {$/;"	f	class:ProcessId
kill	TaskHandler.cpp	/^void TaskHandler::kill(const HVersion *ver, bool inv)$/;"	f	class:TaskHandler
killPSafe	CriticalityManager.h	/^  GStatsCntr killPSafe;$/;"	m	class:PredData
killPri	CriticalityManager.h	/^  GStatsAvg  killPri;$/;"	m	class:PredData
killRat	TaskContext.cpp	/^GStatsCntr * TaskContext::killRat=0;$/;"	m	class:TaskContext	file:
killRat	TaskContext.h	/^  static GStatsCntr * killRat;$/;"	m	class:TaskContext
killSilently	DInst.cpp	/^void DInst::killSilently()$/;"	f	class:DInst
killTls	TaskContext.cpp	/^GStatsCntr * TaskContext::killTls=0;$/;"	m	class:TaskContext	file:
killTls	TaskContext.h	/^  static GStatsCntr * killTls;$/;"	m	class:TaskContext
killed	ASVersion.h	/^  bool killed;$/;"	m	class:HVersion
killed	HVersion.h	/^  bool killed;$/;"	m	class:HVersion
killedGroups	CriticalityBuilder.h	/^  HASH_SET<CritID, ll_hash> killedGroups; \/\/to build resource edges$/;"	m	class:CriticalityBuilder
killedGroups	CriticalityManager.h	/^  HASH_SET<CritID, ll_hash> killedGroups; \/\/to build resource edges$/;"	m	class:CriticalityBase
killedPri	CriticalityManager.h	/^  GStatsHist killedPri;$/;"	m	class:CriticalityManager
killedTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::killedTask(CriticalityTC &tc)$/;"	f	class:CriticalityBuilder
killedTask	CriticalityManager.cpp	/^void CriticalityBase::killedTask(CriticalityTC &tc)$/;"	f	class:CriticalityBase
l1Cache	CavaManager.h	/^  Cache *l1Cache;$/;"	m	class:CavaManager
l1Retry	DInst.h	/^  bool         l1Retry;$/;"	m	class:DInst
l1Size	BPred.h	/^  const ushort l1Size;$/;"	m	class:BP2level
l1Size	BPred.h	/^  const ushort l1Size;$/;"	m	class:BPHybrid
l1SizeMask	BPred.h	/^  const ulong  l1SizeMask;$/;"	m	class:BP2level
l1SizeMask	BPred.h	/^  const ulong  l1SizeMask;$/;"	m	class:BPHybrid
l2Cache	CavaManager.h	/^  Cache *l2Cache;$/;"	m	class:CavaManager
l2Cache	RatsManager.h	/^  Cache *l2Cache;$/;"	m	class:RatsManager
l2MissDetection	MemRequest.h	/^  Time_t l2MissDetection;$/;"	m	class:MemRequest
l2MissOccThrd	Profile.h	/^  float l2MissOccThrd;$/;"	m	class:Profile
lMem2Timeline	TimelineManager.cpp	/^std::vector<Timeline*> TimelineManager::lMem2Timeline;$/;"	m	class:TimelineManager	file:
lMem2Timeline	TimelineManager.h	/^  static std::vector<Timeline *> lMem2Timeline;$/;"	m	class:TimelineManager
lSpec	CriticalityPredictor.h	/^  ProcessId *lSpec;$/;"	m	class:OracularCPred
last	DInst.h	/^  DInstNext *last;  \/\/ instrs that depend on this instr$/;"	m	class:DInst
lastCommitEpoch	Epoch.h	/^    Epoch *lastCommitEpoch;$/;"	m	class:tls::Thread
lastCommitOnResource	CriticalityBuilder.h	/^  std::vector<CritID> lastCommitOnResource; \/\/ never a killed task$/;"	m	class:CriticalityBuilder
lastCommitOnResource	CriticalityManager.h	/^  std::vector<CritID> lastCommitOnResource; \/\/ never a killed task$/;"	m	class:CriticalityBase
lastFrontierCandidate	Epoch.h	/^    Epoch *lastFrontierCandidate;$/;"	m	class:tls::Thread
lastGroup	CriticalityBuilder.h	/^  CPNodeGroup *lastGroup;$/;"	m	class:CriticalityBuilder
lastGroup	CriticalityManager.h	/^  CPNodeGroup *lastGroup;$/;"	m	class:CriticalityBase
lastId	CriticalityBuilder.h	/^  CritID lastId;$/;"	m	class:CriticalityBuilder
lastId	CriticalityManager.h	/^  CritID lastId;$/;"	m	class:CriticalityBase
lastInstrOffset	Epoch.h	/^      size_t lastInstrOffset;$/;"	m	class:tls::Epoch::TraceAccessEvent
lastInsts	MultiManager.h	/^  long long lastInsts;$/;"	m	class:MultiPathManager
lastLoadDest	CavaManager.h	/^  RegType lastLoadDest;$/;"	m	class:CavaManager
lastLowConf	MultiManager.h	/^  long long lastLowConf;$/;"	m	class:MultiPathManager
lastMiss	MultiManager.h	/^  long long lastMiss;$/;"	m	class:MultiPathManager
lastMissesQ	MemAnalyzer.h	/^  AddrQ lastMissesQ;$/;"	m	class:MarkovAP
lastMissesQ	MemAnalyzer.h	/^  std::deque<PAddr> lastMissesQ;$/;"	m	class:StrideAP
lastRecInst	Profile.h	/^  long long lastRecInst;$/;"	m	class:Profile
lastTid	BPred.h	/^  int lastTid;$/;"	m	class:BPRas
lastTimeCommit	BulkManager.h	/^  time_t lastTimeCommit;$/;"	m	class:PredefinedBulkManager
lastTimeOwner	BulkManager.h	/^  time_t lastTimeOwner;$/;"	m	class:PredefinedBulkManager
lastValue	VPred.h	/^  unsigned lastValue;$/;"	m	class:GlobalLVPred
lastsid	CriticalityPredictor.cpp	/^static int lastsid=-66;$/;"	v	file:
lastver	ASVersion.cpp	/^HVersion::VType HVersion::lastver = 0;$/;"	m	class:HVersion	file:
lastver	ASVersion.h	/^  static VType lastver;$/;"	m	class:HVersion
lat	Resource.h	/^  const TimeDelta_t lat;$/;"	m	class:FUBranch
lat	Resource.h	/^  const TimeDelta_t lat;$/;"	m	class:FUGeneric
lat	Resource.h	/^  const TimeDelta_t lat;$/;"	m	class:FULoad
lat	Resource.h	/^  const TimeDelta_t lat;$/;"	m	class:FUStore
latReadHit	Profile.h	/^  int   latReadHit;$/;"	m	class:Profile
latReadMiss	Profile.h	/^  int   latReadMiss;$/;"	m	class:Profile
latWriteHit	Profile.h	/^  int   latWriteHit;$/;"	m	class:Profile
latWriteMiss	Profile.h	/^  int   latWriteMiss;$/;"	m	class:Profile
launch	MemRequest.cpp	/^void StaticCBMemRequest::launch(TimeDelta_t lat, MemObj *m$/;"	f	class:StaticCBMemRequest
ldldViolations	LDSTQ.h	/^  GStatsCntr ldldViolations;$/;"	m	class:LDSTQ
ldqCheckEnergy	Resource.h	/^  GStatsEnergy *ldqCheckEnergy; \/\/ Check for data dependence$/;"	m	class:MemResource
ldqNotUsed	Resource.h	/^  GStatsAvg   ldqNotUsed;$/;"	m	class:FULoad
ldqRdWrEnergy	Resource.h	/^  GStatsEnergy *ldqRdWrEnergy;  \/\/ Read-write operations (insert, exec, retire)$/;"	m	class:MemResource
likelySquash	CriticalityController.h	/^  HASH_MAP<ProcessId*,bool,pointer_hash> likelySquash;$/;"	m	class:CriticalityController
likelySquash	CriticalityManager.h	/^  HASH_MAP<ProcessId*,bool,pointer_hash> likelySquash;$/;"	m	class:CritScheduler
likelySquash	CriticalityPredictor.h	/^  HASH_SET<ProcessId*,hash_pointer> likelySquash;$/;"	m	class:IdealPredInfo
lineMask	MemAnalyzer.h	/^  const unsigned lineMask;$/;"	m	class:GAddressPredictor
lineSize	MemAnalyzer.h	/^  const int lineSize;$/;"	m	class:GAddressPredictor
loadForwarded	DInst.h	/^  bool loadForwarded;$/;"	m	class:DInst
loadSent	DInst.h	/^  bool loadSent;$/;"	m	class:DInst
loadStall	MemRequest.h	/^  static GStatsHist loadStall;$/;"	m	class:DMemRequest
loadStallCache	MemRequest.h	/^  static GStatsHist loadStallCache;$/;"	m	class:DMemRequest
loadStallCoherence	MemRequest.h	/^  static GStatsHist loadStallCoherence;$/;"	m	class:DMemRequest
loadStallMemory	MemRequest.h	/^  static GStatsHist loadStallMemory;$/;"	m	class:DMemRequest
loadThreadContext	FetchEngine.h	/^  void loadThreadContext(void){$/;"	f	class:FetchEngine
loadThreadContext	Processor.cpp	/^void Processor::loadThreadContext(Pid_t pid)$/;"	f	class:Processor
loadThreadContext	SMTProcessor.cpp	/^void SMTProcessor::loadThreadContext(Pid_t pid)$/;"	f	class:SMTProcessor
loadUseDist	CavaManager.h	/^  int loadUseDist;$/;"	m	class:CavaManager
localKill	TaskContext.cpp	/^void TaskContext::localKill(bool inv)$/;"	f	class:TaskContext
localMemoryObjContainer	GMemorySystem.h	/^  MemoryObjContainer *localMemoryObjContainer;$/;"	m	class:GMemorySystem
localRestart	CriticalityTC.cpp	/^void CriticalityTC::localRestart()$/;"	f	class:CriticalityTC
localRestart	TaskContext.cpp	/^void TaskContext::localRestart()$/;"	f	class:TaskContext
localTable	BPred.h	/^  SCTable localTable;$/;"	m	class:BPHybrid
localWriteAddrs	Profile.cpp	/^Profile::AddrSet       Profile::localWriteAddrs;$/;"	m	class:Profile	file:
localWriteAddrs	Profile.h	/^  static AddrSet localWriteAddrs;$/;"	m	class:Profile
localWrites	Profile.cpp	/^Profile::WriteList     Profile::localWrites;$/;"	m	class:Profile	file:
localWrites	Profile.h	/^  static WriteList localWrites;$/;"	m	class:Profile
log	BulkManager.h	/^  static void log(BulkManager* bm){$/;"	f	class:BulkLogger
log2	GProcessor.cpp	/^int SqPred::log2(int val){$/;"	f	class:SqPred
log2LineSize	MemAnalyzer.h	/^  const int log2LineSize;$/;"	m	class:GAddressPredictor
logBlockSize	Checkpoint.h	/^      logBlockSize=5,$/;"	e	enum:tls::Checkpoint::MemoryBlockConstantsEnum
logBlockSize	Epoch.h	/^      logBlockSize=5,$/;"	e	enum:tls::Epoch::BufferBlockConstantsEnum
logChunkSize	Epoch.h	/^      logChunkSize=3,$/;"	e	enum:tls::Epoch::BufferBlockConstantsEnum
logChunkSize	MemBuffer.h	/^  logChunkSize=3,              \/\/ == log2(sizeof(long long))$/;"	e	enum:__anon4
logSize	GProcessor.h	/^  int logSize;$/;"	m	class:STagged
logentry_t	BulkManager.h	/^  typedef unsigned long long logentry_t;$/;"	t	class:BasicLogger
logfile	BulkManager.cpp	/^FILE* BulkLogger::logfile=0;$/;"	m	class:BulkLogger	file:
logfile	BulkManager.h	/^  static FILE *logfile;$/;"	m	class:BulkLogger
logger	BulkManager.cpp	/^BulkLogger* BulkLogger::logger=0;$/;"	m	class:BulkLogger	file:
logger	BulkManager.h	/^  static BulkLogger* logger;$/;"	m	class:BulkLogger
logpred	BPred.h	/^  int logpred;$/;"	m	class:BPOgehl
logthis	BulkManager.cpp	/^void BasicLogger::logthis(BulkManager* bm)$/;"	f	class:BasicLogger
logthis	BulkManager.h	/^  void logthis(BulkManager* bm){};$/;"	f	class:EmptyLogger
lookupThreadExeOrder	Checkpoint.cpp	/^  Checkpoint::ExeOrder::ThreadExeOrder *Checkpoint::ExeOrder::lookupThreadExeOrder(ThreadID tid){$/;"	f	class:tls::Checkpoint::ExeOrder
lowConfDistance	MultiManager.h	/^  GStatsAvg lowConfDistance;$/;"	m	class:MultiPathManager
lowConfidence	DInst.h	/^  bool         lowConfidence;$/;"	m	class:DInst
lowerLevel	MemObj.h	/^  LevelType lowerLevel;$/;"	m	class:MemObj
lsq	GProcessor.h	/^  LDSTQ lsq;$/;"	m	class:GProcessor
ltptr	TaskContext.h	/^struct ltptr$/;"	s
lvid	DInst.h	/^  GLVID      *lvid;$/;"	m	class:DInst
lvidVersion	DInst.h	/^  HVersion   *lvidVersion;$/;"	m	class:DInst
mPool	MemBuffer.h	/^  static pool<MemBuffer, true> mPool;$/;"	m	class:MemBuffer
macache	MemAnalyzer.h	/^  MACacheType *macache;$/;"	m	class:MemAnalyzer
main	main.cpp	/^int main(int argc, char **argv, char **envp)$/;"	f
makeNonRunnable	RunningProcs.cpp	/^void RunningProcs::makeNonRunnable(ProcessId *proc)$/;"	f	class:RunningProcs
makeROBDead	GProcessor.cpp	/^void GProcessor::makeROBDead()$/;"	f	class:GProcessor
makeRunnable	RunningProcs.cpp	/^void RunningProcs::makeRunnable(ProcessId *proc)$/;"	f	class:RunningProcs
makeSCDependentOn	DInst.h	/^  void makeSCDependentOn(DInst *dinst){$/;"	f	class:DInst
makeSysCall	Epoch.h	/^    void makeSysCall(SysCall *sysCall){$/;"	f	class:tls::Epoch
mapMemOps	MemBuffer.h	/^  MapMemOpsType mapMemOps;$/;"	m	class:MemBuffer
markExecuted	DInst.h	/^  void markExecuted() {$/;"	f	class:DInst
markFetched	Pipeline.cpp	/^void IBucket::markFetched() $/;"	f	class:IBucket
markFetchedCB	Pipeline.h	/^  StaticCallbackMember0<IBucket, &IBucket::markFetched> markFetchedCB;$/;"	m	class:IBucket
markIssued	DInst.h	/^  void markIssued() {$/;"	f	class:DInst
markPrefetch	MemRequest.h	/^  void markPrefetch() {$/;"	f	class:MemRequest
markResolved	DInst.h	/^  void markResolved() { $/;"	f	class:DInst
markov	CriticalityPredictor.h	/^  MarkovPred   markov;$/;"	m	class:CritPredInfo
mask	Epoch.h	/^	ChunkBitMask mask;$/;"	m	struct:tls::Epoch::BlockVersions::ConflictInfo
maskedChunkCopy	Epoch.h	/^      static void maskedChunkCopy(unsigned char *srcChunk,$/;"	f	class:tls::Epoch::BufferBlock
maxBB	FetchEngine.h	/^  ushort maxBB;$/;"	m	class:FetchEngine
maxBlocksPerEpoch	Epoch.cpp	/^  size_t Epoch::maxBlocksPerEpoch;$/;"	m	class:tls::Epoch	file:
maxBlocksPerEpoch	Epoch.h	/^    static size_t maxBlocksPerEpoch;$/;"	m	class:tls::Epoch
maxCkps	CavaManager.h	/^  int maxCkps;$/;"	m	class:CavaManager
maxCurrTime	Profile.h	/^  Time_t maxCurrTime;$/;"	m	class:Profile
maxHoistThrd	Profile.h	/^  int   maxHoistThrd;$/;"	m	class:Profile
maxInstrCount	Epoch.h	/^    size_t maxInstrCount;$/;"	m	class:tls::Epoch
maxInsts	CavaManager.h	/^  const int  maxInsts;$/;"	m	class:CavaManager
maxItemCntr	Pipeline.h	/^  Time_t maxItemCntr;$/;"	m	class:Pipeline
maxOutsChunks	BulkManager.cpp	/^int  BulkManager::maxOutsChunks;$/;"	m	class:BulkManager	file:
maxOutsChunks	BulkManager.h	/^  static int  maxOutsChunks;$/;"	m	class:BulkManager
maxOutsPreds	CavaManager.h	/^  const int  maxOutsPreds;$/;"	m	class:CavaManager
maxPreds	CavaManager.h	/^  GStatsMax  maxPreds;$/;"	m	class:CavaManager
maxSimulCommits	BulkManager.cpp	/^int  BulkManager::maxSimulCommits;$/;"	m	class:BulkManager	file:
maxSimulCommits	BulkManager.h	/^  static int  maxSimulCommits;$/;"	m	class:BulkManager
maxSizeInsts	CavaManager.h	/^  GStatsMax  maxSizeInsts;$/;"	m	class:CavaManager
maxSpawnCnt	CriticalityPredictor.h	/^  void maxSpawnCnt(int m) {$/;"	f	class:EdgeStateX
maxSquashCnt	CriticalityPredictor.h	/^  void maxSquashCnt(int m) {$/;"	f	class:EdgeStateX
maxValue	CPPred.h	/^  int              maxValue;$/;"	m	class:CPPred
maxVoltPairRunning	DVFSManager.cpp	/^int DVFSManager::maxVoltPairRunning = -1;$/;"	m	class:DVFSManager	file:
maxVoltPairRunning	DVFSManager.h	/^  static int maxVoltPairRunning;$/;"	m	class:DVFSManager
maxWinSize	CriticalityBuilder.h	/^  size_t maxWinSize;$/;"	m	class:CriticalityBuilder
maxWinSize	CriticalityManager.h	/^  size_t maxWinSize; $/;"	m	class:CriticalityBase
maxi	HVersion.h	/^  VType maxi;$/;"	m	class:HVersion
mbd	HVersion.h	/^  MemBufferDomain *mbd;$/;"	m	class:HVersionDomain
mbd	MemBuffer.h	/^  MemBufferDomain *mbd;$/;"	m	class:MemBuffer
mePool	MemBuffer.h	/^  static pool<MemBufferEntry, true> mePool;$/;"	m	class:MemBufferEntry
memAnalyzer	OSSim.h	/^  MemAnalyzer *memAnalyzer;$/;"	m	class:OSSim
memBarrierEvent	OSSim.h	/^  virtual void memBarrierEvent(Pid_t pid, long vaddr, long type, const void *sptr) {$/;"	f	class:OSSim
memBuffer	TaskContext.h	/^  MemBuffer *memBuffer;$/;"	m	class:TaskContext
memOp	MemRequest.h	/^  MemOperation memOp;$/;"	m	class:MemRequest
memOpQueue	ConsistencyPolicy.h	/^  FastQueue<DInst *> memOpQueue;$/;"	m	class:SCConsistencyPolicy
memOpSerialNumber	DInst.h	/^  long int memOpSerialNumber;$/;"	m	class:DInst
memOps	MemBuffer.h	/^  MemOpsType memOps;$/;"	m	class:MemBufferDomain
memStack	MemRequest.h	/^  std::stack<MemObj*> memStack;$/;"	m	class:MemRequest
memValue	DInst.h	/^  ValueType    memValue;$/;"	m	class:DInst
memVer	MemBuffer.h	/^  const HVersion *memVer; \/\/ version$/;"	m	class:MemBuffer
memVer	TaskContext.h	/^  HVersion *memVer;$/;"	m	class:TaskContext
memobj	MemRequest.h	/^  const char *memobj;$/;"	m	class:ReqPathEntry
memoryIssued	DInst.h	/^  bool memoryIssued;$/;"	m	class:DInst
memoryOS	GMemorySystem.h	/^  GMemoryOS *memoryOS;$/;"	m	class:GMemorySystem
memorySystem	GProcessor.h	/^  GMemorySystem *memorySystem;$/;"	m	class:GProcessor
memorySystem	Resource.h	/^  GMemorySystem *memorySystem;$/;"	m	class:MemResource
merg	Epoch.h	/^      enum MergEnum {PassiveMerge, ActiveMerge}                merg : 1;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::MergEnum
merge	Checkpoint.cpp	/^  void Checkpoint::merge(void){$/;"	f	class:tls::Checkpoint
merge	CriticalityTC.cpp	/^void CriticalityTC::merge(CriticalityTC &immSucc)$/;"	f	class:CriticalityTC
merge	Epoch.h	/^      void merge(void) const{$/;"	f	class:tls::Epoch::BufferBlock
mergeBlock	Epoch.cpp	/^  bool Epoch::mergeBlock(Address baseAddr, bool initialMerge){$/;"	f	class:tls::Epoch
mergeBuffer	Epoch.cpp	/^  void Epoch::mergeBuffer(void){$/;"	f	class:tls::Epoch
mergeDestroy	MemBuffer.cpp	/^void MemBuffer::mergeDestroy()$/;"	f	class:MemBuffer
mergeDestroy	MemBuffer.cpp	/^void MemBufferEntry::mergeDestroy()$/;"	f	class:MemBufferEntry
mergeDestroy	TaskContext.cpp	/^void TaskContext::mergeDestroy()$/;"	f	class:TaskContext
mergeDone	Checkpoint.cpp	/^  void Checkpoint::mergeDone(Epoch *epoch){$/;"	f	class:tls::Checkpoint
mergeEpochDone	Checkpoint.cpp	/^    void mergeEpochDone(ClockValue myClk, size_t iCount, SysCallLog &myLog){$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
mergeEpochDone	Checkpoint.cpp	/^  void Checkpoint::ExeOrder::mergeEpochDone(ThreadID tid, ClockValue myClk,$/;"	f	class:tls::Checkpoint::ExeOrder
mergeEpochInit	Checkpoint.cpp	/^    void mergeEpochInit(ClockValue parClk, ClockValue myClk,$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
mergeEpochInit	Checkpoint.cpp	/^  void Checkpoint::ExeOrder::mergeEpochInit(ThreadID tid, ClockValue parClk,$/;"	f	class:tls::Checkpoint::ExeOrder
mergeFrom	CriticalityTC.h	/^  CritID mergeFrom;$/;"	m	class:CriticalityTC
mergeInit	Checkpoint.cpp	/^  Checkpoint *Checkpoint::mergeInit(Epoch *epoch){$/;"	f	class:tls::Checkpoint
mergeIntoOrderList	Checkpoint.cpp	/^    void mergeIntoOrderList(ExeOrderList &mergeList){$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
mergeLast	TaskContext.cpp	/^void TaskContext::mergeLast(bool inv)$/;"	f	class:TaskContext
mergeNext	CriticalityTC.cpp	/^void CriticalityTC::mergeNext()$/;"	f	class:CriticalityTC
mergeNextCont	CriticalityTC.cpp	/^void CriticalityTC::mergeNextCont()$/;"	f	class:CriticalityTC
mergeOps	MemBuffer.cpp	/^void MemBuffer::mergeOps()$/;"	f	class:MemBuffer
mergeOps	TaskContext.cpp	/^bool TaskContext::mergeOps()$/;"	f	class:TaskContext
mergeOrderPos	Checkpoint.cpp	/^    ExeOrderList::iterator mergeOrderPos;$/;"	m	class:tls::Checkpoint::ExeOrder::ThreadExeOrder	file:
mergeProfFile	Profile.cpp	/^void Profile::mergeProfFile(const char *dstFile, char *srcFile1, char *srcFile2) const$/;"	f	class:Profile
mergeSuccessors	TaskContext.cpp	/^void TaskContext::mergeSuccessors(bool inv)$/;"	f	class:TaskContext
mergeToGlobalStats	ProcessId.cpp	/^bool ProcessId::mergeToGlobalStats()$/;"	f	class:ProcessId
mergingEpochs	Checkpoint.h	/^    size_t mergingEpochs;$/;"	m	class:tls::Checkpoint
mergingNotDestroyedCount	Epoch.cpp	/^  size_t Epoch::mergingNotDestroyedCount=0;$/;"	m	class:tls::Epoch	file:
mergingNotDestroyedCount	Epoch.h	/^    static size_t mergingNotDestroyedCount;$/;"	m	class:tls::Epoch
metaTable	BPred.h	/^  SCTable metaTable;$/;"	m	class:BP2BcgSkew
metaTable	BPred.h	/^  SCTable metaTable;$/;"	m	class:BPHybrid
migrable	ProcessId.h	/^  bool migrable;$/;"	m	class:ProcessId
minFenceDelay	Resource.h	/^  TimeDelta_t minFenceDelay;$/;"	m	class:FUStore
minFenceDelayReached	Resource.h	/^  bool minFenceDelayReached;$/;"	m	class:FUStore
minItemCntr	Pipeline.h	/^  Time_t minItemCntr;$/;"	m	class:Pipeline
miniTag	BPred.h	/^  int miniTag;$/;"	m	class:BPOgehl
misBranchRestore	Cluster.cpp	/^void ClusterManager::misBranchRestore()$/;"	f	class:ClusterManager
misBranchRestore	Processor.cpp	/^void Processor::misBranchRestore(DInst *dinst)$/;"	f	class:Processor
misBranchRestore	Resource.cpp	/^void FULoad::misBranchRestore()$/;"	f	class:FULoad
misBranchRestore	Resource.cpp	/^void FUStore::misBranchRestore() $/;"	f	class:FUStore
misBranchRestore	SMTProcessor.cpp	/^void SMTProcessor::misBranchRestore(DInst *dinst)$/;"	f	class:SMTProcessor
misLoads	Resource.h	/^  int misLoads; \/\/ loads from wrong paths$/;"	m	class:FULoad
misRegPool	GProcessor.h	/^  signed int misRegPool[INSTRUCTION_MAX_DESTPOOL];$/;"	m	class:GProcessor
misStores	Resource.h	/^  int               misStores;$/;"	m	class:FUStore
mispred	FetchEngine.h	/^  DInst *mispred;$/;"	m	class:FetchEngine
mispredicted	CavaManager.h	/^    bool mispredicted;$/;"	m	class:CavaManager::PredInfo
miss	MemAnalyzer.h	/^  GStatsCntr miss;$/;"	m	class:GAddressPredictor
miss	VPred.h	/^  GStatsCntr miss;$/;"	m	class:GValuePredictor
miss	VPred.h	/^  GStatsCntr miss;$/;"	m	class:Selector
missDistance	MultiManager.h	/^  GStatsAvg missDistance;$/;"	m	class:MultiPathManager
missFetchTime	FetchEngine.h	/^  Time_t missFetchTime;$/;"	m	class:FetchEngine
missInstID	FetchEngine.h	/^  InstID missInstID;$/;"	m	class:FetchEngine
missWin	MemAnalyzer.h	/^  const unsigned int missWin;$/;"	m	class:StrideAP
mod	CriticalityPredictor.h	/^  int mod;$/;"	m	class:PredictorCnt
mode	SysCall.h	/^    mode_t mode;$/;"	m	struct:SysCallFileIO::OpenFileInfo
moveROB2replayQ	GProcessor.cpp	/^void GProcessor::moveROB2replayQ(){ $/;"	f	class:GProcessor
moveRaceFrontier	Epoch.cpp	/^  void Thread::moveRaceFrontier(void){$/;"	f	class:tls::Thread
moveThreadSafe	Epoch.cpp	/^  void Thread::moveThreadSafe(void){$/;"	f	class:tls::Thread
mreq	CavaManager.h	/^    MemRequest *mreq;$/;"	m	class:CavaManager::PredInfo
mreq	DInst.h	/^  MemRequest *mreq;$/;"	m	class:DInst
mtMarks	OSSim.h	/^    bool  mtMarks;$/;"	m	struct:OSSim::__anon5
multi	GProcessor.h	/^  MultiPathManager *multi;$/;"	m	class:GProcessor
mutateReadToWrite	MemRequest.h	/^  void mutateReadToWrite() { \/\/ Justification for this in SMPCache.cpp$/;"	f	class:MemRequest
mutateWriteToRead	MemRequest.h	/^  void mutateWriteToRead() {$/;"	f	class:MemRequest
mver	MemRequest.h	/^  const HVersion *mver;$/;"	m	class:MemRequest
myAddr	SysCall.h	/^  Address myAddr;$/;"	m	class:SysCallFree
myAddr	SysCall.h	/^  Address myAddr;$/;"	m	class:SysCallMalloc
myAddr	SysCall.h	/^  Address myAddr;$/;"	m	class:SysCallMmap
myAddr	SysCall.h	/^  Address myAddr;$/;"	m	class:SysCallMunmap
myAllEpochsPos	Epoch.h	/^    EpochList::iterator myAllEpochsPos;$/;"	m	class:tls::Epoch
myBackRacesByAddrEp	Epoch.h	/^    RaceByAddrEp myBackRacesByAddrEp;$/;"	m	class:tls::Epoch
myBackRacesByEpAddr	Epoch.h	/^    RaceByEpAddr myBackRacesByEpAddr;$/;"	m	class:tls::Epoch
myBlocks	Checkpoint.h	/^    BlocksMap myBlocks;$/;"	m	class:tls::Checkpoint
myCheckpoint	Epoch.h	/^    Checkpoint *myCheckpoint;$/;"	m	class:tls::Epoch
myClk	Checkpoint.cpp	/^    ClockValue myClk;      \/\/ Global clock of this epoch$/;"	m	struct:tls::ExeOrderEntry	file:
myClock	Checkpoint.h	/^    ClockValue myClock;$/;"	m	class:tls::Checkpoint
myContext	Epoch.h	/^    ThreadContext myContext;$/;"	m	class:tls::Epoch
myEpoch	DInst.h	/^  tls::Epoch *myEpoch;$/;"	m	class:DInst
myExitCode	Epoch.h	/^    int  myExitCode;$/;"	m	class:tls::Thread
myFd	SysCall.h	/^  int myFd;$/;"	m	class:SysCallClose
myFd	SysCall.h	/^  int myFd;$/;"	m	class:SysCallOpen
myFd	SysCall.h	/^  int myFd;$/;"	m	class:SysCallRead
myFd	SysCall.h	/^  int myFd;$/;"	m	class:SysCallWrite
myForwRacesByAddrEp	Epoch.h	/^    RaceByAddrEp myForwRacesByAddrEp;$/;"	m	class:tls::Epoch
myForwRacesByEpAddr	Epoch.h	/^    RaceByEpAddr myForwRacesByEpAddr;$/;"	m	class:tls::Epoch
myID	Epoch.h	/^    ThreadID myID;$/;"	m	class:tls::Thread
myId	ProcessId.h	/^  int     myId;$/;"	m	class:ProcessId
myIndex	Epoch.h	/^    ThreadIndex myIndex;$/;"	m	class:tls::Thread
myIndex	Epoch.h	/^    size_type myIndex;$/;"	m	class:tls::VClock
myInfo	SysCall.h	/^  OpenFileInfo *myInfo;$/;"	m	class:SysCallClose
myIsFlowSource	Epoch.h	/^      bool myIsFlowSource;$/;"	m	class:tls::Epoch::BufferBlock
myIsStale	Epoch.h	/^      bool myIsStale;$/;"	m	class:tls::Epoch::BufferBlock
myListIt	Epoch.h	/^    VClockList::iterator myListIt;$/;"	m	class:tls::VClock
myName	AdvancedStats.h	/^    char *myName;$/;"	m	class:Stats::Group
myPid	Epoch.h	/^    Pid_t  myPid;$/;"	m	class:tls::Epoch
myPid	RatsManager.h	/^  Pid_t myPid;$/;"	m	class:RatsManager
myPid	SysCall.h	/^  Pid_t myPid;$/;"	m	class:SysCallFree
myPid	SysCall.h	/^  Pid_t myPid;$/;"	m	class:SysCallMalloc
myPid	SysCall.h	/^  Pid_t myPid;$/;"	m	class:SysCallMmap
myPid	SysCall.h	/^  Pid_t myPid;$/;"	m	class:SysCallMunmap
myPos	Checkpoint.h	/^    CheckpointList::iterator myPos;$/;"	m	class:tls::Checkpoint
myPosition	Epoch.h	/^      enum Position { First, Second} myPosition;$/;"	m	struct:tls::Epoch::RaceAddrInfo	typeref:enum:tls::Epoch::RaceAddrInfo::Position
mySClock	Epoch.h	/^    ClockValue mySClock;$/;"	m	class:tls::Epoch
mySeqSpec	Epoch.h	/^    const bool mySeqSpec;$/;"	m	class:tls::Epoch
mySize	SysCall.h	/^  size_t  mySize;$/;"	m	class:SysCallFree
mySize	SysCall.h	/^  size_t  mySize;$/;"	m	class:SysCallMunmap
myState	Epoch.h	/^    State myState;$/;"	m	class:tls::Epoch
mySyncSpec	Epoch.h	/^    const bool mySyncSpec;$/;"	m	class:tls::Epoch
myThread	Epoch.h	/^    Thread *myThread;$/;"	m	class:tls::Epoch
myThread	SysCall.h	/^  Pid_t myThread;$/;"	m	class:SysCallExit
myThreadEpochsPos	Epoch.h	/^    EpochList::iterator myThreadEpochsPos;$/;"	m	class:tls::Epoch
myTime	Epoch.h	/^      Time_t myTime;$/;"	m	class:tls::Epoch::TraceEvent
myTrace	Epoch.h	/^    TraceList myTrace;$/;"	m	class:tls::Epoch
myVClock	Epoch.h	/^    VClock myVClock;$/;"	m	class:tls::Epoch
myVector	Epoch.h	/^    ClockVector myVector;$/;"	m	class:tls::VClock
myVersions	Epoch.h	/^      BlockVersions *myVersions;$/;"	m	class:tls::Epoch::BufferBlock
nAccesses	MemAnalyzer.h	/^  int nAccesses;$/;"	m	class:AVSeries
nBTAC	FetchEngine.h	/^  GStatsCntr nBTAC;$/;"	m	class:FetchEngine
nBranches	BPred.h	/^  GStatsCntr nBranches;$/;"	m	class:BPredictor
nCPUs	CriticalityBuilder.h	/^  size_t nCPUs;$/;"	m	class:CriticalityBuilderIface
nCPUs	CriticalityController.h	/^  size_t nCPUs;$/;"	m	class:CriticalityController
nCPUs	CriticalityManager.h	/^  size_t nCPUs;$/;"	m	class:CriticalityManager
nCacheSquashes	BulkManager.h	/^  GStatsCntr nCacheSquashes;$/;"	m	class:BulkManager
nCheckpoints	TaskContext.cpp	/^GStatsCntr *TaskContext::nCheckpoints=0;$/;"	m	class:TaskContext	file:
nCheckpoints	TaskContext.h	/^  static GStatsCntr *nCheckpoints;$/;"	m	class:TaskContext
nChild	ASVersion.h	/^  size_t nChild;$/;"	m	class:HVersion
nChild	HVersion.h	/^      size_t nChild;$/;"	m	class:HVersion::IDP::PredEntry
nChild	HVersion.h	/^  size_t nChild;$/;"	m	class:HVersion
nChildMax	HVersion.cpp	/^size_t HVersion::IDP::nChildMax;$/;"	m	class:HVersion::IDP	file:
nChildMax	HVersion.h	/^    static size_t nChildMax;$/;"	m	class:HVersion::IDP
nChildren	ASVersion.cpp	/^GStatsCntr *HVersion::nChildren[HVersion::nChildrenStatsMax];$/;"	m	class:HVersion	file:
nChildren	ASVersion.h	/^  static GStatsCntr *nChildren[];$/;"	m	class:HVersion
nChildren	HVersion.cpp	/^GStatsCntr *HVersion::nChildren[HVersion::nChildrenStatsMax];$/;"	m	class:HVersion	file:
nChildren	HVersion.h	/^  static GStatsCntr *nChildren[];$/;"	m	class:HVersion
nChildrenStatsMax	ASVersion.h	/^  static const size_t nChildrenStatsMax=10;$/;"	m	class:HVersion
nChildrenStatsMax	HVersion.h	/^  static const size_t nChildrenStatsMax=10;$/;"	m	class:HVersion
nChilds	ProcessId.h	/^  ulong   nChilds;$/;"	m	class:ProcessId
nClaim	ASVersion.cpp	/^GStatsCntr *HVersion::nClaim=0;$/;"	m	class:HVersion	file:
nClaim	ASVersion.h	/^  static GStatsCntr *nClaim;$/;"	m	class:HVersion
nClaim	HVersion.cpp	/^GStatsCntr *HVersion::nClaim=0;$/;"	m	class:HVersion	file:
nClaim	HVersion.h	/^  static GStatsCntr *nClaim;$/;"	m	class:HVersion
nCleanMarks	Pipeline.h	/^  int nCleanMarks;$/;"	m	class:Pipeline
nColdMisses	CPBuilder.cpp	/^GStatsCntr* CPBuilder::nColdMisses = 0;$/;"	m	class:CPBuilder	file:
nColdMisses	CPBuilder.h	/^    static GStatsCntr *nColdMisses;$/;"	m	class:CPBuilder
nCommits	BulkManager.h	/^  GStatsCntr nCommits;$/;"	m	class:BulkManager
nConflicts	BulkManager.h	/^  GStatsCntr nConflicts;$/;"	m	class:BulkManager
nCorrectCritical	CPBuilder.cpp	/^GStatsCntr *CPBuilder::nCorrectCritical = 0;$/;"	m	class:CPBuilder	file:
nCorrectCritical	CPBuilder.h	/^    static GStatsCntr *nCorrectCritical;$/;"	m	class:CPBuilder
nCorrectInOrderSpawn	TaskContext.cpp	/^GStatsCntr *TaskContext::nCorrectInOrderSpawn=0;$/;"	m	class:TaskContext	file:
nCorrectInOrderSpawn	TaskContext.h	/^  static GStatsCntr *nCorrectInOrderSpawn;$/;"	m	class:TaskContext
nCorrectNonCritical	CPBuilder.cpp	/^GStatsCntr *CPBuilder::nCorrectNonCritical = 0;$/;"	m	class:CPBuilder	file:
nCorrectNonCritical	CPBuilder.h	/^    static GStatsCntr *nCorrectNonCritical;$/;"	m	class:CPBuilder
nCorrectOutOrderSpawn	TaskContext.cpp	/^GStatsCntr *TaskContext::nCorrectOutOrderSpawn=0;$/;"	m	class:TaskContext	file:
nCorrectOutOrderSpawn	TaskContext.h	/^  static GStatsCntr *nCorrectOutOrderSpawn;$/;"	m	class:TaskContext
nCorrectlyPredCrit	CPBuilder.cpp	/^GStatsCntr* CPBuilder::nCorrectlyPredCrit = 0;$/;"	m	class:CPBuilder	file:
nCorrectlyPredCrit	CPBuilder.h	/^    static GStatsCntr *nCorrectlyPredCrit;$/;"	m	class:CPBuilder
nCorrectlyPredNonCrit	CPBuilder.cpp	/^GStatsCntr* CPBuilder::nCorrectlyPredNonCrit = 0;$/;"	m	class:CPBuilder	file:
nCorrectlyPredNonCrit	CPBuilder.h	/^    static GStatsCntr *nCorrectlyPredNonCrit;$/;"	m	class:CPBuilder
nCreate	ASVersion.cpp	/^GStatsCntr *HVersion::nCreate=0;$/;"	m	class:HVersion	file:
nCreate	ASVersion.h	/^  static GStatsCntr *nCreate;$/;"	m	class:HVersion
nCreate	HVersion.cpp	/^GStatsCntr *HVersion::nCreate=0;$/;"	m	class:HVersion	file:
nCreate	HVersion.h	/^  static GStatsCntr *nCreate;$/;"	m	class:HVersion
nCyclesBlocked	GProcessor.h	/^  GStatsCntr nCyclesBlocked;$/;"	m	class:GProcessor
nDCPrivate	BulkManager.h	/^  GStatsCntr nDCPrivate;$/;"	m	class:BulkManager
nDataDepViolation	TaskContext.cpp	/^GStatsCntr *TaskContext::nDataDepViolation[DataDepViolationAtMax];$/;"	m	class:TaskContext	file:
nDataDepViolation	TaskContext.h	/^  static GStatsCntr *nDataDepViolation[DataDepViolationAtMax];$/;"	m	class:TaskContext
nDeadStore	Resource.h	/^  GStatsCntr  nDeadStore;$/;"	m	class:FUStore
nDelayInst1	FetchEngine.h	/^  GStatsCntr nDelayInst1;$/;"	m	class:FetchEngine
nDelayInst2	FetchEngine.h	/^  GStatsCntr nDelayInst2;$/;"	m	class:FetchEngine
nDelayed	MultiManager.h	/^  GStatsCntr nDelayed;$/;"	m	class:MultiPathManager
nDeps	DInst.h	/^  char nDeps;              \/\/ 0, 1 or 2 for RISC processors$/;"	m	class:DInst
nDeps	DepWindow.cpp	/^GStatsCntr *DepWindow::nDeps[3] = {0,0,0};$/;"	m	class:DepWindow	file:
nDeps	DepWindow.h	/^  static GStatsCntr *nDeps[];$/;"	m	class:DepWindow
nDiscards	TaskContext.cpp	/^GStatsCntr *TaskContext::nDiscards=0;$/;"	m	class:TaskContext	file:
nDiscards	TaskContext.h	/^  static GStatsCntr *nDiscards;$/;"	m	class:TaskContext
nDispInReadSet	BulkManager.h	/^  GStatsCntr nDispInReadSet;$/;"	m	class:BulkManager
nDispInWriteSet	BulkManager.h	/^  GStatsCntr nDispInWriteSet;$/;"	m	class:BulkManager
nDynHoist	Profile.h	/^    long long nDynHoist;        \/\/how far does it get hoisted dynamically$/;"	m	class:Profile::TaskInfo
nDynPrivateReads	BulkManager.h	/^  GStatsCntr nDynPrivateReads;$/;"	m	class:BulkManager
nDynPrivateSourced	BulkManager.h	/^  GStatsCntr nDynPrivateSourced;$/;"	m	class:BulkManager
nDynPrivateWrites	BulkManager.h	/^  GStatsCntr nDynPrivateWrites;$/;"	m	class:BulkManager
nEntries	VPred.h	/^  unsigned nEntries;$/;"	m	class:BHLVPred
nEntries	VPred.h	/^  unsigned nEntries;$/;"	m	class:ELVPred
nEntries	VPred.h	/^  unsigned nEntries;$/;"	m	class:FCMPred
nEntries	VPred.h	/^  unsigned nEntries;$/;"	m	class:FWPred
nEntries	VPred.h	/^  unsigned nEntries;$/;"	m	class:LVPred
nEntries	VPred.h	/^  unsigned nEntries;$/;"	m	class:SPred
nExceptions	TaskContext.cpp	/^GStatsCntr *TaskContext::nExceptions=0;$/;"	m	class:TaskContext	file:
nExceptions	TaskContext.h	/^  static GStatsCntr *nExceptions;$/;"	m	class:TaskContext
nExec	Profile.h	/^    int  nExec;                 \/\/how many times it gets executed$/;"	m	class:Profile::TaskInfo
nFalseConflicts	BulkManager.h	/^  GStatsCntr nFalseConflicts;$/;"	m	class:BulkManager
nFalseEviction	TaskContext.cpp	/^GStatsCntr *TaskContext::nFalseEviction=0;$/;"	m	class:TaskContext	file:
nFalseEviction	TaskContext.h	/^  static GStatsCntr *nFalseEviction;$/;"	m	class:TaskContext
nFatherRestarts	TaskContext.cpp	/^GStatsCntr *TaskContext::nFatherRestarts=0;$/;"	m	class:TaskContext	file:
nFatherRestarts	TaskContext.h	/^  static GStatsCntr *nFatherRestarts;$/;"	m	class:TaskContext
nFences	Resource.h	/^  GStatsCntr   nFences;$/;"	m	class:FUStore
nFetched	FetchEngine.h	/^  GStatsCntr nFetched;$/;"	m	class:FetchEngine
nForwarded	Resource.h	/^  GStatsCntr  nForwarded;$/;"	m	class:FULoad
nGradInsts	FetchEngine.h	/^  long long nGradInsts;$/;"	m	class:FetchEngine
nGradInsts	ProcessId.cpp	/^long long ProcessId::nGradInsts = 0;       \/\/ Graduated instructions$/;"	m	class:ProcessId	file:
nGradInsts	ProcessId.h	/^    long long nGradInsts;       \/\/ Graduated instructions$/;"	m	class:ProcessId::Stats
nGradInsts	ProcessId.h	/^  static long long nGradInsts;       \/\/ Graduated instructions$/;"	m	class:ProcessId
nHit	BPred.h	/^  GStatsCntr nHit;  \/\/ N.B. predictors should not update these counters directly$/;"	m	class:BPred
nHit	GProcessor.h	/^  GStatsCntr nHit;$/;"	m	class:SqPred
nIOInst	TaskContext.cpp	/^GStatsCntr *TaskContext::nIOInst=0;$/;"	m	class:TaskContext	file:
nIOInst	TaskContext.h	/^  static GStatsCntr *nIOInst;$/;"	m	class:TaskContext
nIOInst2	TaskContext.cpp	/^GStatsCntr *TaskContext::nIOInst2=0;$/;"	m	class:TaskContext	file:
nIOInst2	TaskContext.h	/^  static GStatsCntr *nIOInst2;$/;"	m	class:TaskContext
nIOSpawn	TaskContext.cpp	/^GStatsCntr *TaskContext::nIOSpawn=0;$/;"	m	class:TaskContext	file:
nIOSpawn	TaskContext.h	/^  static GStatsCntr *nIOSpawn;$/;"	m	class:TaskContext
nIOSpawn2	TaskContext.cpp	/^GStatsCntr *TaskContext::nIOSpawn2=0;$/;"	m	class:TaskContext	file:
nIOSpawn2	TaskContext.h	/^  static GStatsCntr *nIOSpawn2;$/;"	m	class:TaskContext
nIRequests	Pipeline.h	/^  int nIRequests;$/;"	m	class:Pipeline
nIgnoredStreams	MemAnalyzer.h	/^  GStatsCntr nIgnoredStreams;$/;"	m	class:StrideAP
nInCorrectlyPredCrit	CPBuilder.cpp	/^GStatsCntr* CPBuilder::nInCorrectlyPredCrit = 0;$/;"	m	class:CPBuilder	file:
nInCorrectlyPredCrit	CPBuilder.h	/^    static GStatsCntr *nInCorrectlyPredCrit;$/;"	m	class:CPBuilder
nInCorrectlyPredNonCrit	CPBuilder.cpp	/^GStatsCntr* CPBuilder::nInCorrectlyPredNonCrit = 0;$/;"	m	class:CPBuilder	file:
nInCorrectlyPredNonCrit	CPBuilder.h	/^    static GStatsCntr *nInCorrectlyPredNonCrit;$/;"	m	class:CPBuilder
nInOrderSpawn	TaskContext.cpp	/^GStatsCntr *TaskContext::nInOrderSpawn=0;$/;"	m	class:TaskContext	file:
nInOrderSpawn	TaskContext.h	/^  static GStatsCntr *nInOrderSpawn;$/;"	m	class:TaskContext
nIncorrectCritical	CPBuilder.cpp	/^GStatsCntr *CPBuilder::nIncorrectCritical = 0;$/;"	m	class:CPBuilder	file:
nIncorrectCritical	CPBuilder.h	/^    static GStatsCntr *nIncorrectCritical;$/;"	m	class:CPBuilder
nIncorrectNonCritical	CPBuilder.cpp	/^GStatsCntr *CPBuilder::nIncorrectNonCritical = 0;$/;"	m	class:CPBuilder	file:
nIncorrectNonCritical	CPBuilder.h	/^    static GStatsCntr *nIncorrectNonCritical;$/;"	m	class:CPBuilder
nInst	GProcessor.h	/^  GStatsCntr *nInst[MaxInstType];$/;"	m	class:GProcessor
nInst	Profile.h	/^    long long nInst;$/;"	m	class:Profile::TaskInfo
nInst	TaskContext.h	/^    long long nInst;$/;"	m	class:TaskContext::TaskEntry
nInst2Sim	FetchEngine.cpp	/^long long FetchEngine::nInst2Sim=0;$/;"	m	class:FetchEngine	file:
nInst2Sim	FetchEngine.h	/^  static long long nInst2Sim;$/;"	m	class:FetchEngine
nInst2Sim	OSSim.h	/^  long long nInst2Sim;$/;"	m	class:OSSim
nInst2Skip	OSSim.h	/^  long long nInst2Skip;$/;"	m	class:OSSim
nInstB4Ckp	TaskContext.cpp	/^long        TaskContext::nInstB4Ckp;\/\/SescConf->getLong("Checkpoints","nInstructions");$/;"	m	class:TaskContext	file:
nInstB4Ckp	TaskContext.h	/^  static long        nInstB4Ckp;$/;"	m	class:TaskContext
nInstCommited2Sim	OSSim.h	/^  long long nInstCommited2Sim;$/;"	m	class:OSSim
nInstFake	GProcessor.h	/^  GStatsCntr *nInstFake[MaxInstType];$/;"	m	class:GProcessor
nInstructions	TaskContext.h	/^  long long nInstructions;$/;"	m	class:TaskContext
nInsts	CavaManager.h	/^    int nInsts;$/;"	m	class:CavaManager::CkpInfoEntry
nInsts	MultiManager.h	/^  GStatsCntr nInsts;$/;"	m	class:MultiPathManager
nL1Retry	Resource.h	/^  GStatsCntr        nL1Retry;$/;"	m	class:FUStore
nL1Retry	Resource.h	/^  GStatsCntr       nL1Retry;$/;"	m	class:FULoad
nL1RetryInsts	Resource.h	/^  GStatsCntr        nL1RetryInsts;$/;"	m	class:FUStore
nL1RetryInsts	Resource.h	/^  GStatsCntr       nL1RetryInsts;$/;"	m	class:FULoad
nLMergeNext	TaskContext.h	/^  int nLMergeNext; \/\/ # mergeNext that this TC has done$/;"	m	class:TaskContext
nLoads	BulkManager.h	/^    int nLoads;$/;"	m	class:BulkManager::Chunk
nLocalRestarts	TaskContext.h	/^  int nLocalRestarts; \/\/ # of restarts that the task received$/;"	m	class:TaskContext
nLockContCycles	GProcessor.h	/^  GStatsCntr nLockContCycles;$/;"	m	class:GProcessor
nLocks	GProcessor.h	/^  GStatsCntr nLocks;$/;"	m	class:GProcessor
nMergeLast	TaskContext.cpp	/^GStatsCntr *TaskContext::nMergeLast=0;$/;"	m	class:TaskContext	file:
nMergeLast	TaskContext.h	/^  static GStatsCntr *nMergeLast;$/;"	m	class:TaskContext
nMergeNext	TaskContext.cpp	/^GStatsCntr *TaskContext::nMergeNext=0;$/;"	m	class:TaskContext	file:
nMergeNext	TaskContext.h	/^  static GStatsCntr *nMergeNext;$/;"	m	class:TaskContext
nMergeSuccessors	TaskContext.cpp	/^GStatsCntr *TaskContext::nMergeSuccessors=0;$/;"	m	class:TaskContext	file:
nMergeSuccessors	TaskContext.h	/^  static GStatsCntr *nMergeSuccessors;$/;"	m	class:TaskContext
nMispred	MultiManager.h	/^  GStatsCntr nMispred;$/;"	m	class:MultiPathManager
nMiss	BPred.h	/^  GStatsCntr nMiss;           \/\/ hits == nBranches - nMiss$/;"	m	class:BPredictor
nMiss	BPred.h	/^  GStatsCntr nMiss; \/\/ in their predict() function.$/;"	m	class:BPred
nMiss	GProcessor.h	/^  GStatsCntr nMiss;$/;"	m	class:SqPred
nMissed	MultiManager.h	/^  GStatsCntr nMissed;$/;"	m	class:MultiPathManager
nMissedLow	MultiManager.h	/^  GStatsCntr nMissedLow;$/;"	m	class:MultiPathManager
nMisses	CavaManager.h	/^    int nMisses;$/;"	m	class:CavaManager::CkpInfoEntry
nNonUnitStrideStreams	MemAnalyzer.h	/^  GStatsCntr nNonUnitStrideStreams;$/;"	m	class:StrideAP
nOOInst	TaskContext.cpp	/^GStatsCntr *TaskContext::nOOInst=0;$/;"	m	class:TaskContext	file:
nOOInst	TaskContext.h	/^  static GStatsCntr *nOOInst;$/;"	m	class:TaskContext
nOOInst2	TaskContext.cpp	/^GStatsCntr *TaskContext::nOOInst2=0;$/;"	m	class:TaskContext	file:
nOOInst2	TaskContext.h	/^  static GStatsCntr *nOOInst2;$/;"	m	class:TaskContext
nOOSpawn	TaskContext.cpp	/^GStatsCntr *TaskContext::nOOSpawn=0;$/;"	m	class:TaskContext	file:
nOOSpawn	TaskContext.h	/^  static GStatsCntr *nOOSpawn;$/;"	m	class:TaskContext
nOOSpawn2	TaskContext.cpp	/^GStatsCntr *TaskContext::nOOSpawn2=0;$/;"	m	class:TaskContext	file:
nOOSpawn2	TaskContext.h	/^  static GStatsCntr *nOOSpawn2;$/;"	m	class:TaskContext
nOutOrderSpawn	TaskContext.cpp	/^GStatsCntr *TaskContext::nOutOrderSpawn=0;$/;"	m	class:TaskContext	file:
nOutOrderSpawn	TaskContext.h	/^  static GStatsCntr *nOutOrderSpawn;$/;"	m	class:TaskContext
nOutsReqs	ASVersion.h	/^  int nOutsReqs;  \/\/ both outs instructions and mem requests                                                                  $/;"	m	class:HVersion
nOutsReqs	HVersion.h	/^  int nOutsReqs;  \/\/ both outs instructions and mem requests$/;"	m	class:HVersion
nOutsStores	Resource.h	/^  int  nOutsStores;$/;"	m	class:FUStore
nOutsStoresOnFence	Resource.h	/^  GStatsHist   nOutsStoresOnFence;$/;"	m	class:FUStore
nOverlappingCommitsR	BulkManager.h	/^  GStatsCntr nOverlappingCommitsR;$/;"	m	class:BulkManager
nOverlappingCommitsW	BulkManager.h	/^  GStatsCntr nOverlappingCommitsW;$/;"	m	class:BulkManager
nPrefs	ConsistencyPolicy.h	/^  GStatsCntr nPrefs;$/;"	m	class:SCPFConsistencyPolicy
nRatInsts	TaskContext.cpp	/^GStatsCntr * TaskContext::nRatInsts=0;$/;"	m	class:TaskContext	file:
nRatInsts	TaskContext.h	/^  static GStatsCntr * nRatInsts;$/;"	m	class:TaskContext
nRdHit	Profile.h	/^    long nRdHit;$/;"	m	class:Profile::TaskInfo
nRdHit	Profile.h	/^  long nRdHit;$/;"	m	class:ProfCache
nRdMiss	Profile.h	/^    long nRdMiss;$/;"	m	class:Profile::TaskInfo
nRdMiss	Profile.h	/^  long nRdMiss;$/;"	m	class:ProfCache
nRelease	ASVersion.cpp	/^GStatsCntr *HVersion::nRelease=0;$/;"	m	class:HVersion	file:
nRelease	ASVersion.h	/^  static GStatsCntr *nRelease;$/;"	m	class:HVersion
nRelease	HVersion.cpp	/^GStatsCntr *HVersion::nRelease=0;$/;"	m	class:HVersion	file:
nRelease	HVersion.h	/^  static GStatsCntr *nRelease;$/;"	m	class:HVersion
nRestart	TaskContext.cpp	/^GStatsCntr *TaskContext::nRestart[TaskContext::nRestartMax];$/;"	m	class:TaskContext	file:
nRestart	TaskContext.h	/^  static GStatsCntr *nRestart[];$/;"	m	class:TaskContext
nRestartBubble	TaskContext.cpp	/^GStatsCntr *TaskContext::nRestartBubble=0;$/;"	m	class:TaskContext	file:
nRestartBubble	TaskContext.h	/^  static GStatsCntr *nRestartBubble;$/;"	m	class:TaskContext
nRestartException	TaskContext.cpp	/^GStatsCntr *TaskContext::nRestartException=0;$/;"	m	class:TaskContext	file:
nRestartException	TaskContext.h	/^  static GStatsCntr *nRestartException;$/;"	m	class:TaskContext
nRestartGradInsts	ProcessId.cpp	/^long long ProcessId::nRestartGradInsts = 0;$/;"	m	class:ProcessId	file:
nRestartGradInsts	ProcessId.h	/^    long long nRestartGradInsts;$/;"	m	class:ProcessId::Stats
nRestartGradInsts	ProcessId.h	/^  static long long nRestartGradInsts;$/;"	m	class:ProcessId
nRestartInvMem	TaskContext.cpp	/^GStatsCntr *TaskContext::nRestartInvMem=0;$/;"	m	class:TaskContext	file:
nRestartInvMem	TaskContext.h	/^  static GStatsCntr *nRestartInvMem;$/;"	m	class:TaskContext
nRestartLateConflict	TaskContext.cpp	/^GStatsCntr *TaskContext::nRestartLateConflict=0;$/;"	m	class:TaskContext	file:
nRestartLateConflict	TaskContext.h	/^  static GStatsCntr *nRestartLateConflict;$/;"	m	class:TaskContext
nRestartLateFalseConflict	TaskContext.cpp	/^GStatsCntr *TaskContext::nRestartLateFalseConflict=0;$/;"	m	class:TaskContext	file:
nRestartLateFalseConflict	TaskContext.h	/^  static GStatsCntr *nRestartLateFalseConflict;$/;"	m	class:TaskContext
nRestartMax	TaskContext.h	/^  static const size_t nRestartMax=10;$/;"	m	class:TaskContext
nRestartWPathInsts	ProcessId.cpp	/^long long ProcessId::nRestartWPathInsts= 0;$/;"	m	class:ProcessId	file:
nRestartWPathInsts	ProcessId.h	/^    long long nRestartWPathInsts;$/;"	m	class:ProcessId::Stats
nRestartWPathInsts	ProcessId.h	/^  static long long nRestartWPathInsts;$/;"	m	class:ProcessId
nRestarts	ProcessId.cpp	/^long long ProcessId::nRestarts = 0;$/;"	m	class:ProcessId	file:
nRestarts	ProcessId.h	/^    long nRestarts;$/;"	m	class:ProcessId::Stats
nRestarts	ProcessId.h	/^  static long long nRestarts;$/;"	m	class:ProcessId
nRestores	TaskContext.cpp	/^GStatsCntr *TaskContext::nRestores=0;$/;"	m	class:TaskContext	file:
nRestores	TaskContext.h	/^  static GStatsCntr *nRestores;$/;"	m	class:TaskContext
nSaved	MultiManager.h	/^  GStatsCntr nSaved;$/;"	m	class:MultiPathManager
nShift	ASVersion.cpp	/^GStatsCntr *HVersion::nShift=0;$/;"	m	class:HVersion	file:
nShift	ASVersion.h	/^  static GStatsCntr *nShift;$/;"	m	class:HVersion
nShift	HVersion.cpp	/^GStatsCntr *HVersion::nShift=0;$/;"	m	class:HVersion	file:
nShift	HVersion.h	/^  static GStatsCntr *nShift;$/;"	m	class:HVersion
nSpawn	Profile.h	/^    int  nSpawn;                \/\/how many spawns inside it$/;"	m	class:Profile::TaskInfo
nSpawnCnt	CriticalityPredictor.h	/^  int nSpawnCnt;$/;"	m	class:EdgeStateX
nSpawns	ProcessId.cpp	/^long long ProcessId::nSpawns  = 0;$/;"	m	class:ProcessId	file:
nSpawns	ProcessId.h	/^    long long  nSpawns  ;$/;"	m	class:ProcessId::Stats
nSpawns	ProcessId.h	/^  static long long nSpawns;$/;"	m	class:ProcessId
nSpawns	TaskContext.h	/^    long nSpawns;$/;"	m	class:TaskContext::TaskEntry
nSquashCnt	CriticalityPredictor.h	/^  int nSquashCnt;$/;"	m	class:EdgeStateX
nSquashLikely	CriticalityPredictor.h	/^  int nSquashLikely;$/;"	m	class:EdgeStateX
nSquashes	BulkManager.h	/^  GStatsCntr nSquashes;$/;"	m	class:BulkManager
nStall	GProcessor.h	/^  GStatsCntr *nStall[MaxStall];$/;"	m	class:GProcessor
nStaticHoist	Profile.h	/^    long long nStaticHoist;     \/\/how far does it get hoisted statically$/;"	m	class:Profile::TaskInfo
nStores	BulkManager.h	/^    int nStores;$/;"	m	class:BulkManager::Chunk
nStreams	MemAnalyzer.h	/^  const int nStreams;$/;"	m	class:StrideAP
nSwitchs	ProcessId.cpp	/^long long ProcessId::nSwitchs = 0;$/;"	m	class:ProcessId	file:
nSwitchs	ProcessId.h	/^    long long  nSwitchs ;$/;"	m	class:ProcessId::Stats
nSwitchs	ProcessId.h	/^  static long long nSwitchs;$/;"	m	class:ProcessId
nTaken	BPred.h	/^  GStatsCntr nTaken;$/;"	m	class:BPredictor
nTasksAhead	TaskContext.cpp	/^GStatsAvg  *TaskContext::nTasksAhead=0;$/;"	m	class:TaskContext	file:
nTasksAhead	TaskContext.h	/^  static GStatsAvg  *nTasksAhead;$/;"	m	class:TaskContext
nUncountRdMiss	Profile.h	/^    long nUncountRdMiss;        \/\/Misses between two squashes$/;"	m	class:Profile::TaskInfo
nUncountWrMiss	Profile.h	/^    long nUncountWrMiss;$/;"	m	class:Profile::TaskInfo
nUnitStrideStreams	MemAnalyzer.h	/^  GStatsCntr nUnitStrideStreams;$/;"	m	class:StrideAP
nUpperCaches	MemObj.h	/^  ulong nUpperCaches;$/;"	m	class:MemObj
nUsers	ASVersion.h	/^  int nUsers;$/;"	m	class:HVersion
nUsers	HVersion.h	/^  int nUsers;$/;"	m	class:HVersion
nVerSafeWB	TaskContext.cpp	/^GStatsCntr *TaskContext::nVerSafeWB=0;$/;"	m	class:TaskContext	file:
nVerSafeWB	TaskContext.h	/^  static GStatsCntr *nVerSafeWB;$/;"	m	class:TaskContext
nViolations	Profile.h	/^    int  nViolations;           \/\/number of violations happened$/;"	m	class:Profile::TaskInfo
nWPathInsts	FetchEngine.h	/^  long long nWPathInsts;$/;"	m	class:FetchEngine
nWPathInsts	ProcessId.cpp	/^long long ProcessId::nWPathInsts= 0;      \/\/ wrong path instructions$/;"	m	class:ProcessId	file:
nWPathInsts	ProcessId.h	/^    long long nWPathInsts;      \/\/ wrong path instructions$/;"	m	class:ProcessId::Stats
nWPathInsts	ProcessId.h	/^  static long long nWPathInsts;      \/\/ wrong path instructions$/;"	m	class:ProcessId
nWWConflicts	TaskContext.cpp	/^GStatsCntr *TaskContext::nWWConflicts=0;$/;"	m	class:TaskContext	file:
nWWConflicts	TaskContext.h	/^  static GStatsCntr *nWWConflicts;$/;"	m	class:TaskContext
nWWConflictsSameCache	TaskContext.cpp	/^GStatsCntr *TaskContext::nWWConflictsSameCache=0;$/;"	m	class:TaskContext	file:
nWWConflictsSameCache	TaskContext.h	/^  static GStatsCntr *nWWConflictsSameCache;$/;"	m	class:TaskContext
nWastedInsts	BulkManager.h	/^  GStatsCntr nWastedInsts;$/;"	m	class:BulkManager
nWrHit	Profile.h	/^    long nWrHit;$/;"	m	class:Profile::TaskInfo
nWrHit	Profile.h	/^  long nWrHit;$/;"	m	class:ProfCache
nWrMiss	Profile.h	/^    long nWrMiss;$/;"	m	class:Profile::TaskInfo
nWrMiss	Profile.h	/^  long nWrMiss;$/;"	m	class:ProfCache
needReclaim	ASVersion.h	/^  bool needReclaim() const { I(0); return true; } \/* just for interface compatibility *\/$/;"	f	class:HVersion
needReclaim	HVersion.h	/^  bool needReclaim() const { return (maxi - base) < 1; }  \/\/ really needs reclaim$/;"	f	class:HVersion
nentry	BPred.h	/^  const int nentry;$/;"	m	class:BPOgehl
never	CriticalityManager.h	/^  void never() {$/;"	f	class:CritLifetime
never	CriticalityManager.h	/^  void never() {$/;"	f	class:NonCritLifetime
newAccess	Epoch.h	/^      TraceAccessEvent *newAccess(Epoch *epoch, Address dAddrV,$/;"	f	class:tls::Epoch::TraceAccessEvent
newBPHistory	TaskContext.h	/^  BPred::HistoryType newBPHistory;$/;"	m	class:TaskContext
newCkp	HVersion.h	/^  unsigned int newCkp() { return ++globalCkpId; }$/;"	f	class:HVersionDomain
newEntry	Cluster.h	/^  void newEntry() {$/;"	f	class:Cluster
newEntry	MemAnalyzer.cpp	/^void AVSeries::newEntry(bool vHit, bool pHit)$/;"	f	class:AVSeries
newFirstVersion	HVersion.cpp	/^HVersion *HVersion::newFirstVersion(TaskContext *t)$/;"	f	class:HVersion
newFrontierCandidate	Epoch.cpp	/^  void Thread::newFrontierCandidate(void){$/;"	f	class:tls::Thread
newHistory	BPred.cpp	/^BPred::HistoryType BPCRap::newHistory(HistoryType iID, bool taken)$/;"	f	class:BPCRap
newHistory	BPred.cpp	/^BPred::HistoryType BPRap::newHistory(HistoryType iID, bool taken)$/;"	f	class:BPRap
newIndex	Epoch.h	/^    static size_type newIndex(size_type index){$/;"	f	class:tls::VClock
newItem	Pipeline.cpp	/^IBucket *Pipeline::newItem() $/;"	f	class:Pipeline
newest	ASVersion.cpp	/^HVersion *HVersion::newest=0;$/;"	m	class:HVersion	file:
newest	ASVersion.h	/^  static HVersion *newest;$/;"	m	class:HVersion
newest	HVersion.h	/^  HVersion *newest;$/;"	m	class:HVersionDomain
next	HVersion.h	/^  HVersion *next;$/;"	m	class:HVersion
nextAddr	MemAnalyzer.h	/^    PAddr nextAddr(CacheGeneric<PrefState,PAddr> *c) {$/;"	f	class:StrideAP::PrefState
nextDep	DInst.h	/^  DInstNext *nextDep;$/;"	m	class:DInstNext
nextFrontierClk	Epoch.h	/^    ClockValue nextFrontierClk;$/;"	m	class:tls::Thread
nextItem	Pipeline.cpp	/^IBucket *Pipeline::nextItem() $/;"	f	class:Pipeline
nextSid	CriticalityTC.h	/^  long nextSid;$/;"	m	class:CriticalityTC
nextStaticID	CriticalityTC.cpp	/^void CriticalityTC::nextStaticID(int asid)$/;"	f	class:CriticalityTC
nextSysCall	Epoch.h	/^    SysCall *nextSysCall(void){$/;"	f	class:tls::Epoch
niKillGradInsts	ProcessId.cpp	/^long long ProcessId::niKillGradInsts   = 0;$/;"	m	class:ProcessId	file:
niKillGradInsts	ProcessId.h	/^    long long niKillGradInsts;$/;"	m	class:ProcessId::Stats
niKillGradInsts	ProcessId.h	/^  static long long niKillGradInsts;$/;"	m	class:ProcessId
niKillWPathInsts	ProcessId.cpp	/^long long ProcessId::niKillWPathInsts  = 0;$/;"	m	class:ProcessId	file:
niKillWPathInsts	ProcessId.h	/^    long long niKillWPathInsts;$/;"	m	class:ProcessId::Stats
niKillWPathInsts	ProcessId.h	/^  static long long niKillWPathInsts;$/;"	m	class:ProcessId
niKills	ProcessId.cpp	/^long long ProcessId::niKills   = 0;$/;"	m	class:ProcessId	file:
niKills	ProcessId.h	/^    long niKills;$/;"	m	class:ProcessId::Stats
niKills	ProcessId.h	/^  static long long niKills;$/;"	m	class:ProcessId
no	CriticalityManager.h	/^  int no; \/\/ never critical$/;"	m	class:CritLifetime
no	CriticalityManager.h	/^  int no;$/;"	m	class:NonCritLifetime
noFetch	SMTProcessor.h	/^  GStatsCntr  noFetch;$/;"	m	class:SMTProcessor
noMoreWork	BulkManager.cpp	/^void PredefinedBulkManager::noMoreWork(const char* when)$/;"	f	class:PredefinedBulkManager
noMoreWork	BulkManager.h	/^  virtual void noMoreWork(const char*){}$/;"	f	class:BulkManager
noRacesMissed	Epoch.h	/^    VClock noRacesMissed;$/;"	m	class:tls::Thread
noSpecTLBMiss	OSSim.h	/^  bool noSpecTLBMiss;$/;"	m	class:OSSim
nonCritMask	CriticalityController.h	/^  BIT_VECTOR nonCritMask;$/;"	m	class:CriticalityController
nonCritMask	CriticalityManager.h	/^  BIT_VECTOR nonCritMask;$/;"	m	class:CriticalityManager
nonSqHist	CriticalityManager.h	/^  HASH_MAP<int,int> nonSqHist;$/;"	m	class:CritScheduler
noncritical	CriticalityManager.h	/^  NonCritLifetime noncritical;$/;"	m	class:PredData
normalFork	TaskContext.cpp	/^void TaskContext::normalFork(Pid_t cpid)$/;"	f	class:TaskContext
normalForkNewDomain	TaskContext.cpp	/^void TaskContext::normalForkNewDomain(Pid_t cpid)$/;"	f	class:TaskContext
notConsumed	CavaManager.h	/^  GStatsCntr notConsumed;$/;"	m	class:CavaManager
notRetired	GProcessor.h	/^  GStatsCntr *notRetired[MaxNoRetResp][MaxInstType][MaxRetOutcome];$/;"	m	class:GProcessor
notRetiredOtherCause	GProcessor.h	/^  GStatsCntr notRetiredOtherCause;$/;"	m	class:GProcessor
notStart	Profile.h	/^  bool notStart() {$/;"	f	class:Profile
note	Profile.h	/^    Note_t note;                \/\/Note for each task$/;"	m	class:Profile::TaskInfo
notifyDataDepViolation	DInst.cpp	/^void DInst::notifyDataDepViolation(DataDepViolationAt dAt, bool val)$/;"	f	class:DInst
notifyDataDepViolation	MemRequest.h	/^  void notifyDataDepViolation() {$/;"	f	class:MemRequest
nrKillGradInsts	ProcessId.cpp	/^long long ProcessId::nrKillGradInsts   = 0;$/;"	m	class:ProcessId	file:
nrKillGradInsts	ProcessId.h	/^    long long nrKillGradInsts;$/;"	m	class:ProcessId::Stats
nrKillGradInsts	ProcessId.h	/^  static long long nrKillGradInsts;$/;"	m	class:ProcessId
nrKillWPathInsts	ProcessId.cpp	/^long long ProcessId::nrKillWPathInsts  = 0;$/;"	m	class:ProcessId	file:
nrKillWPathInsts	ProcessId.h	/^    long long nrKillWPathInsts;$/;"	m	class:ProcessId::Stats
nrKillWPathInsts	ProcessId.h	/^  static long long nrKillWPathInsts;$/;"	m	class:ProcessId
nrKills	ProcessId.cpp	/^long long ProcessId::nrKills   = 0;$/;"	m	class:ProcessId	file:
nrKills	ProcessId.h	/^    long nrKills;$/;"	m	class:ProcessId::Stats
nrKills	ProcessId.h	/^  static long long nrKills;$/;"	m	class:ProcessId
num	Cluster.cpp	/^  long num;$/;"	m	struct:UnitEntry	file:
numBegThread	Epoch.cpp	/^  unsigned long numBegThread=0;$/;"	v
numCausedSquashes	CriticalityTC.h	/^  int numCausedSquashes; \/\/ number of violations caused by writes from self$/;"	m	class:CriticalityTC
numCkpsHist	CavaManager.h	/^  GStatsTimingHist numCkpsHist;$/;"	m	class:CavaManager
numDstAnomalies	Epoch.h	/^    size_t numDstAnomalies;$/;"	m	class:tls::Epoch
numDstRaces	Epoch.h	/^    size_t numDstRaces;$/;"	m	class:tls::Epoch
numEndThread	Epoch.cpp	/^  unsigned long numEndThread=0;$/;"	v
numExceptions	CriticalityTC.h	/^  int numExceptions;$/;"	m	class:CriticalityTC
numIdSimMarks	OSSim.h	/^  long numIdSimMarks;$/;"	m	class:OSSim
numPoints	AdvancedStats.h	/^    size_t numPoints;$/;"	m	class:Stats::Distribution
numRestarts	CriticalityTC.h	/^  int  numRestarts() { return restartFrom.size(); }$/;"	f	class:CriticalityTC
numRunningThreads	TaskContext.cpp	/^GStatsCntr *TaskContext::numRunningThreads[TaskContext::MaxThreadsHist];$/;"	m	class:TaskContext	file:
numRunningThreads	TaskContext.h	/^  static GStatsCntr *numRunningThreads[];$/;"	m	class:TaskContext
numSimpoints	OSSim.h	/^  int numSimpoints;$/;"	m	class:OSSim
numSpawns	CriticalityTC.h	/^  int numSpawns;$/;"	m	class:CriticalityTC
numSrcAnomalies	Epoch.h	/^    size_t numSrcAnomalies;$/;"	m	class:tls::Epoch
numSrcRaces	Epoch.h	/^    size_t numSrcRaces;$/;"	m	class:tls::Epoch
numThreads	TaskContext.cpp	/^GStatsCntr *TaskContext::numThreads[TaskContext::MaxThreadsHist];$/;"	m	class:TaskContext	file:
numThreads	TaskContext.h	/^  static GStatsCntr *numThreads[];$/;"	m	class:TaskContext
occ	Cluster.cpp	/^  long occ;$/;"	m	struct:UnitEntry	file:
occ	CriticalityManager.h	/^  int occ; \/\/ occurences$/;"	m	class:CritLifetime
occ	CriticalityManager.h	/^  int occ;$/;"	m	class:NonCritLifetime
occ	CriticalityManager.h	/^  int occ;$/;"	m	class:PredData
occCnt	CriticalityPredictor.h	/^  int occCnt;$/;"	m	class:PredictorCnt
occurrence	Profile.h	/^    int occurrence;$/;"	m	class:Profile::DepInfo
offset	CriticalityPredictor.h	/^    int offset;$/;"	m	class:OracularCPred::OraclePredInfo
offset	SysCall.h	/^    off_t offset;$/;"	m	struct:SysCallFileIO::OpenFileInfo
oldest	ASVersion.cpp	/^HVersion *HVersion::oldest=0;$/;"	m	class:HVersion	file:
oldest	ASVersion.h	/^  static HVersion *oldest;$/;"	m	class:HVersion
oldest	HVersion.h	/^  HVersion *oldest;$/;"	m	class:HVersionDomain
oldestTC	ASVersion.cpp	/^HVersion *HVersion::oldestTC=0;$/;"	m	class:HVersion	file:
oldestTC	ASVersion.h	/^  static HVersion *oldestTC; $/;"	m	class:HVersion
oldestTC	HVersion.h	/^  HVersion *oldestTC; $/;"	m	class:HVersionDomain
onlyHit	VPred.h	/^  GStatsCntr onlyHit;$/;"	m	class:GValuePredictor
onlyPHit	MemAnalyzer.h	/^  int onlyPHit;$/;"	m	class:AVSeries
onlyVHit	MemAnalyzer.h	/^  int onlyVHit;$/;"	m	class:AVSeries
ooTask	TaskContext.h	/^  bool ooTask;         \/\/ true if the current task was Out-Of-Order$/;"	m	class:TaskContext
openFiles	SysCall.cpp	/^SysCallFileIO::OpenFileVector SysCallFileIO::openFiles;$/;"	m	class:SysCallFileIO	file:
openFiles	SysCall.h	/^  static OpenFileVector openFiles;$/;"	m	class:SysCallFileIO
operator !=	ASVersion.h	/^  bool operator!=(const HVersion &v) const { return base != v.base; }$/;"	f	class:HVersion
operator !=	Epoch.h	/^      bool operator!=(AtomEnum cmpAtom) const{ return atom!=cmpAtom; }$/;"	f	struct:tls::Epoch::State
operator !=	Epoch.h	/^      bool operator!=(ExecEnum cmpExec) const{ return exec!=cmpExec; }$/;"	f	struct:tls::Epoch::State
operator !=	Epoch.h	/^      bool operator!=(IterEnum cmpIter) const{ return iter!=cmpIter; }$/;"	f	struct:tls::Epoch::State
operator !=	Epoch.h	/^      bool operator!=(MergEnum cmpMerg) const{ return merg!=cmpMerg; }$/;"	f	struct:tls::Epoch::State
operator !=	Epoch.h	/^      bool operator!=(SpecEnum cmpSpec) const{ return spec!=cmpSpec; }$/;"	f	struct:tls::Epoch::State
operator !=	Epoch.h	/^      bool operator!=(SuccEnum cmpSucc) const{ return succ!=cmpSucc; }$/;"	f	struct:tls::Epoch::State
operator !=	Epoch.h	/^      bool operator!=(SyncEnum cmpSync) const{ return sync!=cmpSync; }$/;"	f	struct:tls::Epoch::State
operator !=	Epoch.h	/^      bool operator!=(WaitEnum cmpWait) const{ return wait!=cmpWait; }$/;"	f	struct:tls::Epoch::State
operator !=	HVersion.h	/^  bool operator!=(const HVersion &v) const { $/;"	f	class:HVersion
operator ()	ASVersion.h	/^  bool operator()(const HVersion *v1, const HVersion *v2) const {$/;"	f	class:HVersionLessThan
operator ()	ASVersion.h	/^  size_t operator()(const HVersion *v) const {$/;"	f	class:HVersionHashFunc
operator ()	BPred.h	/^    size_t operator()(const HistoryType &addr) const {$/;"	f	class:BPred::Hash4HistoryType
operator ()	CriticalityBuilder.h	/^  size_t operator () (CPNodeGroup *__p) const {$/;"	f	struct:CPNodeGroup_hash
operator ()	CriticalityManager.h	/^    bool operator() (const ProcessId *left, const ProcessId *right) const {$/;"	f	class:CritScheduler::ProcessIdCmp
operator ()	CriticalityManager.h	/^  size_t operator () (CPNodeGroup *__p) const {$/;"	f	struct:CPNodeGroup_hash
operator ()	DInst.h	/^  size_t operator()(const DInst *dinst) const {$/;"	f	class:Hash4DInst
operator ()	GMemorySystem.h	/^  inline bool operator()(const char* s1, const char* s2) const {$/;"	f	class:MemObjCaseeqstr
operator ()	HVersion.h	/^  bool operator()(const HVersion *v1, const HVersion *v2) const {$/;"	f	class:HVersionLessThan
operator ()	HVersion.h	/^  size_t operator()(const HVersion *v) const {$/;"	f	class:HVersionHashFunc
operator ()	MemBuffer.cpp	/^bool MemBufferEntryLessThan::operator()(const MemBufferEntry *v1, const MemBufferEntry *v2) const$/;"	f	class:MemBufferEntryLessThan
operator ()	MemObj.cpp	/^  bool operator()(const char* s1, const char* s2) const {$/;"	f	class:Setltstr
operator ()	MemObj.h	/^  size_t operator()(const MemObj *mobj) const {$/;"	f	class:MemObjHashFunc
operator ()	MemRequest.h	/^  size_t operator()(const MemRequest *mreq) const {$/;"	f	class:MemRequestHashFunc
operator ()	Pipeline.cpp	/^bool PipeIBucketLess::operator()(const IBucket *x, const IBucket *y) const$/;"	f	class:PipeIBucketLess
operator ()	TaskContext.h	/^    size_t operator()(const TaskContext *tc) const {$/;"	f	class:TaskContext::Hash4TaskContext
operator ()	TaskContext.h	/^  bool operator()(void *p1, void *p2) const$/;"	f	struct:ltptr
operator <	ASVersion.h	/^  bool operator< (const HVersion &v) const { return base <  v.base; }$/;"	f	class:HVersion
operator <	HVersion.h	/^  bool operator< (const HVersion &v) const { $/;"	f	class:HVersion
operator <=	ASVersion.h	/^  bool operator<=(const HVersion &v) const { return base <= v.base; }$/;"	f	class:HVersion
operator <=	Epoch.h	/^      bool operator<=(SyncEnum cmpSync) const{ return sync<=cmpSync; }$/;"	f	struct:tls::Epoch::State
operator <=	HVersion.h	/^  bool operator<=(const HVersion &v) const { $/;"	f	class:HVersion
operator =	CPBuilder.h	/^    TokenContainer& operator=(const TokenContainer &container) {$/;"	f	class:TokenContainer
operator =	Epoch.h	/^      State &operator=(AtomEnum newAtom){ atom=newAtom; return *this; }$/;"	f	struct:tls::Epoch::State
operator =	Epoch.h	/^      State &operator=(ExecEnum newExec){ exec=newExec; return *this; }$/;"	f	struct:tls::Epoch::State
operator =	Epoch.h	/^      State &operator=(IterEnum newIter){ iter=newIter; return *this; }$/;"	f	struct:tls::Epoch::State
operator =	Epoch.h	/^      State &operator=(MergEnum newMerg){ merg=newMerg; return *this; }$/;"	f	struct:tls::Epoch::State
operator =	Epoch.h	/^      State &operator=(SpecEnum newSpec){ spec=newSpec; return *this; }$/;"	f	struct:tls::Epoch::State
operator =	Epoch.h	/^      State &operator=(SuccEnum newSucc){ succ=newSucc; return *this; }$/;"	f	struct:tls::Epoch::State
operator =	Epoch.h	/^      State &operator=(SyncEnum newSync){ sync=newSync; return *this; }$/;"	f	struct:tls::Epoch::State
operator =	Epoch.h	/^      State &operator=(WaitEnum newWait){ wait=newWait; return *this; }$/;"	f	struct:tls::Epoch::State
operator ==	ASVersion.h	/^  bool operator==(const HVersion &v) const { return base == v.base; }$/;"	f	class:HVersion
operator ==	BPred.h	/^    bool operator==(BTBState s) const {$/;"	f	class:BPBTB::BTBState
operator ==	BPred.h	/^    bool operator==(PathEntry b) const {$/;"	f	class:BPCRap::PathEntry
operator ==	BPred.h	/^    bool operator==(PathHistoryEntry s) const {$/;"	f	class:BPRap::PathHistoryEntry
operator ==	Epoch.h	/^      bool operator==(AtomEnum cmpAtom) const{ return atom==cmpAtom; }$/;"	f	struct:tls::Epoch::State
operator ==	Epoch.h	/^      bool operator==(ExecEnum cmpExec) const{ return exec==cmpExec; }$/;"	f	struct:tls::Epoch::State
operator ==	Epoch.h	/^      bool operator==(IterEnum cmpIter) const{ return iter==cmpIter; }$/;"	f	struct:tls::Epoch::State
operator ==	Epoch.h	/^      bool operator==(MergEnum cmpMerg) const{ return merg==cmpMerg; }$/;"	f	struct:tls::Epoch::State
operator ==	Epoch.h	/^      bool operator==(SpecEnum cmpSpec) const{ return spec==cmpSpec; }$/;"	f	struct:tls::Epoch::State
operator ==	Epoch.h	/^      bool operator==(SuccEnum cmpSucc) const{ return succ==cmpSucc; }$/;"	f	struct:tls::Epoch::State
operator ==	Epoch.h	/^      bool operator==(SyncEnum cmpSync) const{ return sync==cmpSync; }$/;"	f	struct:tls::Epoch::State
operator ==	Epoch.h	/^      bool operator==(WaitEnum cmpWait) const{ return wait==cmpWait; }$/;"	f	struct:tls::Epoch::State
operator ==	GMemoryOS.h	/^    bool operator==(DTLBState s) const {$/;"	f	class:DummyMemoryOS::DTLBState
operator ==	HVersion.h	/^  bool operator==(const HVersion &v) const { $/;"	f	class:HVersion
operator ==	Profile.h	/^    bool operator==(PCState a) const {$/;"	f	class:ProfCache::PCState
operator >	ASVersion.h	/^  bool operator> (const HVersion &v) const { return base >  v.base; }$/;"	f	class:HVersion
operator >	Epoch.h	/^      bool operator> (SyncEnum cmpSync) const{ return sync> cmpSync; }$/;"	f	struct:tls::Epoch::State
operator >	HVersion.h	/^  bool operator> (const HVersion &v) const { $/;"	f	class:HVersion
operator >=	ASVersion.h	/^  bool operator>=(const HVersion &v) const { return base >= v.base; }$/;"	f	class:HVersion
operator >=	Epoch.h	/^      bool operator>=(IterEnum cmpIter) const{ return iter>=cmpIter; }$/;"	f	struct:tls::Epoch::State
operator >=	Epoch.h	/^      bool operator>=(SpecEnum cmpSpec) const{ return spec>=cmpSpec; }$/;"	f	struct:tls::Epoch::State
operator >=	Epoch.h	/^      bool operator>=(WaitEnum cmpWait) const{ return wait>=cmpWait; }$/;"	f	struct:tls::Epoch::State
operator >=	HVersion.h	/^  bool operator>=(const HVersion &v) const { $/;"	f	class:HVersion
operator []	Epoch.h	/^    ClockValue &operator[](size_type index){$/;"	f	class:tls::VClock
operator []	Epoch.h	/^    const ClockValue &operator[](size_type index) const{$/;"	f	class:tls::VClock
operator |=	CPBuilder.h	/^    TokenContainer& operator|=(const TokenContainer &container) {$/;"	f	class:TokenContainer
oracleID	DInst.h	/^  InstID oracleID;$/;"	m	class:DInst
oraclePred	MultiManager.h	/^  bool oraclePred;$/;"	m	class:MultiPathManager
orderList	Checkpoint.cpp	/^    ExeOrderList orderList;$/;"	m	class:tls::Checkpoint::ExeOrder::ThreadExeOrder	file:
osSim	OSSim.cpp	/^OSSim   *osSim=0;$/;"	v
outOrder	TaskContext.h	/^    bool outOrder;$/;"	m	class:TaskContext::TaskEntry
outsCkps	CavaManager.h	/^  int outsCkps;$/;"	m	class:CavaManager
outsPredictions	CavaManager.h	/^    int outsPredictions;$/;"	m	class:CavaManager::CkpInfoEntry
outsPredictions	CavaManager.h	/^  int outsPredictions;$/;"	m	class:CavaManager
pAddr	MemRequest.h	/^  PAddr  pAddr; \/\/ physical address$/;"	m	class:MemRequest
pBuff	MemAnalyzer.h	/^  BuffType *pBuff;$/;"	m	class:GAddressPredictor
pCrit	CriticalityManager.h	/^  GStatsCntr pCrit;$/;"	m	class:PredData
pCritical	CriticalityManager.h	/^  int pCritical; \/\/ cnt of parent critical on non-critical spawn$/;"	m	class:PredData
pHits	MemAnalyzer.h	/^  int pHits;$/;"	m	class:AVSeries
pPool	MemRequest.h	/^  static pool<ReqPathEntry> pPool;$/;"	m	class:ReqPathEntry
pSafe	CriticalityManager.h	/^  GStatsCntr pSafe;$/;"	m	class:PredData
pSid	CriticalityPredictor.h	/^  int pSid;$/;"	m	class:CritPredInfo
pTable	MemAnalyzer.h	/^  PrefTableType *pTable;$/;"	m	class:MarkovAP
pTable	MemAnalyzer.h	/^  PrefTableType *pTable;$/;"	m	class:StrideAP
pVecValid	CriticalityPredictor.h	/^  bool pVecValid;$/;"	m	class:EdgeCPred
parClk	Checkpoint.cpp	/^    ClockValue parClk;     \/\/ Global clock of parent of this epoch$/;"	m	struct:tls::ExeOrderEntry	file:
parent	HVersion.h	/^  const HVersion *parent;$/;"	m	class:HVersion
parentDInst	DInst.h	/^  DInst *parentDInst;$/;"	m	class:DInstNext
parentGroup	AdvancedStats.h	/^    Group *parentGroup;$/;"	m	class:Stats::Group
parentH	CriticalityManager.h	/^  GStatsHist parentH;$/;"	m	class:PredData
parentHistLen	CriticalityTC.cpp	/^int CriticalityTC::parentHistLen;$/;"	m	class:CriticalityTC	file:
parentHistLen	CriticalityTC.h	/^  static int parentHistLen;$/;"	m	class:CriticalityTC
parentId	ProcessId.h	/^  int     parentId;$/;"	m	class:ProcessId
parentSClock	Epoch.h	/^    ClockValue parentSClock;$/;"	m	class:tls::Epoch
parentSafe	CriticalityTC.h	/^  bool parentSafe;$/;"	m	class:CriticalityTC
parentSid	CriticalityPredictor.h	/^  int parentSid;$/;"	m	class:EdgeState
parentSid	CriticalityPredictor.h	/^  int parentSid;$/;"	m	class:SpawnState
parentSid	CriticalityPredictor.h	/^  int parentSid;$/;"	m	class:SquashState
parentSid	CriticalityTC.h	/^  int    parentSid;$/;"	m	class:CriticalityTC
parentSidHist	CriticalityTC.h	/^  std::vector<int> parentSidHist;$/;"	m	class:CriticalityTC
partition	CriticalityManager.h	/^  bool partition;$/;"	m	class:CriticalityManager
partitionLikelySquash	CriticalityPredictor.cpp	/^void IdealPredInfo::partitionLikelySquash(std::vector<ProcessId*> &procVec)$/;"	f	class:IdealPredInfo
pathname	SysCall.h	/^    char pathname[MAX_FILENAME_LENGTH];$/;"	m	struct:SysCallFileIO::OpenFileInfo
pcache	Profile.h	/^  PCacheType *pcache;$/;"	m	class:ProfCache
pdense	TaskContext.h	/^  bool pdense;$/;"	m	class:TaskContext
pend	DInst.h	/^  DInstNext pend[MAX_PENDING_SOURCES]; \/\/ instrs on which this instr depends$/;"	m	class:DInst
pendEvent	DInst.h	/^  CallbackBase *pendEvent;$/;"	m	class:DInst
pendInstr	Epoch.h	/^    void pendInstr(void){$/;"	f	class:tls::Epoch
pendInstrCount	Epoch.h	/^    long long pendInstrCount;$/;"	m	class:tls::Epoch
pendingBarrier	LDSTBuffer.cpp	/^DInst *LDSTBuffer::pendingBarrier=0;$/;"	m	class:LDSTBuffer	file:
pendingBarrier	LDSTBuffer.h	/^  static DInst *pendingBarrier;$/;"	m	class:LDSTBuffer
pendingFence	Resource.h	/^  bool pendingFence;$/;"	m	class:FUStore
perfPrediction	CavaManager.h	/^  const bool perfPrediction;$/;"	m	class:CavaManager
perfSelector	CavaManager.h	/^  const bool perfSelector;$/;"	m	class:CavaManager
perfectCE	RatsManager.h	/^  bool perfectCE;$/;"	m	class:RatsManager
perfectPred	RatsManager.h	/^  bool perfectPred;$/;"	m	class:RatsManager
permutationSet	BulkManager.cpp	/^bool BulkManager::permutationSet = false;$/;"	m	class:BulkManager	file:
permutationSet	BulkManager.h	/^  static bool permutationSet;$/;"	m	class:BulkManager
phist	BPred.h	/^  long long phist;$/;"	m	class:BPOgehl
phit	VPred.h	/^  GStatsCntr phit;$/;"	m	class:Selector
physicalPage	GMemoryOS.h	/^    long  physicalPage;$/;"	m	class:DummyMemoryOS::DTLBState
picode	Profile.h	/^    icode_ptr picode;$/;"	m	class:Profile::WriteInfo
pid	CavaManager.h	/^    int pid;$/;"	m	class:CavaManager::CkpInfoEntry
pid	FetchEngine.h	/^  Pid_t pid;$/;"	m	class:FetchEngine
pid	OSSim.h	/^    Pid_t pid;$/;"	m	struct:OSSim::__anon5
pid	ProcessId.h	/^  Pid_t   pid;$/;"	m	class:ProcessId
pid2GProcessor	OSSim.cpp	/^GProcessor *OSSim::pid2GProcessor(Pid_t pid)$/;"	f	class:OSSim
pidPool	ProcessId.cpp	/^pool<ProcessId, true> ProcessId::pidPool;$/;"	m	class:ProcessId	file:
pidPool	ProcessId.h	/^  static pool<ProcessId,true> pidPool;$/;"	m	class:ProcessId
pidTable	ProcessId.cpp	/^std::vector<ProcessId *> ProcessId::pidTable;$/;"	m	class:ProcessId	file:
pidTable	ProcessId.h	/^  static std::vector<ProcessId *> pidTable;$/;"	m	class:ProcessId
pidToEpoch	Epoch.cpp	/^  Epoch::PidToEpoch Epoch::pidToEpoch;$/;"	m	class:tls::Epoch	file:
pidToEpoch	Epoch.h	/^    static PidToEpoch pidToEpoch;$/;"	m	class:tls::Epoch
pinned	ProcessId.h	/^  bool pinned;$/;"	m	class:ProcessId
pipeId	Pipeline.h	/^  Time_t pipeId;$/;"	m	class:IBucket
pipeLine	Pipeline.h	/^  Pipeline *const pipeLine;$/;"	m	class:IBucket
pipeLine	Pipeline.h	/^  Pipeline pipeLine;$/;"	m	class:PipeQueue
pipeQ	Processor.h	/^  PipeQueue pipeQ;$/;"	m	class:Processor
pipeQ	SMTProcessor.h	/^    PipeQueue   pipeQ;$/;"	m	class:SMTProcessor::Fetch
pmiss	VPred.h	/^  GStatsCntr pmiss;$/;"	m	class:Selector
policy	DVFSManager.cpp	/^DVFSPolicy_t DVFSManager::policy;$/;"	m	class:DVFSManager	file:
policy	DVFSManager.h	/^  static DVFSPolicy_t policy;$/;"	m	class:DVFSManager
poolType	ASVersion.h	/^  typedef pool<HVersion, true> poolType;$/;"	t	class:HVersion
poolType	HVersion.h	/^  typedef pool<HVersion, true> poolType;$/;"	t	class:HVersion
pos	HVersion.h	/^  int pos; \/\/position in vdVec, no delete so it never changes$/;"	m	class:HVersionDomain
postBoot	OSSim.cpp	/^void OSSim::postBoot()$/;"	f	class:OSSim
postBoot	TaskContext.cpp	/^void TaskContext::postBoot()$/;"	f	class:TaskContext
postEvent	OSSim.h	/^  virtual void postEvent(Pid_t pid, long vaddr, long type, const void *sptr) {$/;"	f	class:OSSim
postEventCB	OSSim.h	/^typedef CallbackMember4<OSSim, Pid_t, long, long, const void *, &OSSim::postEvent, 102> postEventCB;$/;"	t
postWrite	MemBuffer.cpp	/^const HVersion *MemBuffer::postWrite(const unsigned long long *writeData,$/;"	f	class:MemBuffer
postWrite	TaskContext.h	/^  const HVersion *postWrite(ulong iAddr, short iFlags, RAddr addr) {$/;"	f	class:TaskContext
ppid	ProcessId.h	/^  Pid_t   ppid; \/\/ Parent pid$/;"	m	class:ProcessId
preBoot	OSSim.cpp	/^void OSSim::preBoot()$/;"	f	class:OSSim
preBoot	TaskContext.cpp	/^void TaskContext::preBoot()$/;"	f	class:TaskContext
preEvent	OSSim.h	/^  virtual void preEvent(Pid_t pid, long vaddr, long type, void *sptr) {$/;"	f	class:OSSim
prePred	BPred.h	/^  BPred *prePred;$/;"	m	class:BPCRap
prePred	BPred.h	/^  BPred *prePred;$/;"	m	class:BPRap
preRat	RatsManager.cpp	/^void RatsManager::preRat(void){ \/\/ use it for static cntrs$/;"	f	class:RatsManager
preWrite	TaskContext.h	/^  RAddr preWrite(RAddr addr) {$/;"	f	class:TaskContext
pred	BPred.h	/^  BPred *pred;$/;"	m	class:BPredictor
pred	BPred.h	/^  char **pred;$/;"	m	class:BPOgehl
pred	CriticalityManager.h	/^  GStatsCntr pred;$/;"	m	class:PredData
pred	GProcessor.h	/^  SqPred *pred;$/;"	m	class:SPredictor
pred	ValueTable.h	/^    int pred;$/;"	m	class:ValueTable::PredEntry
predCache	HVersion.cpp	/^HVersion::IDP::PredType **HVersion::IDP::predCache=0;$/;"	m	class:HVersion::IDP	file:
predCache	HVersion.h	/^    static PredType **predCache;$/;"	m	class:HVersion::IDP
predCnt	CriticalityManager.h	/^  int predCnt;$/;"	m	class:PredData
predCrit	CriticalityTC.h	/^  bool predCrit;$/;"	m	class:SubtaskContext
predFile	CriticalityPredictor.h	/^  FILE *predFile;$/;"	m	class:OracularCPred
predH	CriticalityManager.h	/^  GStatsHist predH;$/;"	m	class:PredData
predId	CavaManager.cpp	/^unsigned int CavaManager::predId = 0;$/;"	m	class:CavaManager	file:
predId	CavaManager.h	/^  static unsigned int predId;$/;"	m	class:CavaManager
predId	DInst.h	/^  unsigned int predId;$/;"	m	class:DInst
predIdMap	CavaManager.h	/^  PredIdMap predIdMap;$/;"	m	class:CavaManager
predInfo	CriticalityPredictor.h	/^  HASH_MAP<int,CritPredInfo> predInfo;$/;"	m	class:IdealPredInfo
predInfoMap	CavaManager.h	/^  PredInfoMap predInfoMap;$/;"	m	class:CavaManager
predLines	CavaManager.h	/^    PredLinesSet predLines;$/;"	m	class:CavaManager::CkpInfoEntry
predLoad	DInst.h	/^  bool         predLoad;$/;"	m	class:DInst
predPolicy	CPBuilder.cpp	/^PredIndexPolicy CPBuilder::predPolicy;$/;"	m	class:CPBuilder	file:
predPolicy	CPBuilder.h	/^    static PredIndexPolicy predPolicy;$/;"	m	class:CPBuilder
predResourceCrit	CriticalityTC.h	/^  bool predResourceCrit;$/;"	m	class:SubtaskContext
predSet	CriticalityManager.h	/^  HASH_MAP<int,int> predSet;$/;"	m	class:PredData
predSetCnt	CriticalityManager.h	/^  HASH_MAP<int,int> predSetCnt;$/;"	m	class:PredData
predSpawnCrit	CriticalityTC.h	/^  bool predSpawnCrit;$/;"	m	class:CriticalityTC
predSquashCrit	CriticalityTC.h	/^  bool   predSquashCrit;$/;"	m	class:CriticalityTC
predSquashCritId	CriticalityTC.h	/^  CritID predSquashCritId;$/;"	m	class:CriticalityTC
predTable	CriticalityManager.h	/^  HASH_MAP<long,PredData*> predTable;$/;"	m	class:CritScheduler
predTaskCrit	CriticalityTC.h	/^  bool predTaskCrit;$/;"	m	class:SubtaskContext
predType	CriticalityController.h	/^  CritPredictor_t predType;$/;"	m	class:CriticalityController
predType	CriticalityManager.h	/^  CritPredictor_t predType;  $/;"	m	class:CritScheduler
predType	CriticalityManager.h	/^  CritPredictor_t predType;  $/;"	m	class:CriticalityManager
predTypeStr	CriticalityController.h	/^  char *predTypeStr;$/;"	m	class:CriticalityController
predTypeStr	CriticalityManager.h	/^  char *predTypeStr;$/;"	m	class:CriticalityManager
predVec	CriticalityPredictor.h	/^  OraclePredVector predVec;$/;"	m	class:OracularCPred
predecessor	Profile.h	/^    int  predecessor;$/;"	m	class:Profile::TaskInfo
predict	BPred.cpp	/^PredType  BPNotTaken::predict(const Instruction * inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPNotTaken
predict	BPred.cpp	/^PredType BP2BcgSkew::predict(const Instruction * inst, InstID oracleID, bool doUpdate)$/;"	f	class:BP2BcgSkew
predict	BPred.cpp	/^PredType BP2bit::predict(const Instruction *inst, InstID oracleID, bool doUpdate)$/;"	f	class:BP2bit
predict	BPred.cpp	/^PredType BP2level::predict(const Instruction * inst, InstID oracleID, bool doUpdate)$/;"	f	class:BP2level
predict	BPred.cpp	/^PredType BPBTB::predict(const Instruction * inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPBTB
predict	BPred.cpp	/^PredType BPCRap::predict(const Instruction *inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPCRap
predict	BPred.cpp	/^PredType BPHybrid::predict(const Instruction *inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPHybrid
predict	BPred.cpp	/^PredType BPOgehl::predict(const  Instruction *inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPOgehl
predict	BPred.cpp	/^PredType BPOracle::predict(const Instruction * inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPOracle
predict	BPred.cpp	/^PredType BPRap::predict(const Instruction *inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPRap
predict	BPred.cpp	/^PredType BPRas::predict(const Instruction *inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPRas
predict	BPred.cpp	/^PredType BPStatic::predict(const Instruction * inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPStatic
predict	BPred.cpp	/^PredType BPTaken::predict(const Instruction * inst, InstID oracleID, bool doUpdate)$/;"	f	class:BPTaken
predict	BPred.cpp	/^PredType BPyags::predict(const Instruction *inst, InstID oracleID,bool doUpdate)$/;"	f	class:BPyags
predict	BPred.h	/^  PredType predict(const Instruction *inst, InstID oracleID, bool doUpdate) {$/;"	f	class:BPredictor
predict	CriticalityPredictor.cpp	/^bool ChooseTwoCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:ChooseTwoCPred
predict	CriticalityPredictor.cpp	/^bool EdgeCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:EdgeCPred
predict	CriticalityPredictor.cpp	/^bool LocalHybridCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:LocalHybridCPred
predict	CriticalityPredictor.cpp	/^bool OracularCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:OracularCPred
predict	CriticalityPredictor.cpp	/^bool PathCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:PathCPred
predict	CriticalityPredictor.cpp	/^bool SafeSortCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:SafeSortCPred
predict	CriticalityPredictor.cpp	/^bool SpawnOnlyCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:SpawnOnlyCPred
predict	CriticalityPredictor.cpp	/^bool SquashOnlyCPred::predict(std::vector<ProcessId*> &procVec)$/;"	f	class:SquashOnlyCPred
predict	CriticalityPredictor.h	/^  bool predict(std::vector<ProcessId*> &procVec) { return false; }$/;"	f	class:IdealPredInfo
predict	CriticalityPredictor.h	/^  int predict(int sid) {$/;"	f	class:MarkovPred
predict	GProcessor.cpp	/^bool SBimodal::predict(PAddr iPC,PAddr addr, bool squash, bool doUpdate)$/;"	f	class:SBimodal
predict	GProcessor.cpp	/^bool SHybrid::predict(PAddr iPC,PAddr addr, bool squash, bool doUpdate)$/;"	f	class:SHybrid
predict	GProcessor.cpp	/^bool SNotSquash::predict(PAddr iPC,PAddr addr, bool squash, bool doUpdate){$/;"	f	class:SNotSquash
predict	GProcessor.cpp	/^bool SSquash::predict(PAddr iPC,PAddr addr, bool squash, bool doUpdate){$/;"	f	class:SSquash
predict	GProcessor.cpp	/^bool STagged::predict(PAddr iPC, PAddr addr, bool squash, bool doUpdate)$/;"	f	class:STagged
predict	GProcessor.h	/^  bool predict(PAddr iPC,PAddr addr, bool squash, bool doUpdate){$/;"	f	class:SPredictor
predict	HVersion.cpp	/^long HVersion::IDP::predict(Pid_t pid, PAddr addr)$/;"	f	class:HVersion::IDP
predict	VPred.cpp	/^bool Selector::predict(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:Selector
predictCon	BPred.cpp	/^int BPHybrid::predictCon(const Instruction *inst, InstID oracleID){$/;"	f	class:BPHybrid
predictCon	BPred.cpp	/^int BPOgehl::predictCon(const Instruction *inst, InstID oracleID){$/;"	f	class:BPOgehl
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID) {$/;"	f	class:BPredictor
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BP2BcgSkew
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BP2bit
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BP2level
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPBTB
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPCRap
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPNotTaken
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPOracle
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPRap
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPStatic
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPTaken
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 2;}$/;"	f	class:BPyags
predictCon	BPred.h	/^  int predictCon(const Instruction *inst, InstID oracleID){return 3;} \/\/ RAS SPECIFIC$/;"	f	class:BPRas
predicted	DInst.h	/^  bool         predicted;$/;"	m	class:DInst
predicted	MemBuffer.h	/^  bool predicted;$/;"	m	class:MemBufferEntry
preds	CriticalityBuilder.h	/^  std::vector<CriticalityPredictor*> preds;$/;"	m	class:CriticalityBuilderIface
preds	CriticalityController.h	/^  CriticalityPredictor* preds;$/;"	m	class:CriticalityController
prefDepth	MemAnalyzer.h	/^  const int prefDepth;$/;"	m	class:StrideAP
prefDepth	MemAnalyzer.h	/^  const unsigned prefDepth;$/;"	m	class:MarkovAP
prefetch	MemAnalyzer.cpp	/^void MarkovAP::prefetch(PrefEntry *pe)$/;"	f	class:MarkovAP
prefetch	MemAnalyzer.cpp	/^void StrideAP::prefetch(PrefEntry *pe)$/;"	f	class:StrideAP
prefetch	MemRequest.h	/^  bool prefetch;$/;"	m	class:MemRequest
presched	DInst.h	/^  bool presched;$/;"	m	class:DInst
prev	HVersion.h	/^  HVersion *prev;$/;"	m	class:HVersion
prevDInstID	GProcessor.h	/^  long prevDInstID;$/;"	m	class:GProcessor
prevSysCall	Epoch.h	/^    SysCall *prevSysCall(void){$/;"	f	class:tls::Epoch
previousSid	CriticalityTC.h	/^  long previousSid() {$/;"	f	class:CriticalityTC
pri	CriticalityPredictor.h	/^  int pri;$/;"	m	class:EdgeChain
priMap	CriticalityPredictor.h	/^  HASH_MAP<ProcessId*,int,hash_pointer> priMap;$/;"	m	class:EdgeCPred
print	Epoch.h	/^      virtual void print(void){$/;"	f	class:tls::Epoch::TraceAccessEvent
print	Epoch.h	/^      virtual void print(void){$/;"	f	class:tls::Epoch::TraceEvent
printEpochs	Epoch.h	/^    static void printEpochs(void){$/;"	f	class:tls::Epoch
printQueue	ProcessId.cpp	/^void ProcessId::printQueue(char *where)$/;"	f	class:ProcessId
priority	MemRequest.h	/^  int priority;$/;"	m	class:MemRequest
priority	ProcessId.h	/^  int priority;$/;"	m	class:ProcessId
privateReadSet	BulkManager.h	/^    AddressSet privateReadSet;$/;"	m	class:BulkManager::Chunk
privateWriteSet	BulkManager.h	/^    AddressSet privateWriteSet;$/;"	m	class:BulkManager::Chunk
privatizeDeviceName	GMemorySystem.cpp	/^char *GMemorySystem::privatizeDeviceName(char *given_name, int num)$/;"	f	class:GMemorySystem
proc	CriticalityPredictor.h	/^    ProcessId *proc;$/;"	m	class:OracularCPred::OraclePredInfo
proc2Timeline	TimelineManager.cpp	/^std::vector<Timeline*> TimelineManager::proc2Timeline;$/;"	m	class:TimelineManager	file:
proc2Timeline	TimelineManager.h	/^  static std::vector<Timeline *> proc2Timeline;$/;"	m	class:TimelineManager
procPresent	CriticalityPredictor.h	/^  HASH_SET<ProcessId*,hash_pointer> procPresent;$/;"	m	class:CriticalityPredictor
procSet	CriticalityController.h	/^  ProcSet procSet;$/;"	m	class:CriticalityController
procSet	CriticalityManager.h	/^  ProcSet procSet;$/;"	m	class:CritScheduler
procVec	CriticalityController.h	/^  std::vector< ProcessId* > procVec;$/;"	m	class:CriticalityController
procVec	CriticalityManager.h	/^  std::vector< ProcessId* > procVec;$/;"	m	class:CritScheduler
procVecSwap	CriticalityManager.h	/^  void procVecSwap(size_t i, size_t k) {$/;"	f	class:CritScheduler
procVecSwap	CriticalityPredictor.h	/^  static void procVecSwap(std::vector<ProcessId*> &procVec, size_t i, size_t k) {$/;"	f	class:CriticalityPredictor
processBeforeLoad	RatsManager.cpp	/^int RatsManager::processBeforeLoad(TaskContext *tc, int iAddr, short opflags, RAddr dAddrR, VAddr dAddrV, int pid)$/;"	f	class:RatsManager
processBranch	FetchEngine.cpp	/^bool FetchEngine::processBranch(DInst *dinst, ushort n2Fetched)$/;"	f	class:FetchEngine
processDInst	BulkManager.cpp	/^void BulkManager::processDInst(DInst *dinst, bool fwd)$/;"	f	class:BulkManager
processDInst	CavaManager.cpp	/^void CavaManager::processDInst(DInst *dinst)$/;"	f	class:CavaManager
processDInst	MultiManager.cpp	/^bool MultiPathManager::processDInst(DInst *dinst, ulong gh, bool correct, bool conf)$/;"	f	class:MultiPathManager
processDInst	RatsManager.cpp	/^void RatsManager::processDInst(DInst *dinst)$/;"	f	class:RatsManager
processHit	MemAnalyzer.cpp	/^void MarkovAP::processHit(PAddr addr)$/;"	f	class:MarkovAP
processHit	MemAnalyzer.cpp	/^void StrideAP::processHit(PAddr addr)$/;"	f	class:StrideAP
processMiss	MemAnalyzer.cpp	/^void MarkovAP::processMiss(PAddr addr)$/;"	f	class:MarkovAP
processMiss	MemAnalyzer.cpp	/^void StrideAP::processMiss(PAddr addr)$/;"	f	class:StrideAP
processParams	OSSim.cpp	/^void OSSim::processParams(int argc, char **argv, char **envp)$/;"	f	class:OSSim
processQueue	ProcessId.cpp	/^ProcessId::ProcessQueue ProcessId::processQueue;$/;"	m	class:ProcessId	file:
processQueue	ProcessId.h	/^  static ProcessQueue processQueue;$/;"	m	class:ProcessId
profCache	Profile.h	/^  ProfCache profCache;$/;"	m	class:Profile
profLoadsCnt	MemAnalyzer.h	/^  GStatsProfiler profLoadsCnt;$/;"	m	class:DelinquentLoad
profLoadsMiss	MemAnalyzer.h	/^  GStatsProfiler profLoadsMiss;$/;"	m	class:DelinquentLoad
profPhase	OSSim.h	/^  int profPhase;$/;"	m	class:OSSim
profSectionName	OSSim.h	/^  const char *profSectionName;$/;"	m	class:OSSim
profiler	OSSim.h	/^  Profile *profiler;$/;"	m	class:OSSim
propRat	RatsManager.h	/^  bool propRat;$/;"	m	class:RatsManager
propagateRat	RatsManager.h	/^  bool propagateRat(void) const {return propRat;}$/;"	f	class:RatsManager
propagateRatMode	TaskContext.cpp	/^int TaskContext::propagateRatMode(void)$/;"	f	class:TaskContext
propagateUnresolvedBranch	GProcessor.cpp	/^void GProcessor::propagateUnresolvedBranch()$/;"	f	class:GProcessor
propagateUnresolvedLoad	GProcessor.cpp	/^void GProcessor::propagateUnresolvedLoad()$/;"	f	class:GProcessor
propagateUnresolvedStore	GProcessor.cpp	/^void GProcessor::propagateUnresolvedStore()$/;"	f	class:GProcessor
prot	BulkManager.h	/^  BSCProtocol *prot;$/;"	m	class:BulkManager
pseudoReset	OSSim.h	/^  void pseudoReset() {snapshotGlobalClock = globalClock;}$/;"	f	class:OSSim
ptaken	BPred.h	/^    bool ptaken;$/;"	m	class:BPCRap::PathEntry
ptaken	BPred.h	/^    bool ptaken;$/;"	m	class:BPRap::PathHistoryEntry
ptoe	EnergyMgr.cpp	/^double EnergyMgr::ptoe(double power) $/;"	f	class:EnergyMgr
ptoe	EnergyMgr.h	/^  static double ptoe(double power) {$/;"	f	class:EnergyMgr
putCntr	ValueTable.cpp	/^GStatsCntr *ValueTable::putCntr=0;$/;"	m	class:ValueTable	file:
putCntr	ValueTable.h	/^  static GStatsCntr *putCntr;$/;"	m	class:ValueTable
putStore	MemAnalyzer.cpp	/^void MemAnalyzer::putStore(PAddr addr, PAddr iPC, ValueType value, unsigned dsize)$/;"	f	class:MemAnalyzer
putStore	VPred.cpp	/^void FWPred::putStore(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:FWPred
putStore	VPred.h	/^  virtual void putStore(PAddr addr, PAddr iPC, ValueType value) { }$/;"	f	class:GValuePredictor
putValue	VPred.cpp	/^bool BHLVPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:BHLVPred
putValue	VPred.cpp	/^bool ELVPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:ELVPred
putValue	VPred.cpp	/^bool FCMPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:FCMPred
putValue	VPred.cpp	/^bool FWPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:FWPred
putValue	VPred.cpp	/^bool GlobalLVPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:GlobalLVPred
putValue	VPred.cpp	/^bool LVPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:LVPred
putValue	VPred.cpp	/^bool SPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:SPred
putValue	VPred.cpp	/^bool ZeroPred::putValue(PAddr addr, PAddr iPC, ValueType value, bool countAcc)$/;"	f	class:ZeroPred
queueDemote	ProcessId.cpp	/^ProcessId *ProcessId::queueDemote(void)$/;"	f	class:ProcessId
queueGet	ProcessId.cpp	/^ProcessId *ProcessId::queueGet(const CPU_t cpu)$/;"	f	class:ProcessId
queueInsert	ProcessId.h	/^  ProcessId *queueInsert(void){$/;"	f	class:ProcessId
queuePosition	ProcessId.h	/^  ProcessQueue::iterator queuePosition;$/;"	m	class:ProcessId
queuePromote	ProcessId.cpp	/^ProcessId *ProcessId::queuePromote(void)$/;"	f	class:ProcessId
queueRemove	ProcessId.h	/^  void queueRemove(void){$/;"	f	class:ProcessId
raceByEp	Epoch.h	/^      RaceByEp raceByEp;$/;"	m	struct:tls::Epoch::RaceAddrInfo
raceFrontier	Epoch.h	/^    EpochList::iterator raceFrontier;$/;"	m	class:tls::Thread
raceFrontierHolders	Epoch.h	/^    VClock::size_type raceFrontierHolders;$/;"	m	class:tls::Thread
raceInstAddr	Epoch.cpp	/^  AddressSet raceInstAddr, anomalyInstAddr;$/;"	v
raceType	Epoch.h	/^      } raceType;$/;"	m	struct:tls::Epoch::RaceInfo	typeref:enum:tls::Epoch::RaceInfo::RaceType
raceTypes	Epoch.h	/^      RaceInfo::RaceType raceTypes;$/;"	m	struct:tls::Epoch::RaceAddrInfo
range	CriticalityPredictor.h	/^  int range(int i) {$/;"	f	class:EdgeCPred
ras	BPred.h	/^  BPRas ras;$/;"	m	class:BPredictor
rasEnergy	BPred.h	/^  GStatsEnergy *rasEnergy;$/;"	m	class:BPRas
rasIndex	TaskContext.h	/^  int     rasIndex;$/;"	m	class:TaskContext
rasStack	TaskContext.h	/^  InstID *rasStack;$/;"	m	class:TaskContext
rat	ASVersion.h	/^  bool rat;$/;"	m	class:HVersion
rat	HVersion.h	/^  bool rat;$/;"	m	class:HVersion
ratTime	TaskContext.cpp	/^GStatsCntr * TaskContext::ratTime=0;$/;"	m	class:TaskContext	file:
ratTime	TaskContext.h	/^  static GStatsCntr * ratTime;$/;"	m	class:TaskContext
ratable	TaskContext.h	/^  bool ratable;$/;"	m	class:TaskContext
rats	GProcessor.h	/^  RatsManager *rats;$/;"	m	class:GProcessor
ratsCreated	RatsManager.cpp	/^GStatsCntr *RatsManager::ratsCreated=0;$/;"	m	class:RatsManager	file:
ratsCreated	RatsManager.h	/^  static GStatsCntr *ratsCreated;$/;"	m	class:RatsManager
ratsL2HalfMisses	TaskContext.cpp	/^GStatsCntr *TaskContext::ratsL2HalfMisses=0;$/;"	m	class:TaskContext	file:
ratsL2HalfMisses	TaskContext.h	/^  static GStatsCntr *ratsL2HalfMisses;$/;"	m	class:TaskContext
ratsL2Misses	TaskContext.cpp	/^GStatsCntr *TaskContext::ratsL2Misses=0;$/;"	m	class:TaskContext	file:
ratsL2Misses	TaskContext.h	/^  static GStatsCntr *ratsL2Misses;$/;"	m	class:TaskContext
rdCnt	MemAnalyzer.h	/^  GStatsCntr rdCnt;$/;"	m	class:DelinquentLoad
rdHit	MemAnalyzer.h	/^  GStatsCntr rdHit;$/;"	m	class:MemAnalyzer
rdMiss	MemAnalyzer.h	/^  GStatsCntr rdMiss;$/;"	m	class:DelinquentLoad
rdMiss	MemAnalyzer.h	/^  GStatsCntr rdMiss;$/;"	m	class:MemAnalyzer
rdOnly	Epoch.h	/^      bool rdOnly;$/;"	m	class:tls::Epoch::BlockVersions
rdRegEnergy	GProcessor.h	/^  GStatsEnergyBase *rdRegEnergy[3]; \/\/ 0 INT, 1 FP, 2 NONE$/;"	m	class:GProcessor
rdSelected	MemAnalyzer.h	/^  GStatsCntr rdSelected;$/;"	m	class:DelinquentLoad
rdSelectedMiss	MemAnalyzer.h	/^  GStatsCntr rdSelectedMiss;$/;"	m	class:DelinquentLoad
reachedHeadOfROB	DInst.h	/^  Time_t reachedHeadOfROB;$/;"	m	class:DInst
read	Epoch.cpp	/^  Address Epoch::read(Address iAddrV, short iFlags,$/;"	f	class:tls::Epoch
read	MemAnalyzer.cpp	/^bool MemAnalyzer::read(PAddr addr, PAddr iPC, ValueType value, unsigned dsize, bool trainVP)$/;"	f	class:MemAnalyzer
read	MemBuffer.cpp	/^RAddr MemBuffer::read(ulong iaddr, short opflags, RAddr addr)$/;"	f	class:MemBuffer
read	Profile.cpp	/^bool ProfCache::read(PAddr addr)$/;"	f	class:ProfCache
read	TaskContext.h	/^  RAddr read(ulong iAddr, short iFlags, RAddr addr) {$/;"	f	class:TaskContext
readAccess	Epoch.h	/^      TraceAccessEvent *readAccess;$/;"	m	struct:tls::Epoch::RaceAddrInfo
readConfig	BulkManager.cpp	/^void BulkManager::readConfig()$/;"	f	class:BulkManager
readIncrPredictor	ValueTable.cpp	/^int ValueTable::readIncrPredictor(int id, int lvalue) $/;"	f	class:ValueTable
readInst	Profile.h	/^    int readInst;$/;"	m	class:Profile::DepInfo
readLVPredictor	ValueTable.cpp	/^int ValueTable::readLVPredictor(int id) $/;"	f	class:ValueTable
readOnly	MemBuffer.cpp	/^RAddr MemBuffer::readOnly(ulong iaddr, short opflags, RAddr addr)$/;"	f	class:MemBuffer
readOnly	TaskContext.h	/^  RAddr readOnly(ulong iAddr, short iFlags, RAddr addr) { return memBuffer->readOnly(iAddr, iFlags, addr);}$/;"	f	class:TaskContext
readParameters	Profile.cpp	/^void Profile::readParameters(const char *section)$/;"	f	class:Profile
readSVPredictor	ValueTable.cpp	/^int ValueTable::readSVPredictor(int id) $/;"	f	class:ValueTable
readSet	BulkManager.h	/^    AddressSet readSet;$/;"	m	class:BulkManager::Chunk
readSet	MemBuffer.h	/^  AddressSet readSet;$/;"	m	class:MemBuffer
readyItem	Pipeline.cpp	/^void Pipeline::readyItem(IBucket *b) $/;"	f	class:Pipeline
realAddr	MemBuffer.h	/^  RAddr realAddr;          \/\/ For stores only$/;"	m	class:MemBufferEntry
realFetch	FetchEngine.cpp	/^void FetchEngine::realFetch(IBucket *bucket, int fetchMax)$/;"	f	class:FetchEngine
recCommit	Profile.cpp	/^void Profile::recCommit(int pid, int tid)$/;"	f	class:Profile
recInitial	Profile.cpp	/^void Profile::recInitial(int pid)$/;"	f	class:Profile
recRead	Profile.cpp	/^void Profile::recRead(VAddr vaddr, icode_ptr picode)$/;"	f	class:Profile
recSpawn	Profile.cpp	/^void Profile::recSpawn(int pid)$/;"	f	class:Profile
recStartInst	Profile.cpp	/^void Profile::recStartInst() $/;"	f	class:Profile
recStopInst	Profile.cpp	/^void Profile::recStopInst() $/;"	f	class:Profile
recTermination	Profile.cpp	/^void Profile::recTermination(int pid)$/;"	f	class:Profile
recWrite	Profile.cpp	/^void Profile::recWrite(VAddr vaddr, icode_ptr picode, bool silent)$/;"	f	class:Profile
received	Pipeline.h	/^  std::priority_queue<IBucket *, std::vector<IBucket*>, PipeIBucketLess> received;$/;"	m	class:Pipeline
recycleStore	GProcessor.h	/^  int recycleStore;   \/\/ min(Ul,Ub)$/;"	m	class:GProcessor
refId	CriticalityBuilder.cpp	/^void CriticalityBuilder::refId(CritID id)$/;"	f	class:CriticalityBuilder
refId	CriticalityManager.cpp	/^void CriticalityBase::refId(CritID id)$/;"	f	class:CriticalityBase
refTasks	CriticalityTC.h	/^  std::vector<CritID> refTasks; \/\/ for managing references on commit$/;"	m	class:CriticalityTC
regPool	GProcessor.h	/^  signed int regPool[INSTRUCTION_MAX_DESTPOOL];$/;"	m	class:GProcessor
registerProc	OSSim.cpp	/^void OSSim::registerProc(GProcessor *core)$/;"	f	class:OSSim
registerRecycled	DInst.h	/^  bool registerRecycled;$/;"	m	class:DInst
registerVisit	MemRequest.h	/^  void registerVisit(MemObj *memobj, const char *action, Time_t time)$/;"	f	class:MemRequest
registerVisit	MemRequest.h	/^  void registerVisit(const char *name, const char *action, Time_t time, int tId, int fId)$/;"	f	class:MemRequest
release	HVersion.cpp	/^void HVersion::release()$/;"	f	class:HVersion
remoteDataSourced	BulkManager.cpp	/^void BulkManager::remoteDataSourced(PAddr addr)$/;"	f	class:BulkManager
remove	CriticalityController.cpp	/^void CriticalityController::remove(Pid_t pid)$/;"	f	class:CriticalityController
remove	CriticalityManager.cpp	/^void CritScheduler::remove(Pid_t pid)$/;"	f	class:CritScheduler
remove	Epoch.cpp	/^  void Epoch::BlockVersions::remove(BufferBlock *block){$/;"	f	class:tls::Epoch::BlockVersions
remove	Epoch.h	/^      void remove(const BufferBlock *bufferBlock){$/;"	f	struct:tls::Epoch::VersionCounts
remove	Epoch.h	/^      void remove(const Epoch *epoch){$/;"	f	struct:tls::Epoch::VersionCounts
remove	LDSTQ.cpp	/^void LDSTQ::remove(DInst *dinst)$/;"	f	class:LDSTQ
removeAccessEvent	Epoch.h	/^    void removeAccessEvent(TraceAccessEvent *event){$/;"	f	class:tls::Epoch
removeEpoch	Epoch.cpp	/^  bool Thread::removeEpoch(Epoch *epoch){$/;"	f	class:tls::Thread
removeSCDependences	DInst.h	/^  void removeSCDependences(){$/;"	f	class:DInst
removeStagingWinFront	CriticalityBuilder.h	/^  CPNodeGroup * removeStagingWinFront() {$/;"	f	class:CriticalityBuilder
removeStagingWinFront	CriticalityManager.h	/^  CPNodeGroup * removeStagingWinFront() {$/;"	f	class:CriticalityBase
renameEnergy	GProcessor.h	/^  GStatsEnergy *renameEnergy;$/;"	m	class:GProcessor
renameTime	DInst.h	/^  Time_t renameTime;$/;"	m	class:DInst
replay	BulkManager.h	/^    void replay(GProcessor *gp) {$/;"	f	class:BulkManager::Chunk
replay	GProcessor.cpp	/^void GProcessor::replay(DInst *dinst)$/;"	f	class:GProcessor
replayQ	GProcessor.h	/^  FastQueue<DInst *> replayQ;$/;"	m	class:GProcessor
report	ASVersion.cpp	/^void HVersion::report()$/;"	f	class:HVersion
report	AdvancedStats.cpp	/^  void Group::report(size_t level) const{$/;"	f	class:Stats::Group
report	GMemoryOS.cpp	/^void DummyMemoryOS::report(const char *str) $/;"	f	class:DummyMemoryOS
report	GProcessor.cpp	/^void GProcessor::report(const char *str)$/;"	f	class:GProcessor
report	HVersion.cpp	/^void HVersion::report()$/;"	f	class:HVersion
report	OSSim.cpp	/^void OSSim::report(const char *str)$/;"	f	class:OSSim
report	ProcessId.cpp	/^void ProcessId::report(const char *str)$/;"	f	class:ProcessId
report	TaskContext.cpp	/^void TaskContext::report()$/;"	f	class:TaskContext
reportFile	OSSim.h	/^  char *reportFile;$/;"	m	class:OSSim
reportId	ProcessId.cpp	/^void ProcessId::reportId()$/;"	f	class:ProcessId
reportMiddle	AdvancedStats.cpp	/^  void Distribution::reportMiddle(size_t level) const{$/;"	f	class:Stats::Distribution
reportMiddle	AdvancedStats.cpp	/^  void Group::reportMiddle(size_t level) const{$/;"	f	class:Stats::Group
reportOnTheFly	OSSim.cpp	/^void OSSim::reportOnTheFly(const char *file)$/;"	f	class:OSSim
reportPrefix	AdvancedStats.cpp	/^  void Group::reportPrefix(size_t level) const{$/;"	f	class:Stats::Group
reportSuffix	AdvancedStats.cpp	/^  void Group::reportSuffix(size_t level) const{$/;"	f	class:Stats::Group
reportValue	CriticalityPredictor.cpp	/^void EdgeStateStat::reportValue() const$/;"	f	class:EdgeStateStat
reportValue	Profile.cpp	/^void Profile::reportValue() const$/;"	f	class:Profile
reqPath	MemRequest.h	/^  ReqPath reqPath;$/;"	m	class:MemRequest
request	MemAnalyzer.cpp	/^bool GAddressPredictor::request(PAddr addr, PAddr iPC, ValueType value)$/;"	f	class:GAddressPredictor
requestActiveMerge	Epoch.cpp	/^  void Epoch::requestActiveMerge(void){$/;"	f	class:tls::Epoch
res	Cluster.h	/^  Resource   *res[MaxInstType];$/;"	m	class:Cluster
res	Cluster.h	/^  Resource   *res[MaxInstType];$/;"	m	class:ClusterManager
reset	MemAnalyzer.h	/^  void reset() { $/;"	f	class:AVSeries
reset	ProcessId.h	/^    void reset() {$/;"	f	class:ProcessId::Stats
resetClone	HVersion.h	/^  void resetClone() {$/;"	f	class:HVersion
resetRat	ASVersion.h	/^  void resetRat() {$/;"	f	class:HVersion
resetRat	HVersion.h	/^  void resetRat() {$/;"	f	class:HVersion
resetTmpTotInst	TaskContext.h	/^  void resetTmpTotInst(void)       { tmpTotInst = 0;}$/;"	f	class:TaskContext
resetTmpWaitTime	TaskContext.h	/^  void resetTmpWaitTime(void)      { tmpWaitTime = -1;}$/;"	f	class:TaskContext
resolved	DInst.h	/^  bool resolved; \/\/ For load\/stores when the address is computer, for$/;"	m	class:DInst
resource	CriticalityManager.h	/^  CritLifetime resource;$/;"	m	class:NonCritLifetime
resource	DInst.h	/^  Resource    *resource;$/;"	m	class:DInst
resourceFrom	CriticalityTC.h	/^  CritID resourceFrom;   \/\/ task that freed resource$/;"	m	class:SubtaskContext
restPri	CriticalityManager.h	/^  GStatsAvg  restPri;$/;"	m	class:PredData
restart	CriticalityManager.h	/^  CritLifetime restart;$/;"	m	class:NonCritLifetime
restart	ProcessId.h	/^  void restart() {$/;"	f	class:ProcessId
restart	TaskHandler.cpp	/^bool TaskHandler::restart(const HVersion *ver, const HVersion *fromVer)$/;"	f	class:TaskHandler
restartAvg	CriticalityManager.h	/^  GStatsAvg restartAvg;$/;"	m	class:PredData
restartCheckpoint	CavaManager.cpp	/^void CavaManager::restartCheckpoint(unsigned int ci, bool unused) $/;"	f	class:CavaManager
restartFrom	CriticalityTC.h	/^  std::vector<CritID> restartFrom;$/;"	m	class:CriticalityTC
restartPri	CriticalityManager.h	/^  GStatsHist restartPri;$/;"	m	class:CriticalityManager
restartRat	TaskContext.cpp	/^GStatsCntr * TaskContext::restartRat=0;$/;"	m	class:TaskContext	file:
restartRat	TaskContext.h	/^  static GStatsCntr * restartRat;$/;"	m	class:TaskContext
restartTls	TaskContext.cpp	/^GStatsCntr * TaskContext::restartTls=0;$/;"	m	class:TaskContext	file:
restartTls	TaskContext.h	/^  static GStatsCntr * restartTls;$/;"	m	class:TaskContext
restartVer	DInst.h	/^  HVersion   *restartVer;$/;"	m	class:DInst
restartWeight	CriticalityTC.h	/^  std::vector<unsigned int> restartWeight;$/;"	m	class:CriticalityTC
restarted	ASVersion.h	/^  void restarted() {$/;"	f	class:HVersion
restarted	CavaManager.h	/^    bool restarted;$/;"	m	class:CavaManager::CkpInfoEntry
restarted	CriticalityPredictor.h	/^    bool restarted;$/;"	m	class:OracularCPred::OraclePredInfo
restarted	HVersion.h	/^  void restarted() {$/;"	f	class:HVersion
restartedCkpSizeHist	CavaManager.h	/^  GStatsHist restartedCkpSizeHist;$/;"	m	class:CavaManager
restore	Checkpoint.cpp	/^    void restore(Address baseAddr){$/;"	f	class:tls::Checkpoint::BlockData
restoreCheckpoint	TaskContext.cpp	/^void TaskContext::restoreCheckpoint()$/;"	f	class:TaskContext
restoreCheckpoint	TaskContext.cpp	/^void TaskContext::restoreCheckpoint(void)$/;"	f	class:TaskContext
resultBusEnergy	DepWindow.h	/^  GStatsEnergy *resultBusEnergy;$/;"	m	class:DepWindow
resume	OSSim.h	/^  void resume(Pid_t pid) {$/;"	f	class:OSSim
resumeTask	TaskContext.cpp	/^void TaskContext::resumeTask()$/;"	f	class:TaskContext
retVal	SysCall.h	/^  clock_t    retVal;$/;"	m	class:SysCallTimes
retire	Cluster.cpp	/^void ExecutedCluster::retire(DInst *dinst)$/;"	f	class:ExecutedCluster
retire	Cluster.cpp	/^void RetiredCluster::retire(DInst *dinst)$/;"	f	class:RetiredCluster
retire	CriticalityController.cpp	/^void CriticalityController::retire(Pid_t pid)$/;"	f	class:CriticalityController
retire	GProcessor.cpp	/^void GProcessor::retire()$/;"	f	class:GProcessor
retire	Resource.cpp	/^RetOutcome FUBranch::retire(DInst *dinst)$/;"	f	class:FUBranch
retire	Resource.cpp	/^RetOutcome FULoad::retire(DInst *dinst)$/;"	f	class:FULoad
retire	Resource.cpp	/^RetOutcome FUMemory::retire(DInst *dinst)$/;"	f	class:FUMemory
retire	Resource.cpp	/^RetOutcome FUStore::retire(DInst *dinst)$/;"	f	class:FUStore
retire	Resource.cpp	/^RetOutcome Resource::retire(DInst *dinst)$/;"	f	class:Resource
retired	GProcessor.h	/^  GStatsAvg retired;$/;"	m	class:GProcessor
retiredLoad	ConsistencyPolicy.cpp	/^void SCConsistencyPolicy::retiredLoad(DInst* dinst){$/;"	f	class:SCConsistencyPolicy
retiredLoad	ConsistencyPolicy.h	/^  virtual void retiredLoad(DInst* dinst) { }$/;"	f	class:DefaultConsistencyPolicy
retiredStore	ConsistencyPolicy.cpp	/^void SCConsistencyPolicy::retiredStore(DInst* dinst)$/;"	f	class:SCConsistencyPolicy
retiredStore	ConsistencyPolicy.h	/^  virtual void retiredStore(DInst* dinst) { }$/;"	f	class:DefaultConsistencyPolicy
retryAcquire	Epoch.cpp	/^  void Epoch::retryAcquire(void){$/;"	f	class:tls::Epoch
returnAccess	MemObj.cpp	/^void DummyMemObj::returnAccess(MemRequest *req) $/;"	f	class:DummyMemObj
returnAccess	MemRequest.cpp	/^void MemRequest::returnAccess()$/;"	f	class:MemRequest
returnAccessCB	MemRequest.h	/^  StaticCallbackMember0<MemRequest, &MemRequest::returnAccess> returnAccessCB;$/;"	m	class:MemRequest
returnToken	CPBuilder.cpp	/^void CPBuilder::returnToken(int tokenId)$/;"	f	class:CPBuilder
rewind	Checkpoint.cpp	/^    void rewind(void){$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
rewind	Checkpoint.cpp	/^  void Checkpoint::ExeOrder::rewind(void){$/;"	f	class:tls::Checkpoint::ExeOrder
rewind	Checkpoint.cpp	/^  void Checkpoint::rewind(void){$/;"	f	class:tls::Checkpoint
riskLoadProf	OSSim.h	/^  RiskLoadProf *riskLoadProf;$/;"	m	class:OSSim
riskLoads	RiskLoadProf.h	/^  HashType riskLoads;$/;"	m	class:RiskLoadProf
robEnergy	GProcessor.h	/^  GStatsEnergy *robEnergy;$/;"	m	class:GProcessor
robUsed	GProcessor.h	/^  GStatsAvg robUsed;$/;"	m	class:GProcessor
rollback	Checkpoint.cpp	/^  void Checkpoint::rollback(ClockValue &currClock, ClockValue targClock){$/;"	f	class:tls::Checkpoint
rollingCnt	CriticalityPredictor.h	/^  int rollingCnt;$/;"	m	class:PredictorCnt
run	Epoch.h	/^    void run(void){$/;"	f	class:tls::Epoch
run	RunningProcs.cpp	/^void RunningProcs::run()$/;"	f	class:RunningProcs
runningTaskSchedule	CriticalityBuilder.h	/^  std::vector< std::list<CritID> > runningTaskSchedule;$/;"	m	class:CriticalityBuilder
runningTaskSchedule	CriticalityManager.h	/^  std::vector< std::list<CritID> > runningTaskSchedule;$/;"	m	class:CriticalityBase
runtimeSClockAdjustments	Epoch.h	/^    size_t runtimeSClockAdjustments;$/;"	m	class:tls::Epoch
s	Profile.h	/^    PCacheState s;$/;"	m	class:ProfCache::PCState
sContext	TaskContext.h	/^  ThreadContext sContext;$/;"	m	class:TaskContext
sHoistOccThrd	Profile.h	/^  float sHoistOccThrd;$/;"	m	class:Profile
safe	CriticalityTC.h	/^  bool safe;$/;"	m	class:SubtaskContext
safe	HVersion.h	/^  bool safe;     \/\/ Task is safe (may commit but order between safe version$/;"	m	class:HVersion
safeInsts	CriticalityTC.h	/^  long long safeInsts;$/;"	m	class:CriticalityTC
safeInsts	CriticalityTC.h	/^  long long safeInsts;$/;"	m	class:SubtaskContext
safeNotAnalyzingBufferBlocks	Epoch.cpp	/^  size_t Epoch::safeNotAnalyzingBufferBlocks=0;$/;"	m	class:tls::Epoch	file:
safeNotAnalyzingBufferBlocks	Epoch.h	/^    static size_t safeNotAnalyzingBufferBlocks;$/;"	m	class:tls::Epoch
safeNotAnalyzingCount	Epoch.cpp	/^  size_t Epoch::safeNotAnalyzingCount=0;$/;"	m	class:tls::Epoch	file:
safeNotAnalyzingCount	Epoch.h	/^    static size_t safeNotAnalyzingCount;$/;"	m	class:tls::Epoch
safeNotAnalyzingInstr	Epoch.cpp	/^  InstrCount Epoch::safeNotAnalyzingInstr=(InstrCount)0;$/;"	m	class:tls::Epoch	file:
safeNotAnalyzingInstr	Epoch.h	/^    static InstrCount safeNotAnalyzingInstr;$/;"	m	class:tls::Epoch
safest	CriticalityController.h	/^  ProcessId * safest;$/;"	m	class:CriticalityController
safest	CriticalityManager.h	/^  ProcessId * safest;$/;"	m	class:CritScheduler
sampleCounts	AdvancedStats.h	/^    SampleCounts sampleCounts;$/;"	m	class:Stats::Distribution
satBits	CPPred.h	/^  uchar            satBits;$/;"	m	class:CPPred
saturated	CPPred.h	/^  int              saturated;$/;"	m	class:CPPred
saveThreadContext	FetchEngine.h	/^  void saveThreadContext(void){$/;"	f	class:FetchEngine
saveThreadContext	Processor.cpp	/^void Processor::saveThreadContext(Pid_t pid)$/;"	f	class:Processor
saveThreadContext	SMTProcessor.cpp	/^void SMTProcessor::saveThreadContext(Pid_t pid)$/;"	f	class:SMTProcessor
scNext	DInst.h	/^  DInst *scNext;$/;"	m	class:DInst
scPrev	DInst.h	/^  DInst *scPrev;$/;"	m	class:DInst
sched	CriticalityManager.h	/^  CritScheduler sched;$/;"	m	class:CriticalityManager
schedGroups	CriticalityBuilder.h	/^  HASH_SET<CPNodeGroup*,CPNodeGroup_hash> schedGroups;$/;"	m	class:CriticalityBuilder
schedGroups	CriticalityManager.h	/^  HASH_SET<CPNodeGroup*,CPNodeGroup_hash> schedGroups; $/;"	m	class:CriticalityBase
schedPort	DepWindow.h	/^  PortGeneric *schedPort;$/;"	m	class:DepWindow
schedTime	DInst.h	/^  Time_t schedTime;$/;"	m	class:DInst
schedule	CriticalityController.h	/^  bool schedule;$/;"	m	class:CriticalityController
schedule	CriticalityManager.cpp	/^void CritScheduler::schedule()$/;"	f	class:CritScheduler
schedule	CriticalityManager.h	/^  bool schedule;$/;"	m	class:CriticalityManager
scheduleCommitedTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::scheduleCommitedTask(CPU_t i)$/;"	f	class:CriticalityBuilder
scheduleCommitedTask	CriticalityManager.cpp	/^void CriticalityBase::scheduleCommitedTask(CPU_t i)$/;"	f	class:CriticalityBase
scheduleKilledTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::scheduleKilledTask(CPU_t i, CritID id)$/;"	f	class:CriticalityBuilder
scheduleKilledTask	CriticalityManager.cpp	/^void CriticalityBase::scheduleKilledTask(CPU_t i, CritID id)$/;"	f	class:CriticalityBase
scheduleProcessor	OSSim.h	/^  void scheduleProcessor(CPU_t cpu) { cpus.scheduleProcessor(cpu); }$/;"	f	class:OSSim
scheduleProcessor	RunningProcs.cpp	/^void RunningProcs::scheduleProcessor(CPU_t cpu)$/;"	f	class:RunningProcs
scheduleTask	CriticalityBuilder.cpp	/^void CriticalityBuilder::scheduleTask(CPU_t i, CritID id)$/;"	f	class:CriticalityBuilder
scheduleTask	CriticalityManager.cpp	/^void CriticalityBase::scheduleTask(CPU_t i, CritID id)$/;"	f	class:CriticalityBase
scheduleTask	CriticalityTC.cpp	/^void CriticalityTC::scheduleTask()$/;"	f	class:CriticalityTC
scrap	DInst.cpp	/^void DInst::scrap()$/;"	f	class:DInst
scrapQ	BulkManager.h	/^    void scrapQ() {$/;"	f	class:BulkManager::Chunk
searchMemoryObj	GMemorySystem.cpp	/^MemObj *GMemorySystem::searchMemoryObj(bool shared, const char *name) const$/;"	f	class:GMemorySystem
searchMemoryObj	GMemorySystem.cpp	/^MemObj *GMemorySystem::searchMemoryObj(bool shared, const char *section, const char *name) const$/;"	f	class:GMemorySystem
searchMemoryObj	GMemorySystem.cpp	/^MemObj *MemoryObjContainer::searchMemoryObj(const char *descr_section, $/;"	f	class:MemoryObjContainer
searchMemoryObj	GMemorySystem.cpp	/^MemObj *MemoryObjContainer::searchMemoryObj(const char *device_name) const$/;"	f	class:MemoryObjContainer
section	BPred.h	/^  char *section;$/;"	m	class:BPredictor
section	GProcessor.h	/^  char *section;$/;"	m	class:SPredictor
seed	CPBuilder.h	/^    void seed(int tokenId) {$/;"	f	class:TokenContainer
seedId	CPBuilder.h	/^    int seedId;$/;"	m	class:TokenContainer
seedToken	CPBuilder.cpp	/^void CPBuilder::seedToken(TaskContext *tc, ulonglong uniqueId)$/;"	f	class:CPBuilder
select	DepWindow.cpp	/^void DepWindow::select(DInst *dinst)$/;"	f	class:DepWindow
selectDecodeFlow	SMTProcessor.cpp	/^void SMTProcessor::selectDecodeFlow()$/;"	f	class:SMTProcessor
selectFetchFlow	SMTProcessor.cpp	/^void SMTProcessor::selectFetchFlow()$/;"	f	class:SMTProcessor
selectIssueFlow	SMTProcessor.cpp	/^void SMTProcessor::selectIssueFlow()$/;"	f	class:SMTProcessor
selective	ProcessId.h	/^  bool selective;  \/\/ migrable && selective$/;"	m	class:ProcessId
selectiveKill	RatsManager.h	/^  bool selectiveKill;$/;"	m	class:RatsManager
sendReq	RatsManager.h	/^  bool sendReq (void) const {return sendReqMem;}$/;"	f	class:RatsManager
sendReqMem	RatsManager.h	/^  bool sendReqMem;$/;"	m	class:RatsManager
seqBeginTime	Profile.h	/^    Time_t seqBeginTime;        \/\/virtual start time for sequential run$/;"	m	class:Profile::TaskInfo
seqRAT	RatsManager.h	/^  bool seqRAT;$/;"	m	class:RatsManager
seqTime	Profile.h	/^  Time_t seqTime;       \/\/Sequential execution time$/;"	m	class:Profile
serialNumber	DInst.h	/^  unsigned serialNumber; \/\/ for load\/store S\/N$/;"	m	class:DInst
servicedFromCache	MemRequest.h	/^  bool servicedFromCache;$/;"	m	class:MemRequest
servicedFromCoherence	MemRequest.h	/^  bool servicedFromCoherence;$/;"	m	class:MemRequest
sescConfSignal	OSSim.cpp	/^static void sescConfSignal(int sig)$/;"	f	file:
setBPHistory	TaskContext.cpp	/^void TaskContext::setBPHistory(BPred::HistoryType h)$/;"	f	class:TaskContext
setBPred	DInst.h	/^  void setBPred(BPredictor *bp, InstID oid) {$/;"	f	class:DInst
setBPred	TaskContext.h	/^  void setBPred(BPred *branchPredictor) {$/;"	f	class:TaskContext
setBank	DInst.h	/^  void setBank(long i) {$/;"	f	class:DInst
setBlockRetire	GProcessor.h	/^  void setBlockRetire() { blockRetire = true; }$/;"	f	class:GProcessor
setBrHist	MemAnalyzer.cpp	/^void MemAnalyzer::setBrHist(int bo) $/;"	f	class:MemAnalyzer
setBrHist	VPred.h	/^  virtual void setBrHist(int bo) {  brHist = ((brHist << 1) | !!bo); }$/;"	f	class:GValuePredictor
setBrHist	VPred.h	/^  void setBrHist(int bo) {  brHist = ((brHist << 1) | !!bo); }$/;"	f	class:ConfidenceEstimator
setBrHist	VPred.h	/^  void setBrHist(int bo) { vp1->setBrHist(bo); vp2->setBrHist(bo); }$/;"	f	class:Selector
setCPU	ProcessId.h	/^  void setCPU(CPU_t nCPU)  {$/;"	f	class:ProcessId
setCanBeRecycled	DInst.h	/^  void setCanBeRecycled() { canBeRecycled = true; }$/;"	f	class:DInst
setChanged	CriticalityController.h	/^  void setChanged()   { changed = true;  }$/;"	f	class:CriticalityController
setChanged	CriticalityManager.h	/^  void setChanged() { changed = true; }$/;"	f	class:CritScheduler
setCheckpoint	TaskContext.h	/^  void setCheckpoint()             { checkpoint = true; }$/;"	f	class:TaskContext
setCheckpointable	TaskContext.h	/^  void setCheckpointable(bool ckp) { checkpointable = ckp;}$/;"	f	class:TaskContext
setCheckpointed	HVersion.h	/^  void setCheckpointed(bool ck) { checkpointed = ck; }$/;"	f	class:HVersionDomain
setCheckpointed	TaskContext.h	/^  void setCheckpointed()           { checkpointed = true;   }$/;"	f	class:TaskContext
setChild	SysCall.h	/^  void setChild(Pid_t child){$/;"	f	class:SysCallWait
setCkpId	DInst.h	/^  void setCkpId(unsigned long ci) { ckpId = ci; checkpointed = true; }$/;"	f	class:DInst
setCkpId	HVersion.h	/^  void setCkpId(unsigned int ci) { ckpId = ci; }$/;"	f	class:HVersion
setClock	Pipeline.h	/^  void setClock() {$/;"	f	class:IBucket
setClockStamp	MemRequest.h	/^  void setClockStamp(Time_t cs) {$/;"	f	class:MemRequest
setClone	HVersion.h	/^  void setClone() {$/;"	f	class:HVersion
setClone	HVersion.h	/^  void setClone(const HVersion *ver) { cloneVer = ver;}$/;"	f	class:HVersion
setClone	TaskContext.h	/^  void setClone(bool v)       {clone = v;}$/;"	f	class:TaskContext
setCloned	TaskContext.h	/^  void setCloned(bool v)      {cloned = v;}$/;"	f	class:TaskContext
setCommitTokenOwner	BulkManager.cpp	/^void PredefinedBulkManager::setCommitTokenOwner(PredefinedBulkManager *bm)$/;"	f	class:PredefinedBulkManager
setConsPref	DInst.h	/^  void setConsPref() { consPrefetchDone = true; }$/;"	f	class:DInst
setCritLevel	GProcessor.h	/^  void setCritLevel(CritLevel l) { cLevel = l; }$/;"	f	class:GProcessor
setCritLevel	TaskContext.h	/^  void setCritLevel(CritLevel l) { cLevel = l; }$/;"	f	class:TaskContext
setCurrentMemObj	MemRequest.h	/^  void setCurrentMemObj(MemObj *obj) {$/;"	f	class:MemRequest
setDeadInst	DInst.h	/^  void setDeadInst() { deadInst = true; }$/;"	f	class:DInst
setDeadStore	DInst.h	/^  void setDeadStore() { $/;"	f	class:DInst
setDepsAtRetire	DInst.h	/^  void setDepsAtRetire() { $/;"	f	class:DInst
setEarlyRecycled	DInst.h	/^  void setEarlyRecycled() { earlyRecycled = true; }$/;"	f	class:DInst
setEpoch	DInst.h	/^  void setEpoch(tls::Epoch *epoch){$/;"	f	class:DInst
setExeTime	DInst.cpp	/^void DInst::setExeTime()$/;"	f	class:DInst
setExecuted	ProcessId.h	/^  void setExecuted()      { executed = true;  }$/;"	f	class:ProcessId
setFake	DInst.h	/^  void setFake() { $/;"	f	class:DInst
setFetch	DInst.h	/^  void setFetch(FetchEngine *fe) {$/;"	f	class:DInst
setFetchTime	DInst.cpp	/^void DInst::setFetchTime()$/;"	f	class:DInst
setFields	MemRequest.h	/^  void setFields(DInst *d, MemOperation mop, MemObj *mo) {$/;"	f	class:MemRequest
setFields	TaskContext.cpp	/^void TaskContext::setFields(Pid_t i, HVersion *v)$/;"	f	class:TaskContext
setFileName	BulkManager.cpp	/^void BulkLogger::setFileName(const char* base)$/;"	f	class:BulkLogger
setFinished	ASVersion.h	/^  void setFinished() { I(0); }$/;"	f	class:HVersion
setFinished	HVersion.cpp	/^void HVersion::setFinished()$/;"	f	class:HVersion
setFinished	TaskHandler.cpp	/^void TaskHandler::setFinished(const HVersion *ver)$/;"	f	class:TaskHandler
setHighestLevel	MemObj.h	/^  void setHighestLevel() {$/;"	f	class:MemObj
setInstructionPointer	FetchEngine.h	/^  void setInstructionPointer(icode_ptr picode){$/;"	f	class:FetchEngine
setInstructionPointer	Processor.cpp	/^void Processor::setInstructionPointer(Pid_t pid, icode_ptr picode)$/;"	f	class:Processor
setInstructionPointer	SMTProcessor.cpp	/^void SMTProcessor::setInstructionPointer(Pid_t pid, icode_ptr picode)$/;"	f	class:SMTProcessor
setIssueTime	DInst.cpp	/^void DInst::setIssueTime()$/;"	f	class:DInst
setKilled	ASVersion.h	/^  void setKilled() {$/;"	f	class:HVersion
setKilled	HVersion.cpp	/^void HVersion::setKilled() $/;"	f	class:HVersion
setL1Retry	DInst.h	/^  void setL1Retry() { l1Retry = true; }$/;"	f	class:DInst
setL2MissDetection	MemRequest.h	/^  void   setL2MissDetection(Time_t time) { l2MissDetection = time; }$/;"	f	class:MemRequest
setLVID	DInst.h	/^  void setLVID(GLVID *b, HVersion *lvidV) {$/;"	f	class:DInst
setLastCommit	CriticalityBuilder.h	/^  void setLastCommit(CPU_t i, CritID id) {$/;"	f	class:CriticalityBuilder
setLastCommit	CriticalityManager.h	/^  void setLastCommit(CPU_t i, CritID id) {$/;"	f	class:CriticalityBase
setLastSpawnCrit	CriticalityTC.h	/^  void setLastSpawnCrit() {$/;"	f	class:CriticalityTC
setLastSquashCrit	CriticalityTC.h	/^  void setLastSquashCrit(CritID sqId) {$/;"	f	class:CriticalityTC
setLoadForwarded	DInst.h	/^  void setLoadForwarded() {$/;"	f	class:DInst
setLoadSent	DInst.h	/^  void setLoadSent() {$/;"	f	class:DInst
setLocalMemDutyCycle	TimelineManager.cpp	/^void TimelineManager::setLocalMemDutyCycle(int cpu, int period, int duty)$/;"	f	class:TimelineManager
setLowConfidence	DInst.h	/^  void setLowConfidence(bool cf) { lowConfidence = cf; }$/;"	f	class:DInst
setMemBufferDomain	HVersion.h	/^  void setMemBufferDomain(MemBufferDomain *m) {$/;"	f	class:HVersionDomain
setMemValue	DInst.h	/^  void setMemValue(ValueType val) { memValue = val; }$/;"	f	class:DInst
setMemoryIssued	DInst.h	/^  void setMemoryIssued() {  memoryIssued  = true; }$/;"	f	class:DInst
setNextDep	DInst.h	/^  void setNextDep(DInstNext *n) {$/;"	f	class:DInstNext
setNonMigrable	ProcessId.h	/^  void setNonMigrable()   { migrable = false;  pinned = true;}$/;"	f	class:ProcessId
setOOtask	TaskContext.cpp	/^void TaskContext::setOOtask()$/;"	f	class:TaskContext
setPAddr	MemRequest.h	/^  void  setPAddr(PAddr a) {$/;"	f	class:MemRequest
setPPid	ProcessId.h	/^  void setPPid(Pid_t newPPid) {$/;"	f	class:ProcessId
setParent	HVersion.h	/^  void setParent(const HVersion *ver) { parent = ver;}$/;"	f	class:HVersion
setParentDInst	DInst.h	/^  void setParentDInst(DInst *d) { }$/;"	f	class:DInstNext
setParentDInst	DInst.h	/^  void setParentDInst(DInst *d) {$/;"	f	class:DInstNext
setPipelineId	Pipeline.h	/^  void setPipelineId(Time_t i) {$/;"	f	class:IBucket
setPolicy	DVFSManager.h	/^  static void setPolicy(DVFSPolicy_t p) {$/;"	f	class:DVFSManager
setPredCrit	CriticalityTC.h	/^  void setPredCrit() {$/;"	f	class:CriticalityTC
setPredId	DInst.h	/^  void setPredId(unsigned int id) { predId = id; }$/;"	f	class:DInst
setPredLoad	DInst.h	/^  void setPredLoad()      { predLoad = true; }$/;"	f	class:DInst
setPredType	CriticalityManager.h	/^  void setPredType(CritPredictor_t p) {  predType = p; }$/;"	f	class:CritScheduler
setPredicted	DInst.h	/^  void setPredicted(bool p)  { predicted = p; }$/;"	f	class:DInst
setPresched	DInst.h	/^  void setPresched() {$/;"	f	class:DInst
setPriority	CriticalityPredictor.cpp	/^void EdgeCPred::setPriority(ProcessId *proc, int pri)$/;"	f	class:EdgeCPred
setPriority	MemRequest.h	/^  void setPriority(int p) { priority = p; }$/;"	f	class:MemRequest
setPriority	OSSim.cpp	/^void OSSim::setPriority(Pid_t pid, int newPrio)$/;"	f	class:OSSim
setPriority	ProcessId.h	/^  ProcessId *setPriority(int newPriority) {$/;"	f	class:ProcessId
setProcDutyCycle	TimelineManager.cpp	/^void TimelineManager::setProcDutyCycle(int cpu, int period, int duty)$/;"	f	class:TimelineManager
setProcessor	RunningProcs.cpp	/^void RunningProcs::setProcessor(CPU_t cpu, GProcessor *newCore)$/;"	f	class:RunningProcs
setRASHistory	TaskContext.h	/^  void setRASHistory(int index, InstID *stack) { $/;"	f	class:TaskContext
setRASIndex	TaskContext.h	/^  void setRASIndex(int index) { rasIndex = index; }$/;"	f	class:TaskContext
setRATEntry	DInst.h	/^  void setRATEntry(DInst **rentry) {$/;"	f	class:DInst
setRat	ASVersion.h	/^  void setRat() {$/;"	f	class:HVersion
setRat	HVersion.h	/^  void setRat() {$/;"	f	class:HVersion
setRatMode	RatsManager.cpp	/^bool RatsManager::setRatMode(DInst *dinst)$/;"	f	class:RatsManager
setRatMode	RatsManager.cpp	/^bool RatsManager::setRatMode(PAddr iPC, Address addrV, TaskContext *tc, RAddr addr)$/;"	f	class:RatsManager
setReachedHeadOfROB	DInst.h	/^  void setReachedHeadOfROB()   { reachedHeadOfROB = globalClock; }$/;"	f	class:DInst
setRegisterRecycled	DInst.h	/^  void setRegisterRecycled() { registerRecycled = true; }$/;"	f	class:DInst
setRenameTime	DInst.cpp	/^void DInst::setRenameTime()$/;"	f	class:DInst
setResource	DInst.h	/^  void setResource(Resource *res) {$/;"	f	class:DInst
setResourceCrit	CriticalityTC.h	/^  void setResourceCrit() {$/;"	f	class:CriticalityTC
setRetireTime	DInst.cpp	/^void DInst::setRetireTime()$/;"	f	class:DInst
setSafe	ASVersion.h	/^  void setSafe() {$/;"	f	class:HVersion
setSafe	CriticalityTC.cpp	/^void CriticalityTC::setSafe()$/;"	f	class:CriticalityTC
setSafe	HVersion.cpp	/^void HVersion::setSafe() $/;"	f	class:HVersion
setSafe	TaskHandler.cpp	/^void TaskHandler::setSafe(const HVersion *ver)$/;"	f	class:TaskHandler
setSafest	CriticalityController.cpp	/^void CriticalityController::setSafest(Pid_t pid)$/;"	f	class:CriticalityController
setSafest	CriticalityManager.cpp	/^void CritScheduler::setSafest(Pid_t pid)$/;"	f	class:CritScheduler
setSchedTime	DInst.cpp	/^void DInst::setSchedTime()$/;"	f	class:DInst
setSelective	ProcessId.h	/^  void setSelective(BIT_VECTOR &cpus){$/;"	f	class:ProcessId
setSerialNumber	DInst.h	/^  void setSerialNumber(unsigned sn) {$/;"	f	class:DInst
setServicedFromCache	MemRequest.h	/^  void setServicedFromCache() { servicedFromCache = true; }$/;"	f	class:MemRequest
setServicedFromCoherence	MemRequest.h	/^  void setServicedFromCoherence() { servicedFromCoherence = true; }$/;"	f	class:MemRequest
setSharedMemDutyCycle	TimelineManager.cpp	/^void TimelineManager::setSharedMemDutyCycle(int period, int duty)$/;"	f	class:TimelineManager
setStackData	DInst.h	/^  void setStackData(bool isStack){stackData=isStack;}$/;"	f	class:DInst
setStallUntil	GProcessor.h	/^  virtual void setStallUntil(Time_t t) { stallUntil = t; }$/;"	f	class:GProcessor
setState	ProcessId.h	/^  void setState(ProcessIdState nstate) {$/;"	f	class:ProcessId
setStoreGloballyPerformed	DInst.h	/^  void setStoreGloballyPerformed() {$/;"	f	class:DInst
setStoreRetired	DInst.h	/^  void setStoreRetired() {$/;"	f	class:DInst
setStoreSent	DInst.h	/^  void setStoreSent() {$/;"	f	class:DInst
setTag	HVersion.h	/^      void setTag(PredEntryTag a) { $/;"	f	class:HVersion::IDP::PredEntry
setTime	DInst.h	/^  void setTime(Time_t w){ when = w;}$/;"	f	class:DInst
setTimeline	Cluster.h	/^  virtual void setTimeline(Timeline *aTimeline) {$/;"	f	class:Cluster
setTimeline	DepWindow.h	/^  void setTimeline(Timeline *aTimeline) {$/;"	f	class:DepWindow
setTimeline	FetchEngine.h	/^  void setTimeline(Timeline *aTimeline) {$/;"	f	class:FetchEngine
setTimeline	GProcessor.cpp	/^void GProcessor::setTimeline(Timeline *aTimeline) $/;"	f	class:GProcessor
setTimeline	MemObj.h	/^  virtual void setTimeline(Timeline *aTimeline) { timeline = aTimeline; }$/;"	f	class:MemObj
setTimeline	Processor.h	/^  void setTimeline(Timeline *aTimeline) {$/;"	f	class:Processor
setTimeline	Resource.cpp	/^void MemResource::setTimeline(Timeline *aTimeline) $/;"	f	class:MemResource
setTimeline	Resource.cpp	/^void Resource::setTimeline(Timeline *aTimeline) { $/;"	f	class:Resource
setTmpComInst	TaskContext.h	/^  void setTmpComInst(long long num) {tmpComInst = num;}$/;"	f	class:TaskContext
setTmpWaitTime	TaskContext.h	/^  void setTmpWaitTime(void)        { tmpWaitTime = globalClock;}$/;"	f	class:TaskContext
setUseAffinity	ProcessId.h	/^  static void setUseAffinity(bool a) {$/;"	f	class:ProcessId
setVMemReq	MemRequest.h	/^  void setVMemReq(VMemReq *req) {$/;"	f	class:MemRequest
setVaddr	DInst.h	/^  void setVaddr(VAddr addr) { vaddr = addr; }$/;"	f	class:DInst
setValuePredHit	DInst.h	/^  void setValuePredHit(bool vh) { valuePredHit = vh; }$/;"	f	class:DInst
setVersionDomain	HVersion.h	/^  void setVersionDomain(HVersionDomain *vd) {$/;"	f	class:HVersion
setVersionRef	DInst.h	/^  void setVersionRef(HVersion *ref) { verRef = ref; }$/;"	f	class:DInst
setWaiting	ProcessId.h	/^  void setWaiting()       { waiting = true;   }$/;"	f	class:ProcessId
setWakeUpTime	DInst.h	/^  void setWakeUpTime(Time_t t)  { $/;"	f	class:DInst
setWrInstAddr	MemBuffer.h	/^  void setWrInstAddr(VAddr iaddr) { wrInstAddr = iaddr; }$/;"	f	class:MemBufferEntry
setnChild	HVersion.h	/^      void setnChild(size_t a) {$/;"	f	class:HVersion::IDP::PredEntry
setnInst2Sim	FetchEngine.h	/^  static void setnInst2Sim(long long a) {$/;"	f	class:FetchEngine
setupCores	CriticalityController.cpp	/^void CriticalityController::setupCores()$/;"	f	class:CriticalityController
setupCores	CriticalityManager.cpp	/^void CriticalityManager::setupCores()$/;"	f	class:CriticalityManager
setupPred	CriticalityManager.cpp	/^void CriticalityManager::setupPred()$/;"	f	class:CriticalityManager
sharedAddInst	GProcessor.cpp	/^StallCause GProcessor::sharedAddInst(DInst *dinst) $/;"	f	class:GProcessor
sharedMemTimeline	TimelineManager.cpp	/^Timeline *TimelineManager::sharedMemTimeline;$/;"	m	class:TimelineManager	file:
sharedMemTimeline	TimelineManager.h	/^  static Timeline *sharedMemTimeline;$/;"	m	class:TimelineManager
sharedMemoryObjContainer	GMemorySystem.cpp	/^MemoryObjContainer GMemorySystem::sharedMemoryObjContainer;$/;"	m	class:GMemorySystem	file:
sharedMemoryObjContainer	GMemorySystem.h	/^  static MemoryObjContainer sharedMemoryObjContainer;$/;"	m	class:GMemorySystem
shiftAllVersions	HVersion.cpp	/^void HVersion::shiftAllVersions()$/;"	f	class:HVersion
showAllStatus	BulkManager.cpp	/^void BulkManager::showAllStatus(){$/;"	f	class:BulkManager
showStatus	BulkManager.cpp	/^void BulkManager::showStatus(){$/;"	f	class:BulkManager
showStatus	BulkManager.cpp	/^void PredefinedBulkManager::showStatus(){$/;"	f	class:PredefinedBulkManager
sid	CriticalityBuilder.h	/^  int sid;$/;"	m	class:GraphState
sid	CriticalityManager.h	/^  int sid;$/;"	m	class:CGPredState
sid	CriticalityManager.h	/^  int sid;$/;"	m	class:GraphState
sid	CriticalityPredictor.h	/^    int sid;$/;"	m	class:OracularCPred::OraclePredInfo
sid	CriticalityPredictor.h	/^  int sid;$/;"	m	class:CritPredInfo
sid	CriticalityPredictor.h	/^  int sid;$/;"	m	class:EdgeState
sid	CriticalityPredictor.h	/^  int sid;$/;"	m	class:MarkovPred
sid	CriticalityPredictor.h	/^  int sid;$/;"	m	class:SpawnState
sid	CriticalityPredictor.h	/^  int sid;$/;"	m	class:SquashState
sid	CriticalityTC.h	/^  long sid;$/;"	m	class:SubtaskContext
sidFreq	CriticalityManager.h	/^  GStatsHist sidFreq;$/;"	m	class:CriticalityManager
sidSet	CriticalityPredictor.h	/^  HASH_SET<int> sidSet;$/;"	m	class:MarkovPred
sidVec	CriticalityPredictor.h	/^  std::vector<int>  sidVec;$/;"	m	class:MarkovPred
signalCatcher	OSSim.cpp	/^static void signalCatcher(int sig)$/;"	f	file:
simFinish	OSSim.cpp	/^void OSSim::simFinish()$/;"	f	class:OSSim
simMarks	OSSim.h	/^  SimulationMark_t simMarks;$/;"	m	class:OSSim
simPointConfigH	CriticalityManager.h	/^  GStatsHist simPointConfigH;$/;"	m	class:CriticalityManager
simPointMarks	OSSim.h	/^  bool simPointMarks;$/;"	m	class:OSSim
simPointNum	CriticalityController.h	/^  int simPointNum;$/;"	m	class:CriticalityController
simPointNum	CriticalityManager.h	/^  int simPointNum;$/;"	m	class:CriticalityManager
simTime	Resource.cpp	/^void FUBranch::simTime(DInst *dinst)$/;"	f	class:FUBranch
simTime	Resource.cpp	/^void FUEvent::simTime(DInst *dinst)$/;"	f	class:FUEvent
simTime	Resource.cpp	/^void FUGeneric::simTime(DInst *dinst)$/;"	f	class:FUGeneric
simTime	Resource.cpp	/^void FULoad::simTime(DInst *dinst)$/;"	f	class:FULoad
simTime	Resource.cpp	/^void FUMemory::simTime(DInst *dinst)$/;"	f	class:FUMemory
simTime	Resource.cpp	/^void FUStore::simTime(DInst *dinst)$/;"	f	class:FUStore
simpointEnd	OSSim.h	/^  int *simpointEnd;$/;"	m	class:OSSim
simpointInterval	OSSim.h	/^  long long simpointInterval;$/;"	m	class:OSSim
simpointStart	OSSim.h	/^  int *simpointStart; \/\/ sorted list of arrival times$/;"	m	class:OSSim
singleton	CPBuilder.cpp	/^CPBuilder *CPBuilder::singleton()$/;"	f	class:CPBuilder
singleton	CriticalityBuilder.h	/^  static CriticalityBuilder *singleton() { I(cb); return cb; }$/;"	f	class:CriticalityBuilder
singleton	CriticalityBuilder.h	/^  static CriticalityBuilderIface *singleton() { I(cbi); return cbi; }$/;"	f	class:CriticalityBuilderIface
singleton	CriticalityController.h	/^  static CriticalityController *singleton() { return ctrl; }$/;"	f	class:CriticalityController
singleton	CriticalityManager.h	/^  static CriticalityBase *singleton() { I(cb); return cb; }$/;"	f	class:CriticalityBase
singleton	CriticalityManager.h	/^  static CriticalityManager *singleton() { return cm; }$/;"	f	class:CriticalityManager
singleton	CriticalityPredictor.cpp	/^EdgeCPred * EdgeCPred::singleton = 0;$/;"	m	class:EdgeCPred	file:
singleton	CriticalityPredictor.h	/^  static EdgeCPred *singleton;$/;"	m	class:EdgeCPred
size	Epoch.h	/^    static size_type size(void){$/;"	f	class:tls::VClock
size	RunningProcs.h	/^  size_t size() const { return cpuVector.size();  }$/;"	f	class:RunningProcs
size_type	Epoch.h	/^    typedef ClockVector::size_type size_type; $/;"	t	class:tls::VClock
skipAcquire	Epoch.cpp	/^  void Epoch::skipAcquire(void){$/;"	f	class:tls::Epoch
skipDivs	RatsManager.h	/^  bool skipDivs(void){return skipdv;}$/;"	f	class:RatsManager
skipMults	RatsManager.h	/^  bool skipMults(void){return skipms;}$/;"	f	class:RatsManager
skipRelease	Epoch.cpp	/^  void Epoch::skipRelease(void){$/;"	f	class:tls::Epoch
skipdv	RatsManager.h	/^  bool skipdv;$/;"	m	class:RatsManager
skipms	RatsManager.h	/^  bool skipms;$/;"	m	class:RatsManager
skippedNES	TaskContext.h	/^  char skippedNES;$/;"	m	class:TaskContext
slack	CriticalityPredictor.h	/^    int slack;$/;"	m	class:OracularCPred::OraclePredInfo
smtContexts	SMTProcessor.h	/^  const int smtContexts;$/;"	m	class:SMTProcessor
snapshotGlobalClock	OSSim.h	/^  unsigned long long snapshotGlobalClock;$/;"	m	class:OSSim
solveRequest	GMemoryOS.cpp	/^void DummyMemoryOS::solveRequest(MemRequest *r)$/;"	f	class:DummyMemoryOS
sortCrit	CriticalityManager.cpp	/^void CritScheduler::sortCrit(size_t low, size_t upper)$/;"	f	class:CritScheduler
sortProcessPri	CriticalityPredictor.cpp	/^void CriticalityPredictor::sortProcessPri(std::vector<ProcessId*> &procVec,$/;"	f	class:CriticalityPredictor
sortProcessVer	CriticalityPredictor.cpp	/^void CriticalityPredictor::sortProcessVer(std::vector<ProcessId*> &procVec,$/;"	f	class:CriticalityPredictor
sortVer	CriticalityManager.cpp	/^void CritScheduler::sortVer(size_t low, size_t upper)$/;"	f	class:CritScheduler
sortedPVec	CriticalityPredictor.h	/^  std::vector<ProcessId*> sortedPVec;$/;"	m	class:EdgeCPred
spCache	CriticalityPredictor.h	/^  SpawnPredCache *spCache;$/;"	m	class:LocalHybridCPred
spCache	CriticalityPredictor.h	/^  SpawnPredCache *spCache;$/;"	m	class:SpawnOnlyCPred
spaceInInstQueue	Processor.h	/^  signed int spaceInInstQueue;$/;"	m	class:Processor
spaceInInstQueue	SMTProcessor.h	/^  signed int spaceInInstQueue;$/;"	m	class:SMTProcessor
spawn	CriticalityManager.h	/^  void spawn() {$/;"	f	class:CritLifetime
spawn	CriticalityPredictor.h	/^  PredictorCnt spawn;$/;"	m	class:CritPredInfo
spawn	CriticalityPredictor.h	/^  bool spawn;$/;"	m	class:EdgeCPred
spawn	CriticalityPredictor.h	/^  bool spawn;$/;"	m	class:PathCPred
spawn	CriticalityTC.cpp	/^void CriticalityTC::spawn(CriticalityTC &child, int aSid)$/;"	f	class:CriticalityTC
spawnAddr	TaskContext.h	/^  PAddr spawnAddr;$/;"	m	class:TaskContext
spawnAfterSq	CriticalityPredictor.h	/^  int spawnAfterSq;$/;"	m	class:EdgeStateX
spawnCnt	CriticalityPredictor.h	/^  int spawnCnt;$/;"	m	class:EdgeState
spawnCntMax	CriticalityPredictor.h	/^  int spawnCntMax;$/;"	m	class:EdgeStateX
spawnConfidence	CriticalityPredictor.h	/^  int spawnConfidence;$/;"	m	class:EdgeState
spawnContEdge	CriticalityBuilder.cpp	/^void CriticalityBuilder::spawnContEdge(CPNodeGroup *g)$/;"	f	class:CriticalityBuilder
spawnContEdge	CriticalityManager.cpp	/^void CriticalityBase::spawnContEdge(CPNodeGroup *g)$/;"	f	class:CriticalityBase
spawnCrit	CriticalityPredictor.h	/^    bool spawnCrit;$/;"	m	class:OracularCPred::OraclePredInfo
spawnEpoch	Epoch.cpp	/^  Epoch *Epoch::spawnEpoch(void){$/;"	f	class:tls::Epoch
spawnFrom	CriticalityTC.h	/^  CritID spawnFrom;      \/\/ parent$/;"	m	class:CriticalityTC
spawnOverhead	Profile.h	/^  int   spawnOverhead;$/;"	m	class:Profile
spawnPlanted	CriticalityPredictor.h	/^  int spawnPlanted;$/;"	m	class:EdgeStateX
spawnPos	Profile.h	/^    long long spawnPos;         \/\/where it gets spawned$/;"	m	class:Profile::TaskInfo
spawnSuccessor	TaskContext.cpp	/^void TaskContext::spawnSuccessor(Pid_t childPid, PAddr childAddr, int sid)$/;"	f	class:TaskContext
spawnTable	CriticalityPredictor.h	/^  HASH_MAP<ProcessId*,ProcessId*,hash_pointer> spawnTable;$/;"	m	class:CriticalityPredictor
spawnTime	ProcessId.h	/^  Time_t  spawnTime;$/;"	m	class:ProcessId
spawnTo	CriticalityPredictor.h	/^  ProcessId *spawnTo;$/;"	m	class:EdgeCPred
spawnTo	CriticalityPredictor.h	/^  ProcessId *spawnTo;$/;"	m	class:PathCPred
spawnTrain	CriticalityPredictor.h	/^  int spawnTrain;$/;"	m	class:EdgeState
spawnedBy	Profile.h	/^    int spawnedBy;              \/\/parent task ID$/;"	m	class:Profile::TaskInfo
spawns	Profile.h	/^  SLIST<SpawnInfo> spawns;$/;"	m	class:Profile
spec	Epoch.h	/^      enum SpecEnum {Spec, ThreadSafe, GlobalSafe, Committed}  spec : 2;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::SpecEnum
spliceIntoPrevious	Checkpoint.cpp	/^    void spliceIntoPrevious(ThreadExeOrder &prev){$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
spliceIntoPrevious	Checkpoint.cpp	/^  void Checkpoint::ExeOrder::spliceIntoPrevious(ExeOrder &prev){$/;"	f	class:tls::Checkpoint::ExeOrder
spred	GProcessor.h	/^  SPredictor *spred; \/\/ squash predictor $/;"	m	class:GProcessor
sqAfterCnt	CriticalityPredictor.h	/^  int sqAfterCnt;$/;"	m	class:EdgeState
sqCache	CriticalityPredictor.h	/^  SqPredCache *sqCache;$/;"	m	class:SquashOnlyCPred
sqCnt	CriticalityManager.h	/^  int sqCnt;$/;"	m	class:PredData
sqSet	CriticalityManager.h	/^  HASH_MAP<int,int> sqSet;$/;"	m	class:PredData
squash	BulkManager.cpp	/^void BulkManager::squash(Chunk *ck)$/;"	f	class:BulkManager
squash	CPBuilder.cpp	/^void CPBuilder::squash(TaskContext *tc)$/;"	f	class:CPBuilder
squash	CriticalityManager.h	/^  void squash() {$/;"	f	class:CritLifetime
squash	CriticalityPredictor.h	/^  PredictorCnt squash;$/;"	m	class:CritPredInfo
squash	CriticalityPredictor.h	/^  bool squash;$/;"	m	class:EdgeCPred
squash	CriticalityPredictor.h	/^  bool squash;$/;"	m	class:PathCPred
squash	CriticalityTC.cpp	/^void CriticalityTC::squash(CriticalityTC &succ)$/;"	f	class:CriticalityTC
squash	Epoch.cpp	/^  void Epoch::squash(void){$/;"	f	class:tls::Epoch
squash	MemBuffer.h	/^  bool squash;$/;"	m	class:MemBufferEntry
squash	ProcessId.cpp	/^void ProcessId::squash() $/;"	f	class:ProcessId
squashCnt	CriticalityPredictor.h	/^  int squashCnt;$/;"	m	class:EdgeState
squashCntMax	CriticalityPredictor.h	/^  int squashCntMax;$/;"	m	class:EdgeStateX
squashConfidence	CriticalityPredictor.h	/^  int squashConfidence;$/;"	m	class:EdgeState
squashCrit	CriticalityPredictor.h	/^    bool squashCrit;$/;"	m	class:OracularCPred::OraclePredInfo
squashCritCnt	CriticalityPredictor.h	/^  int squashCritCnt;$/;"	m	class:EdgeState
squashEdgePresent	CriticalityBuilder.cpp	/^bool CriticalityBuilder::squashEdgePresent(CPNodeGroup *earlier, CPNodeGroup *later)$/;"	f	class:CriticalityBuilder
squashH	CriticalityManager.h	/^  GStatsHist squashH;$/;"	m	class:PredData
squashH	CriticalityPredictor.h	/^  HASH_MAP<int,PredictorCnt> squashH; \/\/index is squasher$/;"	m	class:CritPredInfo
squashL2Misses	TaskContext.cpp	/^GStatsCntr *TaskContext::squashL2Misses=0;$/;"	m	class:TaskContext	file:
squashL2Misses	TaskContext.h	/^  static GStatsCntr *squashL2Misses;$/;"	m	class:TaskContext
squashLikely	CriticalityPredictor.h	/^  int squashLikely;$/;"	m	class:EdgeStateX
squashLocal	Epoch.cpp	/^  void Epoch::squashLocal(void){$/;"	f	class:tls::Epoch
squashPlanted	CriticalityPredictor.h	/^  int squashPlanted;$/;"	m	class:EdgeStateX
squashPred	CriticalityManager.h	/^  CGPredictor *squashPred;$/;"	m	class:CritScheduler
squashTable	CriticalityPredictor.h	/^  HASH_MAP<ProcessId*,ProcessId*,hash_pointer> squashTable;$/;"	m	class:CriticalityPredictor
squashTo	CriticalityPredictor.h	/^  ProcessId *squashTo;$/;"	m	class:EdgeCPred
squashTo	CriticalityPredictor.h	/^  ProcessId *squashTo;$/;"	m	class:PathCPred
squashTrain	CriticalityPredictor.h	/^  int squashTrain;$/;"	m	class:EdgeState
srcAnomalyFound	Epoch.h	/^    void srcAnomalyFound(void){$/;"	f	class:tls::Epoch
srcRaceFound	Epoch.h	/^    void srcRaceFound(void){$/;"	f	class:tls::Epoch
stTime	OSSim.h	/^  timeval stTime;$/;"	m	class:OSSim
stack	BPred.h	/^  InstID *stack;$/;"	m	class:BPRas
stackData	DInst.h	/^  bool stackData;$/;"	m	class:DInst
stagingWin	CriticalityBuilder.h	/^  GroupList stagingWin; \/\/window of tasks waiting for resource edge$/;"	m	class:CriticalityBuilder
stagingWin	CriticalityManager.h	/^  GroupList stagingWin; \/\/window of tasks waiting for resource edge$/;"	m	class:CriticalityBase
stall	CavaManager.cpp	/^void CavaManager::stall(DInst *dinst)$/;"	f	class:CavaManager
stallProcessor	OSSim.h	/^  void stallProcessor(CPU_t cpu, int cycles) { cpus.stallProcessor(cpu, cycles); }$/;"	f	class:OSSim
stallProcessor	RunningProcs.cpp	/^void RunningProcs::stallProcessor(CPU_t cpu, int cycles)$/;"	f	class:RunningProcs
stallUntil	GProcessor.h	/^  Time_t stallUntil; \/\/stall the cpu until$/;"	m	class:GProcessor
start	BulkManager.h	/^  static void start(){$/;"	f	class:BulkLogger
start	CriticalityTC.cpp	/^void CriticalityTC::start(CPU_t i)$/;"	f	class:CriticalityTC
startAddr	Profile.h	/^    long startAddr;$/;"	m	class:Profile::TaskInfo
startBPHistory	TaskContext.h	/^  BPred::HistoryType startBPHistory; \/\/ Original history used$/;"	m	class:TaskContext
startCrit	CriticalityPredictor.h	/^    bool startCrit;$/;"	m	class:OracularCPred::OraclePredInfo
startInst	Profile.h	/^  long long startInst;$/;"	m	class:Profile
startLogging	BulkManager.cpp	/^void BasicLogger::startLogging()$/;"	f	class:BasicLogger
startLogging	BulkManager.h	/^  void startLogging(){};$/;"	f	class:EmptyLogger
startMReq	CavaManager.cpp	/^void CavaManager::startMReq(MemRequest *mreq) $/;"	f	class:CavaManager
startOrderPos	Checkpoint.cpp	/^    ExeOrderList::iterator startOrderPos;$/;"	m	class:tls::Checkpoint::ExeOrder::ThreadExeOrder	file:
startPos	Profile.h	/^    long long startPos;         \/\/where it starts$/;"	m	class:Profile::TaskInfo
startProcessor	OSSim.h	/^  void startProcessor(CPU_t id) {$/;"	f	class:OSSim
startProcessor	RunningProcs.h	/^  void startProcessor(CPU_t cpu) {$/;"	f	class:RunningProcs
startTime	CriticalityTC.h	/^  Time_t startTime;$/;"	m	class:SubtaskContext
startTime	ProcessId.h	/^  Time_t  startTime;$/;"	m	class:ProcessId
started	Profile.h	/^  bool started;$/;"	m	class:Profile
statAddFillerCnt	CriticalityPredictor.h	/^  GStatsCntr statAddFillerCnt;$/;"	m	class:OracularCPred
statAfterSq	CriticalityManager.h	/^  GStatsCntr statAfterSq;$/;"	m	class:CriticalityManager
statAfterSquash	CriticalityBuilder.h	/^  GStatsCntr statAfterSquash;$/;"	m	class:CriticalityBuilderIface
statBuilderIfaceUpdatePredictors	CriticalityBuilder.h	/^  GStatsCntr statBuilderIfaceUpdatePredictors;$/;"	m	class:CriticalityBuilderIface
statBuilderIfaceUpdatePredictorsNoParent	CriticalityBuilder.h	/^  GStatsCntr statBuilderIfaceUpdatePredictorsNoParent;$/;"	m	class:CriticalityBuilderIface
statCPUKilledInsts	CriticalityTC.h	/^  static GStatsHist statCPUKilledInsts;$/;"	m	class:CriticalityTC
statCPUSquashedInsts	CriticalityTC.h	/^  static GStatsHist statCPUSquashedInsts;$/;"	m	class:CriticalityTC
statChooseLSpecCnt	CriticalityPredictor.h	/^  GStatsCntr statChooseLSpecCnt;$/;"	m	class:OracularCPred
statChooseNonRestartedCnt	CriticalityPredictor.h	/^  GStatsCntr statChooseNonRestartedCnt;$/;"	m	class:OracularCPred
statChooseNotYetRestartedCnt	CriticalityPredictor.h	/^  GStatsCntr statChooseNotYetRestartedCnt;$/;"	m	class:OracularCPred
statChooseRestartedCnt	CriticalityPredictor.h	/^  GStatsCntr statChooseRestartedCnt;$/;"	m	class:OracularCPred
statCommitPri	CriticalityController.h	/^  GStatsHist statCommitPri;$/;"	m	class:CriticalityController
statCritCPUHist	CriticalityBuilder.h	/^  GStatsHist statCritCPUHist;$/;"	m	class:CriticalityBuilder
statCritCPUHist	CriticalityManager.h	/^  GStatsHist statCritCPUHist;$/;"	m	class:CriticalityBase
statCritInsts	CriticalityBuilder.h	/^  GStatsCntr statCritInsts;$/;"	m	class:CriticalityBuilder
statCritInsts	CriticalityManager.h	/^  GStatsCntr statCritInsts;$/;"	m	class:CriticalityBase
statCritPred	CriticalityBuilder.h	/^  GStatsHist statCritPred;$/;"	m	class:CriticalityBuilder
statCritPred	CriticalityManager.h	/^  GStatsHist statCritPred;$/;"	m	class:CriticalityBase
statEofCnt	CriticalityPredictor.h	/^  GStatsCntr statEofCnt;$/;"	m	class:OracularCPred
statFoundCritOptCnt	CriticalityPredictor.h	/^  GStatsCntr statFoundCritOptCnt;$/;"	m	class:OracularCPred
statFoundKilledPlantedPred	CriticalityBuilder.h	/^  GStatsCntr statFoundKilledPlantedPred;$/;"	m	class:CriticalityBuilder
statFoundPlantedPred	CriticalityBuilder.h	/^  GStatsCntr statFoundPlantedPred;$/;"	m	class:CriticalityBuilder
statFoundPlantedPred2	CriticalityBuilder.h	/^  GStatsCntr statFoundPlantedPred2;$/;"	m	class:CriticalityBuilder
statFoundPredCrit	CriticalityPredictor.h	/^  GStatsCntr statFoundPredCrit;$/;"	m	class:EdgeCPred
statFoundSpawnPredCrit	CriticalityPredictor.h	/^  GStatsCntr statFoundSpawnPredCrit;$/;"	m	class:EdgeCPred
statHyPredAccess	CriticalityPredictor.h	/^  GStatsCntr statHyPredAccess;$/;"	m	class:LocalHybridCPred
statHyPredHit	CriticalityPredictor.h	/^  GStatsCntr statHyPredHit;$/;"	m	class:LocalHybridCPred
statHyPredTrainCnt	CriticalityPredictor.h	/^  GStatsCntr statHyPredTrainCnt;$/;"	m	class:LocalHybridCPred
statHySafeMoved	CriticalityPredictor.h	/^  GStatsCntr statHySafeMoved;$/;"	m	class:LocalHybridCPred
statKillCPUHist	CriticalityBuilder.h	/^  GStatsHist statKillCPUHist;$/;"	m	class:CriticalityBuilder
statKillCPUHist	CriticalityManager.h	/^  GStatsHist statKillCPUHist;$/;"	m	class:CriticalityBase
statKilledPri	CriticalityController.h	/^  GStatsHist statKilledPri;$/;"	m	class:CriticalityController
statLSpecNullCnt	CriticalityPredictor.h	/^  GStatsCntr statLSpecNullCnt;$/;"	m	class:OracularCPred
statLowerConfCrit	CriticalityPredictor.h	/^  GStatsCntr statLowerConfCrit;$/;"	m	class:EdgeCPred
statMap	CriticalityPredictor.h	/^  HASH_MAP<int,EdgeStateX*> statMap;$/;"	m	class:EdgeStateStat
statNonCritCPUHist	CriticalityBuilder.h	/^  GStatsHist statNonCritCPUHist;$/;"	m	class:CriticalityBuilder
statNonCritCPUHist	CriticalityManager.h	/^  GStatsHist statNonCritCPUHist;$/;"	m	class:CriticalityBase
statNonCritInsts	CriticalityBuilder.h	/^  GStatsCntr statNonCritInsts;$/;"	m	class:CriticalityBuilder
statNonCritInsts	CriticalityManager.h	/^  GStatsCntr statNonCritInsts;$/;"	m	class:CriticalityBase
statNonCritPred	CriticalityBuilder.h	/^  GStatsHist statNonCritPred;$/;"	m	class:CriticalityBuilder
statNonCritPred	CriticalityManager.h	/^  GStatsHist statNonCritPred;$/;"	m	class:CriticalityBase
statNonSqTasksH	CriticalityController.h	/^  GStatsHist statNonSqTasksH;$/;"	m	class:CriticalityController
statNonSqTasksH	CriticalityManager.h	/^  GStatsHist statNonSqTasksH;$/;"	m	class:CritScheduler
statPlantPredCrit	CriticalityPredictor.h	/^  GStatsCntr statPlantPredCrit;$/;"	m	class:EdgeCPred
statPlantSpawnPredCrit	CriticalityPredictor.h	/^  GStatsCntr statPlantSpawnPredCrit;$/;"	m	class:EdgeCPred
statPredCritCritInsts	CriticalityBuilder.h	/^  GStatsCntr statPredCritCritInsts;$/;"	m	class:CriticalityBuilder
statPredCritNonCritInsts	CriticalityBuilder.h	/^  GStatsCntr statPredCritNonCritInsts;$/;"	m	class:CriticalityBuilder
statPredNonCritCritInsts	CriticalityBuilder.h	/^  GStatsCntr statPredNonCritCritInsts;$/;"	m	class:CriticalityBuilder
statPredNonCritNonCritInsts	CriticalityBuilder.h	/^  GStatsCntr statPredNonCritNonCritInsts;$/;"	m	class:CriticalityBuilder
statPredResource	CriticalityController.h	/^  GStatsCntr statPredResource;$/;"	m	class:CriticalityController
statPredResource	CriticalityManager.h	/^  GStatsCntr statPredResource;$/;"	m	class:CriticalityManager
statPredictAction	CriticalityPredictor.h	/^  GStatsCntr statPredictAction;$/;"	m	class:EdgeCPred
statPredictActiveChainValid	CriticalityPredictor.h	/^  GStatsCntr statPredictActiveChainValid;$/;"	m	class:EdgeCPred
statPredictAnalyzeEventList	CriticalityPredictor.h	/^  GStatsCntr statPredictAnalyzeEventList; \/\/***$/;"	m	class:EdgeCPred
statPredictCPFinishEvent	CriticalityPredictor.h	/^  GStatsCntr statPredictCPFinishEvent;$/;"	m	class:EdgeCPred
statPredictCPSpawnEvent	CriticalityPredictor.h	/^  GStatsCntr statPredictCPSpawnEvent;$/;"	m	class:EdgeCPred
statPredictCPSquashEvent	CriticalityPredictor.h	/^  GStatsCntr statPredictCPSquashEvent;$/;"	m	class:EdgeCPred
statPredictCalled	CriticalityPredictor.h	/^  GStatsCntr statPredictCalled;$/;"	m	class:EdgeCPred
statPredictCheckSpawn	CriticalityPredictor.h	/^  GStatsCntr statPredictCheckSpawn;$/;"	m	class:EdgeCPred
statPredictCheckSquash	CriticalityPredictor.h	/^  GStatsCntr statPredictCheckSquash;$/;"	m	class:EdgeCPred
statPredictChooseBestChain	CriticalityPredictor.h	/^  GStatsCntr statPredictChooseBestChain;$/;"	m	class:EdgeCPred
statPredictChooseBestChainNewHead	CriticalityPredictor.h	/^  GStatsCntr statPredictChooseBestChainNewHead;$/;"	m	class:EdgeCPred
statPredictChooseCurrent	CriticalityPredictor.h	/^  GStatsCntr statPredictChooseCurrent;$/;"	m	class:EdgeCPred
statPredictCurrentSquashLikely	CriticalityPredictor.h	/^  GStatsCntr statPredictCurrentSquashLikely;$/;"	m	class:EdgeCPred
statPredictFollowSpawn	CriticalityPredictor.h	/^  GStatsCntr statPredictFollowSpawn;$/;"	m	class:EdgeCPred
statPredictFollowSquash	CriticalityPredictor.h	/^  GStatsCntr statPredictFollowSquash;$/;"	m	class:EdgeCPred
statPredictFoundCurrent	CriticalityPredictor.h	/^  GStatsCntr statPredictFoundCurrent;$/;"	m	class:EdgeCPred
statPredictFoundPrediction	CriticalityPredictor.h	/^  GStatsCntr statPredictFoundPrediction;$/;"	m	class:EdgeCPred
statPredictLikelyFollowEdge	CriticalityPredictor.h	/^  GStatsCntr statPredictLikelyFollowEdge;$/;"	m	class:EdgeCPred
statPredictLikelySquash	CriticalityPredictor.h	/^  GStatsCntr statPredictLikelySquash;$/;"	m	class:EdgeCPred
statPredictProcVecEmpty	CriticalityPredictor.h	/^  GStatsCntr statPredictProcVecEmpty;$/;"	m	class:EdgeCPred
statPredictSpCauseSquash	CriticalityPredictor.h	/^  GStatsCntr statPredictSpCauseSquash;$/;"	m	class:EdgeCPred
statPredictSpEventSquashLikely	CriticalityPredictor.h	/^  GStatsCntr statPredictSpEventSquashLikely;$/;"	m	class:EdgeCPred
statPredictSpLikelySquash	CriticalityPredictor.h	/^  GStatsCntr statPredictSpLikelySquash;$/;"	m	class:EdgeCPred
statPredictSpLikelySquashCalled	CriticalityPredictor.h	/^  GStatsCntr statPredictSpLikelySquashCalled;$/;"	m	class:EdgeCPred
statPredictSpLikelySquashLU	CriticalityPredictor.h	/^  GStatsCntr statPredictSpLikelySquashLU;$/;"	m	class:EdgeCPred
statPredictSpLikelySquashLUHit	CriticalityPredictor.h	/^  GStatsCntr statPredictSpLikelySquashLUHit;$/;"	m	class:EdgeCPred
statPredictSpawnTrain	CriticalityPredictor.h	/^  GStatsCntr statPredictSpawnTrain;$/;"	m	class:EdgeCPred
statPredictSqLikelyAddChain	CriticalityPredictor.h	/^  GStatsCntr statPredictSqLikelyAddChain;$/;"	m	class:EdgeCPred
statPredictSquashTrain	CriticalityPredictor.h	/^  GStatsCntr statPredictSquashTrain;$/;"	m	class:EdgeCPred
statPredictUpdateLeastSpec	CriticalityPredictor.h	/^  GStatsCntr statPredictUpdateLeastSpec;$/;"	m	class:EdgeCPred
statRaiseConfCrit	CriticalityPredictor.h	/^  GStatsCntr statRaiseConfCrit;$/;"	m	class:EdgeCPred
statRestartPri	CriticalityController.h	/^  GStatsHist statRestartPri;$/;"	m	class:CriticalityController
statSafeCritInsts	CriticalityBuilder.h	/^  GStatsCntr statSafeCritInsts;$/;"	m	class:CriticalityBuilder
statSafeCritInsts	CriticalityManager.h	/^  GStatsCntr statSafeCritInsts;$/;"	m	class:CriticalityBase
statSafeMoved	CriticalityPredictor.h	/^  GStatsCntr statSafeMoved;$/;"	m	class:SpawnOnlyCPred
statSafeMoved	CriticalityPredictor.h	/^  GStatsCntr statSafeMoved;$/;"	m	class:SquashOnlyCPred
statSafeNonCritInsts	CriticalityBuilder.h	/^  GStatsCntr statSafeNonCritInsts;$/;"	m	class:CriticalityBuilder
statSafeNonCritInsts	CriticalityManager.h	/^  GStatsCntr statSafeNonCritInsts;$/;"	m	class:CriticalityBase
statSidFreq	CriticalityBuilder.h	/^  GStatsHist statSidFreq;$/;"	m	class:CriticalityBuilderIface
statSidWeight	CriticalityBuilder.h	/^  GStatsHist statSidWeight;$/;"	m	class:CriticalityBuilder
statSimPointConfigH	CriticalityController.h	/^  GStatsHist statSimPointConfigH;$/;"	m	class:CriticalityController
statSpPredAccess	CriticalityPredictor.h	/^  GStatsCntr statSpPredAccess;$/;"	m	class:SpawnOnlyCPred
statSpPredHit	CriticalityPredictor.h	/^  GStatsCntr statSpPredHit;$/;"	m	class:SpawnOnlyCPred
statSpPredTrainCnt	CriticalityPredictor.h	/^  GStatsCntr statSpPredTrainCnt;$/;"	m	class:SpawnOnlyCPred
statSpawnEdge	CriticalityBuilder.h	/^  GStatsCntr statSpawnEdge;$/;"	m	class:CriticalityBuilder
statSpawnEdge	CriticalityManager.h	/^  GStatsCntr statSpawnEdge;$/;"	m	class:CriticalityBase
statSpawnHit	CriticalityPredictor.h	/^  GStatsCntr statSpawnHit;$/;"	m	class:EdgeCPred
statSpawnLU	CriticalityPredictor.h	/^  GStatsCntr statSpawnLU;$/;"	m	class:EdgeCPred
statSqPredAccess	CriticalityPredictor.h	/^  GStatsCntr statSqPredAccess;$/;"	m	class:SquashOnlyCPred
statSqPredHit	CriticalityPredictor.h	/^  GStatsCntr statSqPredHit;$/;"	m	class:SquashOnlyCPred
statSqPredTrainCnt	CriticalityPredictor.h	/^  GStatsCntr statSqPredTrainCnt;$/;"	m	class:SquashOnlyCPred
statSquCPUHist	CriticalityBuilder.h	/^  GStatsHist statSquCPUHist;$/;"	m	class:CriticalityBuilder
statSquCPUHist	CriticalityManager.h	/^  GStatsHist statSquCPUHist;$/;"	m	class:CriticalityBase
statSquashEdge	CriticalityBuilder.h	/^  GStatsCntr statSquashEdge;$/;"	m	class:CriticalityBuilder
statSquashEdge	CriticalityManager.h	/^  GStatsCntr statSquashEdge;$/;"	m	class:CriticalityBase
statSquashHit	CriticalityPredictor.h	/^  GStatsCntr statSquashHit;$/;"	m	class:EdgeCPred
statSquashLU	CriticalityPredictor.h	/^  GStatsCntr statSquashLU;$/;"	m	class:EdgeCPred
statSquashLikely	CriticalityPredictor.h	/^  GStatsCntr statSquashLikely;$/;"	m	class:EdgeCPred
statSquashRare	CriticalityBuilder.h	/^  GStatsCntr statSquashRare;$/;"	m	class:CriticalityBuilder
statSquashRare	CriticalityManager.h	/^  GStatsCntr statSquashRare;$/;"	m	class:CriticalityBase
statTaskCritHist	CriticalityBuilder.h	/^  HASH_MAP<int,GStatsHist*> statTaskCritHist;$/;"	m	class:CriticalityBuilder
statTaskCritHist	CriticalityManager.h	/^  HASH_MAP<int,GStatsHist*> statTaskCritHist;$/;"	m	class:CriticalityBase
state	ProcessId.h	/^  ProcessIdState state;$/;"	m	class:ProcessId
staticConstructor	Checkpoint.cpp	/^  void Checkpoint::staticConstructor(void){$/;"	f	class:tls::Checkpoint
staticConstructor	Epoch.cpp	/^  void Epoch::staticConstructor(void){$/;"	f	class:tls::Epoch
staticDestructor	Checkpoint.cpp	/^  void Checkpoint::staticDestructor(void){$/;"	f	class:tls::Checkpoint
staticDestructor	Epoch.cpp	/^  void Epoch::staticDestructor(void){$/;"	f	class:tls::Epoch
staticDestructor	Epoch.h	/^      static void staticDestructor(void){$/;"	f	class:tls::Epoch::BlockVersions
staticHoistThrd	Profile.h	/^  int   staticHoistThrd;$/;"	m	class:Profile
staticId	TaskContext.h	/^  int   staticId;  \/\/ Static Task Id$/;"	m	class:TaskContext
stats	ProcessId.h	/^  Stats   stats;$/;"	m	class:ProcessId
stayInLoop	RunningProcs.h	/^  bool stayInLoop;$/;"	m	class:RunningProcs
stldForwarding	LDSTQ.h	/^  GStatsCntr stldForwarding;$/;"	m	class:LDSTQ
stldViolations	LDSTQ.h	/^  GStatsCntr stldViolations;$/;"	m	class:LDSTQ
stop	BulkManager.h	/^  static void stop(){$/;"	f	class:BulkLogger
stop	CriticalityTC.cpp	/^void CriticalityTC::stop(CPU_t i)$/;"	f	class:CriticalityTC
stop	OSSim.cpp	/^void OSSim::stop(Pid_t pid)$/;"	f	class:OSSim
stopInst	Profile.h	/^  long long stopInst;$/;"	m	class:Profile
stopLogging	BulkManager.cpp	/^void BasicLogger::stopLogging()$/;"	f	class:BasicLogger
stopLogging	BulkManager.h	/^  void stopLogging(){};$/;"	f	class:EmptyLogger
stopProcessor	OSSim.h	/^  void stopProcessor(CPU_t id) {$/;"	f	class:OSSim
stopProcessor	RunningProcs.h	/^  void stopProcessor(CPU_t cpu) {$/;"	f	class:RunningProcs
stopSimulation	OSSim.h	/^  void stopSimulation() { cpus.finishWorkNow(); }$/;"	f	class:OSSim
stoppedForAnalysis	Epoch.cpp	/^  EpochList Epoch::stoppedForAnalysis;$/;"	m	class:tls::Epoch	file:
stoppedForAnalysis	Epoch.h	/^    static EpochList stoppedForAnalysis;$/;"	m	class:tls::Epoch
storeCompleted	Resource.cpp	/^void FUStore::storeCompleted()$/;"	f	class:FUStore
storeGloballyPerformed	DInst.h	/^  bool storeGloballyPerformed;$/;"	m	class:DInst
storeLocallyPerformed	LDSTBuffer.h	/^  static void storeLocallyPerformed(DInst *dinst) {$/;"	f	class:LDSTBuffer
storeMap	VPred.h	/^  StoreMap storeMap;$/;"	m	class:FWPred
storeQueue	VPred.h	/^  StoreQueue storeQueue;$/;"	m	class:FWPred
storeQueueSize	VPred.h	/^  const unsigned storeQueueSize;$/;"	m	class:FWPred
storeRetired	DInst.h	/^  bool storeRetired;$/;"	m	class:DInst
storeSent	DInst.h	/^  bool storeSent;$/;"	m	class:DInst
storeSent	Resource.h	/^  void storeSent() { nOutsStores++; }$/;"	f	class:FUStore
storeStuckAtFence	Resource.h	/^  GStatsHist   storeStuckAtFence;$/;"	m	class:FUStore
stores	LDSTBuffer.cpp	/^LDSTBuffer::EntryType      LDSTBuffer::stores;$/;"	m	class:LDSTBuffer	file:
stores	LDSTBuffer.h	/^  static EntryType stores;$/;"	m	class:LDSTBuffer
stqCheckEnergy	Resource.h	/^  GStatsEnergy *stqCheckEnergy; \/\/ Check for data dependence$/;"	m	class:MemResource
stqNotUsed	Resource.h	/^  GStatsAvg   stqNotUsed;$/;"	m	class:FUStore
stqRdWrEnergy	Resource.h	/^  GStatsEnergy *stqRdWrEnergy;  \/\/ Read-write operations (insert, exec, retire)$/;"	m	class:MemResource
streamMap	CriticalityPredictor.h	/^  HASH_SET<ProcessId*,hash_pointer> streamMap;$/;"	m	class:EdgeCPred
stride	MemAnalyzer.h	/^    ulong stride;$/;"	m	class:StrideAP::PrefState
stride	ValueTable.h	/^    int stride;$/;"	m	class:ValueTable::PredEntry
ststViolations	LDSTQ.h	/^  GStatsCntr ststViolations;$/;"	m	class:LDSTQ
subLVID	DInst.h	/^  SubLVIDType subLVID;$/;"	m	class:DInst
subLVID	FetchEngine.h	/^  SubLVIDType subLVID;$/;"	m	class:FetchEngine
subTC	CriticalityTC.h	/^  size_t subTC;$/;"	m	class:CriticalityTC
subThreadLevel	TaskContext.h	/^  int subThreadLevel;$/;"	m	class:TaskContext
subtaskPool	CriticalityTC.h	/^  static pool<SubtaskContext,true> subtaskPool;$/;"	m	class:SubtaskContext
subtaskVec	CriticalityTC.h	/^  std::vector< SubtaskContext* > subtaskVec;$/;"	m	class:CriticalityTC
succ	Epoch.h	/^      enum SuccEnum {NotSucceeded, WasSucceeded}               succ : 1;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::SuccEnum
succeed	Epoch.h	/^    void succeed(const VClock &other){$/;"	f	class:tls::VClock
succeeded	Epoch.cpp	/^  void Epoch::succeeded(Epoch *succEpoch){$/;"	f	class:tls::Epoch
sumCache	CriticalityPredictor.h	/^  EdgePredCache *sumCache;$/;"	m	class:EdgeCPred
suspend	OSSim.cpp	/^void OSSim::suspend(Pid_t pid)$/;"	f	class:OSSim
suspendTask	TaskContext.cpp	/^void TaskContext::suspendTask(bool earlyAwake)$/;"	f	class:TaskContext
suspendedCounter	ProcessId.h	/^  int suspendedCounter;$/;"	m	class:ProcessId
switchIn	BPred.cpp	/^void BP2BcgSkew::switchIn(Pid_t pid)$/;"	f	class:BP2BcgSkew
switchIn	BPred.cpp	/^void BP2bit::switchIn(Pid_t pid)$/;"	f	class:BP2bit
switchIn	BPred.cpp	/^void BP2level::switchIn(Pid_t pid)$/;"	f	class:BP2level
switchIn	BPred.cpp	/^void BPBTB::switchIn(Pid_t pid)$/;"	f	class:BPBTB
switchIn	BPred.cpp	/^void BPCRap::switchIn(Pid_t pid)$/;"	f	class:BPCRap
switchIn	BPred.cpp	/^void BPHybrid::switchIn(Pid_t pid)$/;"	f	class:BPHybrid
switchIn	BPred.cpp	/^void BPNotTaken::switchIn(Pid_t pid)$/;"	f	class:BPNotTaken
switchIn	BPred.cpp	/^void BPOgehl::switchIn(Pid_t pid)$/;"	f	class:BPOgehl
switchIn	BPred.cpp	/^void BPOracle::switchIn(Pid_t pid)$/;"	f	class:BPOracle
switchIn	BPred.cpp	/^void BPRap::switchIn(Pid_t pid)$/;"	f	class:BPRap
switchIn	BPred.cpp	/^void BPRas::switchIn(Pid_t pid)$/;"	f	class:BPRas
switchIn	BPred.cpp	/^void BPStatic::switchIn(Pid_t pid)$/;"	f	class:BPStatic
switchIn	BPred.cpp	/^void BPTaken::switchIn(Pid_t pid)$/;"	f	class:BPTaken
switchIn	BPred.cpp	/^void BPyags::switchIn(Pid_t pid)$/;"	f	class:BPyags
switchIn	BPred.h	/^  void switchIn(Pid_t pid) {$/;"	f	class:BPredictor
switchIn	FetchEngine.cpp	/^void FetchEngine::switchIn(Pid_t i)$/;"	f	class:FetchEngine
switchIn	ProcessId.h	/^  void switchIn(CPU_t nCPU) {$/;"	f	class:ProcessId
switchIn	Processor.cpp	/^void Processor::switchIn(Pid_t pid)$/;"	f	class:Processor
switchIn	RunningProcs.cpp	/^void RunningProcs::switchIn(CPU_t id, ProcessId *proc)$/;"	f	class:RunningProcs
switchIn	SMTProcessor.cpp	/^void SMTProcessor::switchIn(Pid_t pid)$/;"	f	class:SMTProcessor
switchOut	BPred.cpp	/^void BP2BcgSkew::switchOut(Pid_t pid)$/;"	f	class:BP2BcgSkew
switchOut	BPred.cpp	/^void BP2bit::switchOut(Pid_t pid)$/;"	f	class:BP2bit
switchOut	BPred.cpp	/^void BP2level::switchOut(Pid_t pid)$/;"	f	class:BP2level
switchOut	BPred.cpp	/^void BPBTB::switchOut(Pid_t pid)$/;"	f	class:BPBTB
switchOut	BPred.cpp	/^void BPCRap::switchOut(Pid_t pid)$/;"	f	class:BPCRap
switchOut	BPred.cpp	/^void BPHybrid::switchOut(Pid_t pid)$/;"	f	class:BPHybrid
switchOut	BPred.cpp	/^void BPNotTaken::switchOut(Pid_t pid)$/;"	f	class:BPNotTaken
switchOut	BPred.cpp	/^void BPOgehl::switchOut(Pid_t pid)$/;"	f	class:BPOgehl
switchOut	BPred.cpp	/^void BPOracle::switchOut(Pid_t pid)$/;"	f	class:BPOracle
switchOut	BPred.cpp	/^void BPRap::switchOut(Pid_t pid)$/;"	f	class:BPRap
switchOut	BPred.cpp	/^void BPRas::switchOut(Pid_t pid)$/;"	f	class:BPRas
switchOut	BPred.cpp	/^void BPStatic::switchOut(Pid_t pid)$/;"	f	class:BPStatic
switchOut	BPred.cpp	/^void BPTaken::switchOut(Pid_t pid)$/;"	f	class:BPTaken
switchOut	BPred.cpp	/^void BPyags::switchOut(Pid_t pid)$/;"	f	class:BPyags
switchOut	BPred.h	/^  void switchOut(Pid_t pid) {$/;"	f	class:BPredictor
switchOut	FetchEngine.cpp	/^void FetchEngine::switchOut(Pid_t i)$/;"	f	class:FetchEngine
switchOut	OSSim.h	/^  void switchOut(CPU_t id, ProcessId *procId) { cpus.switchOut(id, procId); }$/;"	f	class:OSSim
switchOut	ProcessId.h	/^  void switchOut(long long nGradInsts, long long nWPathInsts) {$/;"	f	class:ProcessId
switchOut	Processor.cpp	/^void Processor::switchOut(Pid_t pid)$/;"	f	class:Processor
switchOut	RunningProcs.cpp	/^void RunningProcs::switchOut(CPU_t id, ProcessId *proc)$/;"	f	class:RunningProcs
switchOut	SMTProcessor.cpp	/^void SMTProcessor::switchOut(Pid_t pid)$/;"	f	class:SMTProcessor
switchedOut	CriticalityTC.h	/^  bool switchedOut;$/;"	m	class:CriticalityTC
symbolicName	MemObj.h	/^  const char *symbolicName;$/;"	m	class:MemObj
sync	CriticalityManager.h	/^  CritLifetime sync;$/;"	m	class:NonCritLifetime
sync	Epoch.h	/^	{PreAccess, Acquire, Access, Release, PostAccess}      sync : 3;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::SyncEnum
syncBecomeSafe	CriticalityTC.h	/^  bool   syncBecomeSafe;$/;"	m	class:SubtaskContext
syncBecomeSafe	TaskContext.cpp	/^void TaskContext::syncBecomeSafe(bool earlyAwake)$/;"	f	class:TaskContext
syncClockDelta	Epoch.cpp	/^  ClockValue syncClockDelta;$/;"	v
syncSafe	CriticalityTC.cpp	/^void CriticalityTC::syncSafe()$/;"	f	class:CriticalityTC
syncSafeTime	CriticalityTC.h	/^  Time_t syncSafeTime;$/;"	m	class:SubtaskContext
syncSafeUntilRestart	TaskContext.cpp	/^void TaskContext::syncSafeUntilRestart()$/;"	f	class:TaskContext
syncUntilRestart	TaskContext.h	/^  bool syncUntilRestart;$/;"	m	class:TaskContext
sysCallLog	Checkpoint.cpp	/^    SysCallLog sysCallLog; \/\/ System call record during this epoch$/;"	m	struct:tls::ExeOrderEntry	file:
sysCallLog	Epoch.h	/^    SysCallLog sysCallLog;$/;"	m	class:tls::Epoch
sysCallLogPos	Epoch.h	/^    SysCallLog::iterator sysCallLogPos;$/;"	m	class:tls::Epoch
sysconf	ProcessId.cpp	/^bool ProcessId::sysconf(long flags)$/;"	f	class:ProcessId
table	BPred.h	/^  SCTable table;$/;"	m	class:BP2bit
table	BPred.h	/^  SCTable table;$/;"	m	class:BPyags
table	CPBuilder.h	/^    CPPred table;$/;"	m	class:CPBuilder
table	CPPred.h	/^  CriticalityTable *table;$/;"	m	class:CPPred
table	GProcessor.h	/^  SCTable table;$/;"	m	class:SBimodal
table	GProcessor.h	/^  SCTable table;$/;"	m	class:STagged
table	VPred.h	/^  SCTable table;$/;"	m	class:ConfidenceEstimator
table	VPred.h	/^  SCTable table;$/;"	m	class:Selector
table	ValueTable.cpp	/^ValueTable::PredEntry::VTable ValueTable::PredEntry::table;$/;"	m	class:ValueTable::PredEntry	file:
table	ValueTable.h	/^    static VTable table;$/;"	m	class:ValueTable::PredEntry
tableIpc	GProcessor.h	/^  SCTable tableIpc;$/;"	m	class:SHybrid
tableMask	GProcessor.h	/^  int tableMask;$/;"	m	class:STagged
tableMem	GProcessor.h	/^  SCTable tableMem;$/;"	m	class:SHybrid
tableSel	GProcessor.h	/^  SCTable tableSel;$/;"	m	class:SHybrid
tableSize	GProcessor.h	/^  int tableSize;$/;"	m	class:STagged
tableSize	MemAnalyzer.h	/^  const int tableSize;$/;"	m	class:MarkovAP
tag	GProcessor.h	/^  uchar *tag;$/;"	m	class:STagged
tag	HVersion.h	/^      PredEntryTag tag;$/;"	m	class:HVersion::IDP::PredEntry
tagMask	GProcessor.h	/^  int tagMask;$/;"	m	class:STagged
takeWriteSnapshot	MemBuffer.h	/^  void takeWriteSnapshot() { writeSnapshot = writeSet; }$/;"	f	class:MemBuffer
target	BPred.h	/^    InstID target;$/;"	m	class:BPRap::PathHistoryEntry
taskEntries	TaskContext.cpp	/^TaskContext::TaskEntriesType TaskContext::taskEntries;$/;"	m	class:TaskContext	file:
taskEntries	TaskContext.h	/^  static TaskEntriesType taskEntries;$/;"	m	class:TaskContext
taskHandler	TaskHandler.cpp	/^TaskHandler *taskHandler=0;$/;"	v
taskID	Profile.h	/^    int taskID;       \/\/which task it belongs to$/;"	m	class:Profile::WriteInfo
taskID	Profile.h	/^    int taskID;$/;"	m	class:Profile::SpawnInfo
taskSizeThrd	Profile.h	/^  int   taskSizeThrd;$/;"	m	class:Profile
tasks	Profile.cpp	/^Profile::TaskInfoType  Profile::tasks;$/;"	m	class:Profile	file:
tasks	Profile.h	/^  static TaskInfoType tasks;$/;"	m	class:Profile
tc	ASVersion.h	/^  TaskContext *tc;$/;"	m	class:HVersion
tc	CPBuilder.h	/^      TaskContext *tc;$/;"	m	struct:CPBuilder::Token
tc	CriticalityTC.h	/^  const TaskContext *tc;$/;"	m	class:CriticalityTC
tc	HVersion.h	/^  TaskContext *tc; \/\/ tc == 0 means, finished and (safe or killed)$/;"	m	class:HVersion
tcPool	TaskContext.h	/^  static pool<TaskContext, true> tcPool;$/;"	m	class:TaskContext
tempDInstQueue	BulkManager.h	/^  FastQueue<DInst*> *tempDInstQueue;$/;"	m	class:PredefinedBulkManager
testSaturation	CPPred.cpp	/^int CPPred::testSaturation(int v) const {$/;"	f	class:CPPred
test_and_clear	CPBuilder.h	/^    bool test_and_clear(int tokenId) {$/;"	f	class:TokenContainer
thFillEnergy	TaskContext.cpp	/^GStatsCntr *TaskContext::thFillEnergy=0;   \/\/ FIXME: Energy$/;"	m	class:TaskContext	file:
thFillEnergy	TaskContext.h	/^  static GStatsCntr *thFillEnergy;  \/\/ ETODO$/;"	m	class:TaskContext
thReadEnergy	TaskContext.cpp	/^GStatsCntr *TaskContext::thReadEnergy=0;   \/\/ FIXME: Energy$/;"	m	class:TaskContext	file:
thReadEnergy	TaskContext.h	/^  static GStatsCntr *thReadEnergy;  \/\/ ETODO$/;"	m	class:TaskContext
thWriteEnergy	TaskContext.cpp	/^GStatsCntr *TaskContext::thWriteEnergy=0;  \/\/ FIXME: Energy$/;"	m	class:TaskContext	file:
thWriteEnergy	TaskContext.h	/^  static GStatsCntr *thWriteEnergy; \/\/ ETODO$/;"	m	class:TaskContext
thermFile	OSSim.h	/^  char *thermFile;$/;"	m	class:OSSim
threadEpochs	Epoch.h	/^    EpochList threadEpochs;$/;"	m	class:tls::Thread
threadExeOrders	Checkpoint.h	/^      ThreadExeOrders threadExeOrders;$/;"	m	class:tls::Checkpoint::ExeOrder
threadSafe	Epoch.h	/^    EpochList::iterator threadSafe;    $/;"	m	class:tls::Thread
threadSafeAvailable	Epoch.h	/^    bool threadSafeAvailable;$/;"	m	class:tls::Thread
threadSafeClk	Epoch.h	/^    VClock threadSafeClk;$/;"	m	class:tls::Thread
threadSave	Epoch.cpp	/^  void Epoch::threadSave(void){$/;"	f	class:tls::Epoch
threadVector	Epoch.h	/^    static ThreadVector threadVector;$/;"	m	class:tls::Thread
tid	Epoch.h	/^      ThreadID tid;$/;"	m	class:tls::Epoch::TraceEvent
tid	MemAnalyzer.h	/^  int tid;$/;"	m	class:DelinquentLoad
tid	TaskContext.h	/^  Pid_t  tid;$/;"	m	class:TaskContext
tid2TaskContext	TaskContext.cpp	/^TaskContext::Tid2TaskContextType TaskContext::tid2TaskContext;$/;"	m	class:TaskContext	file:
tid2TaskContext	TaskContext.h	/^  static Tid2TaskContextType tid2TaskContext;$/;"	m	class:TaskContext
timeline	DepWindow.h	/^  Timeline *timeline;$/;"	m	class:DepWindow
timeline	FetchEngine.h	/^  Timeline *timeline;$/;"	m	class:FetchEngine
timeline	GProcessor.h	/^  Timeline *timeline;$/;"	m	class:GProcessor
timeline	MemObj.h	/^  Timeline *timeline;$/;"	m	class:MemObj
timeline	Resource.h	/^  Timeline *timeline;$/;"	m	class:Resource
timer	CPBuilder.h	/^      int timer;$/;"	m	struct:CPBuilder::Token
tls	Checkpoint.cpp	/^namespace tls{$/;"	n	file:
tls	Checkpoint.h	/^namespace tls{$/;"	n
tls	Epoch.cpp	/^namespace tls{$/;"	n	file:
tls	Epoch.h	/^namespace tls{$/;"	n
tmpAddedWaitTime	TaskContext.h	/^  long long tmpAddedWaitTime;$/;"	m	class:TaskContext
tmpComInst	TaskContext.h	/^  long long tmpComInst;$/;"	m	class:TaskContext
tmpComL2HalfMisses	TaskContext.h	/^  long long tmpComL2HalfMisses;$/;"	m	class:TaskContext
tmpComL2Misses	TaskContext.h	/^  long long tmpComL2Misses;$/;"	m	class:TaskContext
tmpComTime	TaskContext.h	/^  long long tmpComTime;$/;"	m	class:TaskContext
tmpInitWaitTime	TaskContext.h	/^  long long tmpInitWaitTime;$/;"	m	class:TaskContext
tmpRatInsts	TaskContext.h	/^  long long tmpRatInsts;$/;"	m	class:TaskContext
tmpRatTime	TaskContext.h	/^  long long tmpRatTime;$/;"	m	class:TaskContext
tmpTotInst	TaskContext.h	/^  long long tmpTotInst;$/;"	m	class:TaskContext
tmpTotTime	TaskContext.h	/^  long long tmpTotTime;$/;"	m	class:TaskContext
tmpWaitTime	TaskContext.h	/^  long long tmpWaitTime;$/;"	m	class:TaskContext
tmsStruct	SysCall.h	/^  struct tms tmsStruct;$/;"	m	class:SysCallTimes	typeref:struct:SysCallTimes::tms
to	CriticalityPredictor.h	/^  ProcessId  *to;$/;"	m	class:CPSchedEvent
toId	MemRequest.h	/^  int toId;$/;"	m	class:ReqPathEntry
toSid	CriticalityPredictor.h	/^  int toSid;$/;"	m	class:EdgeStateX
tokenPool	CPBuilder.h	/^    std::set<int> tokenPool;$/;"	m	class:CPBuilder
tokenRcvd	CriticalityTC.h	/^  bool   tokenRcvd;$/;"	m	class:CriticalityTC
tokenTimer	CPBuilder.h	/^    int tokenTimer;$/;"	m	class:CPBuilder
tokens	CPBuilder.h	/^    Token tokens[NTOKENS];$/;"	m	class:CPBuilder
tokens	CPBuilder.h	/^    bool tokens[NTOKENS];$/;"	m	class:TokenContainer
tot	CriticalityManager.h	/^  GStatsCntr tot;$/;"	m	class:PredData
totCnt	CriticalityPredictor.h	/^  int totCnt;$/;"	m	class:PredictorCnt
total	OSSim.h	/^    ulong total;$/;"	m	struct:OSSim::__anon5
totalCount	AdvancedStats.h	/^    LargeCount totalCount;$/;"	m	class:Stats::Distribution
totalInst	TaskContext.cpp	/^GStatsCntr *TaskContext::totalInst=0;$/;"	m	class:TaskContext	file:
totalInst	TaskContext.h	/^  static GStatsCntr *totalInst;$/;"	m	class:TaskContext
totalInsts	CriticalityTC.h	/^  long long totalInsts;$/;"	m	class:CriticalityTC
totalPredictions	CavaManager.h	/^    int totalPredictions;$/;"	m	class:CavaManager::CkpInfoEntry
totalTime	ProcessId.h	/^    Time_t totalTime;$/;"	m	class:ProcessId::Stats
totalTime	TaskContext.cpp	/^GStatsCntr *TaskContext::totalTime=0;$/;"	m	class:TaskContext	file:
totalTime	TaskContext.h	/^  static GStatsCntr *totalTime;$/;"	m	class:TaskContext
totalnInst	FetchEngine.cpp	/^long long FetchEngine::totalnInst=0;$/;"	m	class:FetchEngine	file:
totalnInst	FetchEngine.h	/^  static long long totalnInst;$/;"	m	class:FetchEngine
trace	OSSim.h	/^  bool trace() const { return (traceFile != 0); }$/;"	f	class:OSSim
traceCodeAddresses	Epoch.h	/^    AddressSet traceCodeAddresses;$/;"	m	class:tls::Epoch
traceDataAddresses	Epoch.h	/^    AddressSet traceDataAddresses;$/;"	m	class:tls::Epoch
traceFile	OSSim.h	/^  char *traceFile;$/;"	m	class:OSSim
tracePrediction	CPBuilder.h	/^      bool tracePrediction;$/;"	m	struct:CPBuilder::Token
train	CriticalityController.h	/^  bool train;$/;"	m	class:CriticalityController
train	CriticalityManager.h	/^  bool train;$/;"	m	class:CritScheduler
train	CriticalityManager.h	/^  bool train;$/;"	m	class:CriticalityManager
trainCnt	CriticalityController.h	/^  int trainCnt;$/;"	m	class:CriticalityController
trainCnt	CriticalityManager.h	/^  int trainCnt;$/;"	m	class:CriticalityManager
trainCritical	CriticalityPredictor.cpp	/^void IdealPredInfo::trainCritical(bool crit, int sid, int successor)$/;"	f	class:IdealPredInfo
trainCritical	CriticalityPredictor.h	/^  virtual void trainCritical(bool crit, int sid, int successor) {}$/;"	f	class:CriticalityPredictor
trainCritical	CriticalityPredictor.h	/^  void trainCritical(bool crit, int sid, int successor) {}$/;"	f	class:IdealHybridCPred
trainCritical	CriticalityPredictor.h	/^  void trainCritical(bool crit, int sid, int successor) {}$/;"	f	class:OracularCPred
trainCritical	CriticalityPredictor.h	/^  void trainCritical(bool crit, int sid, int successor) {}$/;"	f	class:SafeSortCPred
trainCritical	CriticalityPredictor.h	/^  void trainCritical(bool crit, int sid, int successor) {}$/;"	f	class:SpawnOnlyCPred
trainCritical	CriticalityPredictor.h	/^  void trainCritical(bool crit, int sid, int successor) {}$/;"	f	class:SquashOnlyCPred
trainFinish	CriticalityBuilder.cpp	/^void CriticalityBuilderIface::trainFinish(CPNodeGroup *g)$/;"	f	class:CriticalityBuilderIface
trainFinish	CriticalityPredictor.cpp	/^void EdgeCPred::trainFinish(bool crit, int from, int to, int parent, bool predCrit)$/;"	f	class:EdgeCPred
trainFinish	CriticalityPredictor.h	/^  virtual void trainFinish(bool crit, int from, int to, int parent, bool predCrit=false) {}$/;"	f	class:CriticalityPredictor
trainNoSquash	CriticalityPredictor.cpp	/^void EdgeCPred::trainNoSquash(int restart, std::vector<int> &fromHist)$/;"	f	class:EdgeCPred
trainNoSquash	CriticalityPredictor.cpp	/^void IdealPredInfo::trainNoSquash(int restart, std::vector<int> &fromHist)$/;"	f	class:IdealPredInfo
trainNoSquash	CriticalityPredictor.cpp	/^void SquashOnlyCPred::trainNoSquash(int restart, std::vector<int> &fromHist)$/;"	f	class:SquashOnlyCPred
trainNoSquash	CriticalityPredictor.h	/^  virtual void trainNoSquash(int restart, std::vector<int> &fromHist) {}$/;"	f	class:CriticalityPredictor
trainNoSquash	CriticalityPredictor.h	/^  void trainNoSquash(int restart, std::vector<int> &fromHist) {}$/;"	f	class:OracularCPred
trainNoSquash	CriticalityPredictor.h	/^  void trainNoSquash(int restart, std::vector<int> &fromHist) {}$/;"	f	class:SafeSortCPred
trainNoSquash	CriticalityPredictor.h	/^  void trainNoSquash(int restart, std::vector<int> &fromHist) {}$/;"	f	class:SpawnOnlyCPred
trainPhase	CriticalityController.cpp	/^void CriticalityController::trainPhase(int nonSqTasks)$/;"	f	class:CriticalityController
trainPhase	CriticalityManager.cpp	/^void CritScheduler::trainPhase(int nonSqTasks)$/;"	f	class:CritScheduler
trainPredecessor	CriticalityBuilder.cpp	/^void CriticalityBuilderIface::trainPredecessor(int pos)$/;"	f	class:CriticalityBuilderIface
trainPredecessor	CriticalityManager.cpp	/^void CriticalityManager::trainPredecessor(CPNodeGroup *g, CPNodeGroup *pred)$/;"	f	class:CriticalityManager
trainSamples	CriticalityController.h	/^  int trainSamples;$/;"	m	class:CriticalityController
trainSamples	CriticalityManager.h	/^  int trainSamples;$/;"	m	class:CriticalityManager
trainSpawn	CriticalityBuilder.cpp	/^void CriticalityBuilderIface::trainSpawn(CPNodeGroup *g)$/;"	f	class:CriticalityBuilderIface
trainSpawn	CriticalityPredictor.cpp	/^void EdgeCPred::trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit)$/;"	f	class:EdgeCPred
trainSpawn	CriticalityPredictor.cpp	/^void IdealPredInfo::trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit)$/;"	f	class:IdealPredInfo
trainSpawn	CriticalityPredictor.cpp	/^void LocalHybridCPred::trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit)$/;"	f	class:LocalHybridCPred
trainSpawn	CriticalityPredictor.cpp	/^void PathCPred::trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit)$/;"	f	class:PathCPred
trainSpawn	CriticalityPredictor.cpp	/^void SpawnOnlyCPred::trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit)$/;"	f	class:SpawnOnlyCPred
trainSpawn	CriticalityPredictor.h	/^  virtual void trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit=false) {}$/;"	f	class:CriticalityPredictor
trainSpawn	CriticalityPredictor.h	/^  void trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit=false) {}$/;"	f	class:IdealHybridCPred
trainSpawn	CriticalityPredictor.h	/^  void trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit=false) {}$/;"	f	class:OracularCPred
trainSpawn	CriticalityPredictor.h	/^  void trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit=false) {}$/;"	f	class:SafeSortCPred
trainSpawn	CriticalityPredictor.h	/^  void trainSpawn(bool crit, int child, int parent, bool afterSq, bool predCrit=false) {}$/;"	f	class:SquashOnlyCPred
trainSquash	CriticalityPredictor.cpp	/^void EdgeCPred::trainSquash(bool crit, int restart, int from,$/;"	f	class:EdgeCPred
trainSquash	CriticalityPredictor.cpp	/^void IdealPredInfo::trainSquash(bool crit, int restart, int from,$/;"	f	class:IdealPredInfo
trainSquash	CriticalityPredictor.cpp	/^void SquashOnlyCPred::trainSquash(bool crit, int restart,$/;"	f	class:SquashOnlyCPred
trainSquash	CriticalityPredictor.h	/^  virtual void trainSquash(bool crit, int restart, int from, std::vector<int> &fromHist, bool predCrit=false) {}$/;"	f	class:CriticalityPredictor
trainSquash	CriticalityPredictor.h	/^  void trainSquash(bool crit, int restart, int from, std::vector<int> &fromHist, bool predCrit=false) {}$/;"	f	class:OracularCPred
trainSquash	CriticalityPredictor.h	/^  void trainSquash(bool crit, int restart, int from, std::vector<int> &fromHist, bool predCrit=false) {}$/;"	f	class:SafeSortCPred
trainSquash	CriticalityPredictor.h	/^  void trainSquash(bool crit, int restart, int from, std::vector<int> &fromHist, bool predCrit=false) {}$/;"	f	class:SpawnOnlyCPred
trainSquashData	CriticalityBuilder.cpp	/^void CriticalityBuilderIface::trainSquashData(CPNodeGroup *g)$/;"	f	class:CriticalityBuilderIface
trainSquashData	CriticalityManager.cpp	/^void CriticalityManager::trainSquashData( CPNodeGroup *g, PredData *data )$/;"	f	class:CriticalityManager
training	CriticalityManager.h	/^  bool training;$/;"	m	class:CriticalityManager
transferToWindow	CriticalityBuilder.cpp	/^void CriticalityBuilder::transferToWindow()$/;"	f	class:CriticalityBuilder
transferToWindow	CriticalityManager.cpp	/^void CriticalityBase::transferToWindow()$/;"	f	class:CriticalityBase
tricklePriority	CriticalityPredictor.cpp	/^void EdgeCPred::tricklePriority(ProcessId *proc, int pri)$/;"	f	class:EdgeCPred
trustRats	RatsManager.h	/^  bool trustRats;  $/;"	m	class:RatsManager
tryChainSpawn	CriticalityPredictor.cpp	/^bool EdgeCPred::tryChainSpawn(ProcessId *parent, ProcessId *child)$/;"	f	class:EdgeCPred
tryCommit	Epoch.cpp	/^  void Epoch::tryCommit(void){$/;"	f	class:tls::Epoch
tryGlobalSave	Epoch.cpp	/^  void Epoch::tryGlobalSave(void){$/;"	f	class:tls::Epoch
tryPropagateSafeToken	TaskContext.cpp	/^void TaskContext::tryPropagateSafeToken(const HVersionDomain *vd)$/;"	f	class:TaskContext
tryPropagateSafeTokenAll	HVersion.cpp	/^void HVersionDomain::tryPropagateSafeTokenAll()$/;"	f	class:HVersionDomain
tryWakeupParent	OSSim.cpp	/^void OSSim::tryWakeupParent(Pid_t cpid) $/;"	f	class:OSSim
uCkpt	CavaManager.h	/^  GStatsCntr uCkpt;$/;"	m	class:CavaManager
uDist	CavaManager.h	/^  GStatsAvg  uDist;$/;"	m	class:CavaManager
uPred	CavaManager.h	/^  GStatsCntr uPred;$/;"	m	class:CavaManager
ulonglong	CPBuilder.h	/^typedef unsigned long long ulonglong;$/;"	t
unBlockFetch	FetchEngine.cpp	/^void FetchEngine::unBlockFetch()$/;"	f	class:FetchEngine
unBlockFetchCB	FetchEngine.h	/^  StaticCallbackMember0<FetchEngine,&FetchEngine::unBlockFetch> unBlockFetchCB;$/;"	m	class:FetchEngine
unPendInstr	Epoch.h	/^    void unPendInstr(void){$/;"	f	class:tls::Epoch
unRegisterProc	OSSim.cpp	/^void OSSim::unRegisterProc(GProcessor *core)$/;"	f	class:OSSim
undo	SysCall.cpp	/^void SysCallClose::undo(bool expectRedo){$/;"	f	class:SysCallClose
undo	SysCall.cpp	/^void SysCallExit::undo(bool expectRedo){$/;"	f	class:SysCallExit
undo	SysCall.cpp	/^void SysCallFree::undo(bool expectRedo){$/;"	f	class:SysCallFree
undo	SysCall.cpp	/^void SysCallMalloc::undo(bool expectRedo){$/;"	f	class:SysCallMalloc
undo	SysCall.cpp	/^void SysCallMmap::undo(bool expectRedo){$/;"	f	class:SysCallMmap
undo	SysCall.cpp	/^void SysCallMunmap::undo(bool expectRedo){$/;"	f	class:SysCallMunmap
undo	SysCall.cpp	/^void SysCallOpen::undo(bool expectRedo){$/;"	f	class:SysCallOpen
undo	SysCall.cpp	/^void SysCallRead::undo(bool expectRedo){$/;"	f	class:SysCallRead
undo	SysCall.cpp	/^void SysCallSescSpawn::undo(bool expectRedo){$/;"	f	class:SysCallSescSpawn
undo	SysCall.cpp	/^void SysCallWait::undo(bool expectRedo){$/;"	f	class:SysCallWait
undo	SysCall.cpp	/^void SysCallWrite::undo(bool expectRedo){$/;"	f	class:SysCallWrite
undo	SysCall.h	/^  virtual void undo(bool expectRedo){};$/;"	f	class:SysCall
uniqueId	CPBuilder.h	/^      ulonglong uniqueId;$/;"	m	struct:CPBuilder::Token
uniqueIds	CriticalityTC.h	/^  std::vector<CritID> uniqueIds;$/;"	m	class:CriticalityTC
unitMap	Cluster.cpp	/^static UnitMapType unitMap;$/;"	v	file:
unresolvedBranch	GProcessor.h	/^  int unresolvedBranch; \/\/ Ub in cherry paper$/;"	m	class:GProcessor
unresolvedLoad	GProcessor.h	/^  int unresolvedLoad;   \/\/ Ul in cherry paper$/;"	m	class:GProcessor
unresolvedStore	GProcessor.h	/^  int unresolvedStore;  \/\/ Us in cherry paper$/;"	m	class:GProcessor
unsetBlockRetire	GProcessor.h	/^  void unsetBlockRetire() { blockRetire = false; }$/;"	f	class:GProcessor
unspawn	Epoch.cpp	/^  void Epoch::unspawn(void){$/;"	f	class:tls::Epoch
unstop	OSSim.cpp	/^void OSSim::unstop(Pid_t pid)$/;"	f	class:OSSim
unused	CriticalityTC.h	/^  bool unused;$/;"	m	class:SubtaskContext
update	BPred.h	/^    void update(const Instruction *inst, InstID oracleID,  HistoryType hist){return ;}$/;"	f	class:BPOgehl
update	CPPred.cpp	/^int CPPredEntry::update(bool predCrit, int maxValue) {$/;"	f	class:CPPredEntry
update	CriticalityController.cpp	/^void CriticalityController::update(Pid_t pid, int priority)$/;"	f	class:CriticalityController
update	CriticalityManager.cpp	/^void CritScheduler::update(Pid_t pid, int priority)$/;"	f	class:CritScheduler
update	CriticalityPredictor.h	/^  void update() {$/;"	f	class:PredictorCnt
update	VPred.cpp	/^void Selector::update(PAddr addr, PAddr iPC, ValueType value, bool updateVP)$/;"	f	class:Selector
updateAnalyzerCache	BulkManager.cpp	/^void BulkManager::updateAnalyzerCache(DInst *dinst)$/;"	f	class:BulkManager
updateChainHead	CriticalityPredictor.cpp	/^void EdgeCPred::updateChainHead(ProcessId *from, ProcessId *to, bool conf) {$/;"	f	class:EdgeCPred
updateChainPri	CriticalityPredictor.h	/^  int updateChainPri(int old, bool conf) {$/;"	f	class:EdgeCPred
updateCnt	CriticalityPredictor.h	/^  int updateCnt;$/;"	m	class:PredictorCnt
updateCommitTimeStats	BulkManager.cpp	/^void BulkManager::updateCommitTimeStats(Chunk *cc)$/;"	f	class:BulkManager
updateCommitTimeStats	BulkManager.cpp	/^void PredefinedBulkManager::updateCommitTimeStats(Chunk *cc)$/;"	f	class:PredefinedBulkManager
updateCritPrediction	CPPred.cpp	/^int CPPred::updateCritPrediction(ulonglong uniqueId, bool critPred) {$/;"	f	class:CPPred
updateGradInsts	FetchEngine.cpp	/^void FetchEngine::updateGradInsts()$/;"	f	class:FetchEngine
updateIncrPredictor	ValueTable.cpp	/^void ValueTable::updateIncrPredictor(int id, int value) $/;"	f	class:ValueTable
updateInstCnt	CriticalityTC.cpp	/^void CriticalityTC::updateInstCnt()$/;"	f	class:CriticalityTC
updateLVPredictor	ValueTable.cpp	/^void ValueTable::updateLVPredictor(int id, int value) $/;"	f	class:ValueTable
updateOnly	BPred.cpp	/^void BPBTB::updateOnly(const Instruction *inst, InstID oracleID)$/;"	f	class:BPBTB
updatePredictionTables	CriticalityManager.cpp	/^void CriticalityManager::updatePredictionTables(CPNodeGroup *g)$/;"	f	class:CriticalityManager
updatePredictors	CriticalityBuilder.cpp	/^void CriticalityBuilderIface::updatePredictors(int pos)$/;"	f	class:CriticalityBuilderIface
updatePriorities	CriticalityPredictor.cpp	/^void EdgeCPred::updatePriorities(std::vector<ProcessId*> &procVec)$/;"	f	class:EdgeCPred
updateSVPredictor	ValueTable.cpp	/^void ValueTable::updateSVPredictor(int id, int value)$/;"	f	class:ValueTable
updateSidHist	CriticalityTC.cpp	/^void CriticalityTC::updateSidHist(CriticalityTC &child)$/;"	f	class:CriticalityTC
updateStatCounters	CPBuilder.cpp	/^void CPBuilder::updateStatCounters(bool oraclePred, int tablePred )$/;"	f	class:CPBuilder
updateTime	Profile.cpp	/^void Profile::updateTime()$/;"	f	class:Profile
updateTmpComTime	TaskContext.h	/^  void updateTmpComTime(void) { tmpComTime = globalClock;}$/;"	f	class:TaskContext
updateXRDMask	MemBuffer.h	/^  void updateXRDMask(BitMaskType accMask) {$/;"	f	class:MemBufferEntry
updated	DInst.h	/^  bool updated;$/;"	m	class:DInst
upperCaches	MemObj.h	/^  MemObjList upperCaches;$/;"	m	class:MemObj
upperLevel	MemObj.h	/^  LevelType upperLevel;$/;"	m	class:MemObj
useAffinity	ProcessId.cpp	/^bool ProcessId::useAffinity = false;$/;"	m	class:ProcessId	file:
useAffinity	ProcessId.h	/^  static bool useAffinity;$/;"	m	class:ProcessId
useBH	VPred.h	/^  const bool useBH;$/;"	m	class:ConfidenceEstimator
useBadValue	CavaManager.h	/^  const bool useBadValue;$/;"	m	class:CavaManager
useBadValue	RatsManager.h	/^  bool useBadValue;$/;"	m	class:RatsManager
useCE	CavaManager.h	/^  const bool useCE;$/;"	m	class:CavaManager
useCE	RatsManager.h	/^  bool useCE;$/;"	m	class:RatsManager
useDelay	MultiManager.h	/^  bool useDelay;$/;"	m	class:MultiPathManager
useDensity	RatsManager.h	/^  bool useDensity;$/;"	m	class:RatsManager
useHistory	CriticalityBuilder.cpp	/^bool CriticalityBuilderIface::useHistory = true;$/;"	m	class:CriticalityBuilderIface	file:
useHistory	CriticalityBuilder.h	/^  static bool useHistory;$/;"	m	class:CriticalityBuilderIface
useInflightHash	CavaManager.h	/^  const bool useInflightHash;$/;"	m	class:CavaManager
useMSHR	RatsManager.h	/^  bool useMSHR;$/;"	m	class:RatsManager
useSimMarks	OSSim.h	/^  bool useSimMarks;$/;"	m	class:OSSim
useSimPoints	OSSim.h	/^  bool useSimPoints;$/;"	m	class:OSSim
useSquash	RatsManager.h	/^  bool useSquash;$/;"	m	class:RatsManager
usedHistLength	BPred.h	/^  int *usedHistLength;$/;"	m	class:BPOgehl
usedNames	GMemorySystem.cpp	/^GMemorySystem::StrCounterType  GMemorySystem::usedNames;$/;"	m	class:GMemorySystem	file:
usedNames	GMemorySystem.h	/^  static StrCounterType usedNames;$/;"	m	class:GMemorySystem
usedThreads	TaskContext.h	/^  Pid_tSet usedThreads; \/\/ TODO: look for a better name$/;"	m	class:TaskContext
usefulPredictions	CavaManager.h	/^    int usefulPredictions;$/;"	m	class:CavaManager::CkpInfoEntry
v1	VPred.h	/^  ValueType *v1, *v2, *v3 ,*v4;$/;"	m	class:FCMPred
v2	VPred.h	/^  ValueType *v1, *v2, *v3 ,*v4;$/;"	m	class:FCMPred
v3	VPred.h	/^  ValueType *v1, *v2, *v3 ,*v4;$/;"	m	class:FCMPred
v4	VPred.h	/^  ValueType *v1, *v2, *v3 ,*v4;$/;"	m	class:FCMPred
vDomain	HVersion.h	/^  HVersionDomain *vDomain;$/;"	m	class:HVersion
vHit	CavaManager.h	/^  GStatsCntr vHit;$/;"	m	class:CavaManager
vHit	MemAnalyzer.h	/^  GStatsCntr vHit;$/;"	m	class:MemAnalyzer
vHits	MemAnalyzer.h	/^  int vHits;$/;"	m	class:AVSeries
vMiss	CavaManager.h	/^  GStatsCntr vMiss;$/;"	m	class:CavaManager
vMiss	MemAnalyzer.h	/^  GStatsCntr vMiss;$/;"	m	class:MemAnalyzer
vPool	ASVersion.h	/^  static poolType vPool;$/;"	m	class:HVersion
vPool	HVersion.h	/^  static poolType vPool;$/;"	m	class:HVersion
vPredictors	MemAnalyzer.h	/^  VPredTableType vPredictors;$/;"	m	class:MemAnalyzer
vSelectors	MemAnalyzer.h	/^  VSelTableType  vSelectors;$/;"	m	class:MemAnalyzer
vTime	Profile.h	/^    Time_t vTime;      \/\/virtual time$/;"	m	class:Profile::SpawnInfo
vTime	Profile.h	/^    Time_t vTime;     \/\/record the virtual time because the future $/;"	m	class:Profile::WriteInfo
vaddr	DInst.h	/^  VAddr vaddr;$/;"	m	class:DInst
value	Epoch.h	/^    ClockValue value(void) const{$/;"	f	class:tls::VClock
valuePredHit	DInst.h	/^  bool         valuePredHit;$/;"	m	class:DInst
vdVec	HVersion.cpp	/^HVersionDomain::VDomainVectorType HVersionDomain::vdVec;$/;"	m	class:HVersionDomain	file:
vdVec	HVersion.h	/^  static VDomainVectorType vdVec;$/;"	m	class:HVersionDomain
ver	MemBuffer.h	/^  const HVersion *ver; \/\/ Version that the rd\/wr belongs$/;"	m	class:MemBufferEntry
verRef	DInst.h	/^  HVersion   *verRef; \/\/ should == lvidVersion$/;"	m	class:DInst
verify	Checkpoint.cpp	/^    bool verify(Address baseAddr){$/;"	f	class:tls::Checkpoint::BlockData
verify	HVersion.cpp	/^void HVersion::verify(HVersion *orig)$/;"	f	class:HVersion
verify	HVersion.h	/^  static void verify(HVersion *orig) {$/;"	f	class:HVersion
verifyBadCntr	ValueTable.cpp	/^GStatsCntr *ValueTable::verifyBadCntr =0;$/;"	m	class:ValueTable	file:
verifyBadCntr	ValueTable.h	/^  static GStatsCntr *verifyBadCntr;$/;"	m	class:ValueTable
verifyGoodCntr	ValueTable.cpp	/^GStatsCntr *ValueTable::verifyGoodCntr=0;$/;"	m	class:ValueTable	file:
verifyGoodCntr	ValueTable.h	/^  static GStatsCntr *verifyGoodCntr;$/;"	m	class:ValueTable
verifyValue	ValueTable.cpp	/^void ValueTable::verifyValue(int rval, int pval)$/;"	f	class:ValueTable
vfpair	CriticalityController.h	/^  std::vector<int> vfpair;$/;"	m	class:CriticalityController
vfpair	CriticalityManager.h	/^  std::vector<int> vfpair;$/;"	m	class:CriticalityManager
vfpairId	DVFSManager.cpp	/^HASH_MAP< const char*, int, HASH<const char*>, struct eqstr > DVFSManager::vfpairId;$/;"	m	class:DVFSManager	file:
vfpairId	DVFSManager.h	/^  static HASH_MAP<const char *,int, HASH<const char*>, struct eqstr > vfpairId;$/;"	m	class:DVFSManager
vfpairInv	CriticalityController.h	/^  std::vector<int> vfpairInv;$/;"	m	class:CriticalityController
vfpairInv	CriticalityManager.h	/^  std::vector<int> vfpairInv;$/;"	m	class:CriticalityManager
vfpairs	DVFSManager.cpp	/^std::vector<int> DVFSManager::vfpairs;$/;"	m	class:DVFSManager	file:
vfpairs	DVFSManager.h	/^  static std::vector<int> vfpairs; \/\/vfpairs[i] is the pair on processor i$/;"	m	class:DVFSManager
violationThrd	Profile.h	/^  float violationThrd;$/;"	m	class:Profile
visited	ASVersion.h	/^  bool visited;$/;"	m	class:HVersion
visited	HVersion.h	/^  bool visited;$/;"	m	class:HVersion
vmemReq	MemRequest.h	/^  VMemReq *vmemReq;$/;"	m	class:MemRequest
voltScaleHash	DVFSManager.cpp	/^HASH_MAP< int, double > DVFSManager::voltScaleHash;$/;"	m	class:DVFSManager	file:
voltScaleHash	DVFSManager.h	/^  static HASH_MAP<int, double> voltScaleHash;$/;"	m	class:DVFSManager
vp	RatsManager.h	/^  GValuePredictor *vp;$/;"	m	class:RatsManager
vp1	CavaManager.h	/^  GValuePredictor *vp1, *vp2;$/;"	m	class:CavaManager
vp1	VPred.h	/^  GValuePredictor *vp1;$/;"	m	class:Selector
vp2	CavaManager.h	/^  GValuePredictor *vp1, *vp2;$/;"	m	class:CavaManager
vp2	VPred.h	/^  GValuePredictor *vp2;$/;"	m	class:Selector
vpMode	CavaManager.h	/^  VPMode vpMode;$/;"	m	class:CavaManager
vpSel	CavaManager.h	/^  Selector *vpSel;$/;"	m	class:CavaManager
vpSel	MemAnalyzer.h	/^  Selector *vpSel;$/;"	m	class:MemAnalyzer
vpTrainAll	CavaManager.h	/^  bool vpTrainAll;$/;"	m	class:CavaManager
vptSize	CavaManager.h	/^  const int  vptSize;$/;"	m	class:CavaManager
vptSize	MemAnalyzer.h	/^  const int  vptSize;$/;"	m	class:MemAnalyzer
vptSize	RatsManager.h	/^  const int  vptSize;$/;"	m	class:RatsManager
wToRLevel	MemRequest.h	/^  long wToRLevel;$/;"	m	class:MemRequest
wait	Epoch.h	/^		     WaitGlobalSafe, WaitFullyMerged}          wait : 2;$/;"	m	struct:tls::Epoch::State	typeref:enum:tls::Epoch::State::WaitEnum
waitBeginIdSimMarks	OSSim.h	/^  long waitBeginIdSimMarks;$/;"	m	class:OSSim
waitEndIdSimMarks	OSSim.h	/^  long waitEndIdSimMarks;$/;"	m	class:OSSim
waitFullyMerged	Epoch.h	/^    bool waitFullyMerged(void){$/;"	f	class:tls::Epoch
waitGlobalSafe	Epoch.h	/^    bool waitGlobalSafe(void){$/;"	f	class:tls::Epoch
waitThreadSafe	Epoch.h	/^    bool waitThreadSafe(void){$/;"	f	class:tls::Epoch
waitTime	ProcessId.h	/^    Time_t waitTime ;$/;"	m	class:ProcessId::Stats
waitTime	TaskContext.cpp	/^GStatsCntr *TaskContext::waitTime=0;$/;"	m	class:TaskContext	file:
waitTime	TaskContext.h	/^  static GStatsCntr *waitTime;$/;"	m	class:TaskContext
waiting	ProcessId.h	/^  bool waiting;$/;"	m	class:ProcessId
waitingOnFence	Resource.h	/^  bool waitingOnFence() {$/;"	f	class:FUStore
wakeUpDeps	Cluster.h	/^  void wakeUpDeps(DInst *dinst) { window.wakeUpDeps(dinst); }$/;"	f	class:Cluster
wakeUpDeps	DepWindow.cpp	/^void DepWindow::wakeUpDeps(DInst *dinst)$/;"	f	class:DepWindow
wakeUpPort	DepWindow.h	/^  PortGeneric *wakeUpPort;$/;"	m	class:DepWindow
wakeUpTime	DInst.h	/^  Time_t wakeUpTime;$/;"	m	class:DInst
wasSpawnedOO	TaskContext.h	/^  bool wasSpawnedOO;   \/\/ true if the current task was spawned Out-Of-Order$/;"	m	class:TaskContext
weight	CriticalityPredictor.h	/^  std::vector<bool> weight;$/;"	m	class:MarkovPred
when	DInst.h	/^  Time_t       when;$/;"	m	class:DInst
whenStall	CavaManager.h	/^  enum VPMode { eager, atHeadROB, whenStall };$/;"	e	enum:CavaManager::VPMode
winHead	CriticalityBuilder.h	/^  size_t winHead;$/;"	m	class:CriticalityBuilder
winHead	CriticalityManager.h	/^  size_t winHead;$/;"	m	class:CriticalityBase
winNotUsed	Cluster.h	/^  GStatsAvg winNotUsed;$/;"	m	class:Cluster
winPadSize	CriticalityBuilder.h	/^  size_t winPadSize;$/;"	m	class:CriticalityBuilder
winPadSize	CriticalityManager.h	/^  size_t winPadSize; $/;"	m	class:CriticalityBase
winSize	CriticalityBuilder.h	/^  size_t winSize;$/;"	m	class:CriticalityBuilder
winSize	CriticalityManager.h	/^  size_t winSize;$/;"	m	class:CriticalityBase
window	Cluster.h	/^  DepWindow window;$/;"	m	class:Cluster
window	CriticalityBuilder.h	/^  GroupList window;     \/\/window of tasks to analyze$/;"	m	class:CriticalityBuilder
window	CriticalityManager.h	/^  GroupList window;     \/\/window of tasks to analyze$/;"	m	class:CriticalityBase
windowCheckEnergy	DepWindow.h	/^  GStatsEnergy *windowCheckEnergy; \/\/ Check for dependences on the window$/;"	m	class:DepWindow
windowRdWrEnergy	DepWindow.h	/^  GStatsEnergy *windowRdWrEnergy;  \/\/ read\/write on an individual window entry$/;"	m	class:DepWindow
windowSelEnergy	DepWindow.h	/^  GStatsEnergy *windowSelEnergy;   \/\/ instruction selection$/;"	m	class:DepWindow
windowSize	Cluster.h	/^  long windowSize;$/;"	m	class:Cluster
wkData	Epoch.h	/^      unsigned long long wkData[blockSize\/sizeof(unsigned long long)];$/;"	m	class:tls::Epoch::BufferBlock
workingList	RunningProcs.h	/^  GProcCont  workingList;$/;"	m	class:RunningProcs
workingListAdd	RunningProcs.cpp	/^void RunningProcs::workingListAdd(GProcessor *core)$/;"	f	class:RunningProcs
workingListRemove	RunningProcs.cpp	/^void RunningProcs::workingListRemove(GProcessor *core)$/;"	f	class:RunningProcs
wrHit	MemAnalyzer.h	/^  GStatsCntr wrHit;$/;"	m	class:MemAnalyzer
wrInstAddr	MemBuffer.h	/^  ulong  wrInstAddr;$/;"	m	class:MemBufferEntry
wrMask	Epoch.h	/^      ChunkBitMask wrMask[blockSize\/chunkSize];$/;"	m	class:tls::Epoch::BufferBlock
wrMiss	MemAnalyzer.h	/^  GStatsCntr wrMiss;$/;"	m	class:MemAnalyzer
wrRegEnergy	GProcessor.h	/^  GStatsEnergyBase *wrRegEnergy[3]; \/\/ 0 INT, 1 FP, 2 NONE$/;"	m	class:GProcessor
write	Checkpoint.cpp	/^  void Checkpoint::write(Address addr){$/;"	f	class:tls::Checkpoint
write	Epoch.cpp	/^  Address Epoch::write(Address iAddrV, short iFlags,$/;"	f	class:tls::Epoch
write	MemAnalyzer.cpp	/^void MemAnalyzer::write(PAddr addr, PAddr iPC, ValueType value, unsigned dsize, bool trainVP)$/;"	f	class:MemAnalyzer
write	Profile.cpp	/^bool ProfCache::write(PAddr addr)$/;"	f	class:ProfCache
writeAccess	Epoch.h	/^      TraceAccessEvent *writeAccess;$/;"	m	struct:tls::Epoch::RaceAddrInfo
writeData	TaskContext.cpp	/^unsigned long long TaskContext::writeData=0;$/;"	m	class:TaskContext	file:
writeData	TaskContext.h	/^  static unsigned long long writeData;$/;"	m	class:TaskContext
writeInst	Profile.h	/^    int writeInst;$/;"	m	class:Profile::DepInfo
writeSet	BulkManager.h	/^    AddressSet writeSet;$/;"	m	class:BulkManager::Chunk
writeSet	MemBuffer.h	/^  AddressSet writeSet;$/;"	m	class:MemBuffer
writeSnapshot	MemBuffer.h	/^  AddressSet writeSnapshot;$/;"	m	class:MemBuffer
writers	Epoch.h	/^      BufferBlockList writers;$/;"	m	class:tls::Epoch::BlockVersions
writersPos	Epoch.h	/^      BlockVersions::BufferBlockList::iterator writersPos;$/;"	m	class:tls::Epoch::BufferBlock
writes	Profile.cpp	/^Profile::WriteInfoType Profile::writes;$/;"	m	class:Profile	file:
writes	Profile.h	/^  static WriteInfoType writes;$/;"	m	class:Profile
wrmask	MemBuffer.h	/^  BitMaskType        wrmask;$/;"	m	class:MemBufferEntry
wrong	DInst.h	/^  bool wrong;$/;"	m	class:DInst
xpMask	Epoch.h	/^      ChunkBitMask xpMask[blockSize\/chunkSize];$/;"	m	class:tls::Epoch::BufferBlock
xrdmask	MemBuffer.h	/^  BitMaskType        xrdmask; \/\/ Exposed read mask (ONLY exposed reads)$/;"	m	class:MemBufferEntry
~AVSeries	MemAnalyzer.h	/^  ~AVSeries() { fclose(ffd); }$/;"	f	class:AVSeries
~BHLVPred	VPred.h	/^  virtual ~BHLVPred() { }$/;"	f	class:BHLVPred
~BP2BcgSkew	BPred.cpp	/^BP2BcgSkew::~BP2BcgSkew()$/;"	f	class:BP2BcgSkew
~BP2level	BPred.cpp	/^BP2level::~BP2level()$/;"	f	class:BP2level
~BPBTB	BPred.cpp	/^BPBTB::~BPBTB()$/;"	f	class:BPBTB
~BPCRap	BPred.cpp	/^BPCRap::~BPCRap()$/;"	f	class:BPCRap
~BPHybrid	BPred.cpp	/^BPHybrid::~BPHybrid()$/;"	f	class:BPHybrid
~BPOgehl	BPred.cpp	/^BPOgehl::~BPOgehl()$/;"	f	class:BPOgehl
~BPRap	BPred.cpp	/^BPRap::~BPRap()$/;"	f	class:BPRap
~BPRas	BPred.cpp	/^BPRas::~BPRas()$/;"	f	class:BPRas
~BPred	BPred.cpp	/^BPred::~BPred()$/;"	f	class:BPred
~BPredictor	BPred.cpp	/^BPredictor::~BPredictor()$/;"	f	class:BPredictor
~BPyags	BPred.cpp	/^BPyags::~BPyags()$/;"	f	class:BPyags
~BlockVersions	Epoch.h	/^      ~BlockVersions(void){$/;"	f	class:tls::Epoch::BlockVersions
~BufferBlock	Epoch.h	/^      ~BufferBlock(void){$/;"	f	class:tls::Epoch::BufferBlock
~BulkManager	BulkManager.h	/^  virtual ~BulkManager() { }$/;"	f	class:BulkManager
~Checkpoint	Checkpoint.cpp	/^  Checkpoint::~Checkpoint(void){$/;"	f	class:tls::Checkpoint
~Chunk	BulkManager.h	/^    ~Chunk() {$/;"	f	class:BulkManager::Chunk
~Cluster	Cluster.cpp	/^Cluster::~Cluster()$/;"	f	class:Cluster
~ConfidenceEstimator	VPred.h	/^  ~ConfidenceEstimator() { }$/;"	f	class:ConfidenceEstimator
~ConsistencyPolicy	ConsistencyPolicy.h	/^  virtual ~ConsistencyPolicy() { };$/;"	f	class:ConsistencyPolicy
~CriticalityBase	CriticalityManager.h	/^  virtual ~CriticalityBase() {}$/;"	f	class:CriticalityBase
~CriticalityBuilder	CriticalityBuilder.h	/^  virtual ~CriticalityBuilder() {}$/;"	f	class:CriticalityBuilder
~CriticalityController	CriticalityController.h	/^  virtual ~CriticalityController() {}$/;"	f	class:CriticalityController
~CriticalityManager	CriticalityManager.h	/^  virtual ~CriticalityManager() {}$/;"	f	class:CriticalityManager
~CriticalityPredictor	CriticalityPredictor.h	/^  virtual ~CriticalityPredictor() {}$/;"	f	class:CriticalityPredictor
~DefaultConsistencyPolicy	ConsistencyPolicy.h	/^  ~DefaultConsistencyPolicy() { };$/;"	f	class:DefaultConsistencyPolicy
~DepWindow	DepWindow.cpp	/^DepWindow::~DepWindow()$/;"	f	class:DepWindow
~DummyMemoryOS	GMemoryOS.cpp	/^DummyMemoryOS::~DummyMemoryOS() $/;"	f	class:DummyMemoryOS
~DummyMemorySystem	GMemorySystem.cpp	/^DummyMemorySystem::~DummyMemorySystem() $/;"	f	class:DummyMemorySystem
~ELVPred	VPred.h	/^  virtual ~ELVPred() { }$/;"	f	class:ELVPred
~Epoch	Epoch.cpp	/^  Epoch::~Epoch(void){$/;"	f	class:tls::Epoch
~ExeOrder	Checkpoint.cpp	/^  Checkpoint::ExeOrder::~ExeOrder(void){$/;"	f	class:tls::Checkpoint::ExeOrder
~ExecutedCluster	Cluster.h	/^  virtual ~ExecutedCluster() {$/;"	f	class:ExecutedCluster
~FCMPred	VPred.h	/^  virtual ~FCMPred() { }$/;"	f	class:FCMPred
~FWPred	VPred.h	/^  virtual ~FWPred() { }$/;"	f	class:FWPred
~Fetch	SMTProcessor.cpp	/^SMTProcessor::Fetch::~Fetch()$/;"	f	class:SMTProcessor::Fetch
~FetchEngine	FetchEngine.cpp	/^FetchEngine::~FetchEngine()$/;"	f	class:FetchEngine
~GAddressPredictor	MemAnalyzer.h	/^  virtual ~GAddressPredictor() { } $/;"	f	class:GAddressPredictor
~GLVID	GLVID.h	/^  virtual ~GLVID() {}$/;"	f	class:GLVID
~GMemoryOS	GMemoryOS.h	/^  virtual ~GMemoryOS() {$/;"	f	class:GMemoryOS
~GMemorySystem	GMemorySystem.cpp	/^GMemorySystem::~GMemorySystem() $/;"	f	class:GMemorySystem
~GProcessor	GProcessor.cpp	/^GProcessor::~GProcessor()$/;"	f	class:GProcessor
~GValuePredictor	VPred.h	/^  virtual ~GValuePredictor() { }$/;"	f	class:GValuePredictor
~GlobalLVPred	VPred.h	/^  virtual ~GlobalLVPred() { }$/;"	f	class:GlobalLVPred
~Group	AdvancedStats.cpp	/^  Group::~Group(void){$/;"	f	class:Stats::Group
~IBucket	Pipeline.h	/^  virtual ~IBucket() { }$/;"	f	class:IBucket
~LDSTQ	LDSTQ.h	/^  ~LDSTQ() { }$/;"	f	class:LDSTQ
~LVPred	VPred.h	/^  virtual ~LVPred() { }$/;"	f	class:LVPred
~MarkovAP	MemAnalyzer.h	/^  virtual ~MarkovAP() { }$/;"	f	class:MarkovAP
~MemAnalyzer	MemAnalyzer.cpp	/^MemAnalyzer::~MemAnalyzer()$/;"	f	class:MemAnalyzer
~MemObj	MemObj.cpp	/^MemObj::~MemObj() $/;"	f	class:MemObj
~MemRequest	MemRequest.cpp	/^MemRequest::~MemRequest() $/;"	f	class:MemRequest
~OSSim	OSSim.cpp	/^OSSim::~OSSim() $/;"	f	class:OSSim
~PipeQueue	Pipeline.cpp	/^PipeQueue::~PipeQueue()$/;"	f	class:PipeQueue
~Pipeline	Pipeline.cpp	/^Pipeline::~Pipeline() $/;"	f	class:Pipeline
~Processor	Processor.cpp	/^Processor::~Processor()$/;"	f	class:Processor
~ProfCache	Profile.cpp	/^ProfCache::~ProfCache()$/;"	f	class:ProfCache
~Profile	Profile.cpp	/^Profile::~Profile()$/;"	f	class:Profile
~RaceAddrInfo	Epoch.h	/^      ~RaceAddrInfo(void){$/;"	f	struct:tls::Epoch::RaceAddrInfo
~Resource	Resource.cpp	/^Resource::~Resource()$/;"	f	class:Resource
~RetiredCluster	Cluster.h	/^  virtual ~RetiredCluster() {$/;"	f	class:RetiredCluster
~RiskLoadProf	RiskLoadProf.h	/^  ~RiskLoadProf() {}$/;"	f	class:RiskLoadProf
~SBimodal	GProcessor.cpp	/^SBimodal::~SBimodal(){$/;"	f	class:SBimodal
~SCConsistencyPolicy	ConsistencyPolicy.cpp	/^SCConsistencyPolicy::~SCConsistencyPolicy()$/;"	f	class:SCConsistencyPolicy
~SHybrid	GProcessor.cpp	/^SHybrid::~SHybrid(){$/;"	f	class:SHybrid
~SMTProcessor	SMTProcessor.cpp	/^SMTProcessor::~SMTProcessor()$/;"	f	class:SMTProcessor
~SNotSquash	GProcessor.cpp	/^SNotSquash::~SNotSquash(){$/;"	f	class:SNotSquash
~SPred	VPred.h	/^  virtual ~SPred() { }$/;"	f	class:SPred
~SSquash	GProcessor.cpp	/^SSquash::~SSquash(){$/;"	f	class:SSquash
~STagged	GProcessor.cpp	/^STagged::~STagged(){$/;"	f	class:STagged
~Selector	VPred.h	/^  ~Selector() { }$/;"	f	class:Selector
~SqPred	GProcessor.cpp	/^SqPred::~SqPred()$/;"	f	class:SqPred
~StrideAP	MemAnalyzer.h	/^  virtual ~StrideAP() { }$/;"	f	class:StrideAP
~Thread	Epoch.cpp	/^  Thread::~Thread(void){$/;"	f	class:tls::Thread
~ThreadExeOrder	Checkpoint.cpp	/^    ~ThreadExeOrder(void){$/;"	f	class:tls::Checkpoint::ExeOrder::ThreadExeOrder
~TraceEvent	Epoch.h	/^      virtual ~TraceEvent(void){}$/;"	f	class:tls::Epoch::TraceEvent
~VClock	Epoch.h	/^    ~VClock(void){$/;"	f	class:tls::VClock
~ZeroPred	VPred.h	/^  virtual ~ZeroPred() { }$/;"	f	class:ZeroPred
