Revision 842775ab src/eventlog/sequencechartfacade.h
src/eventlog/sequencechartfacade.h  

39  39 
long timelineCoordinateSystemVersion; // a counter incremented each time the timeline coordinate system is relocated 
40  40 
eventnumber_t timelineCoordinateOriginEventNumber; // 1 means undefined, otherwise the event number of the timeline coordinate system origin 
41  41 
simtime_t timelineCoordinateOriginSimulationTime; // simtime_nil means undefined 
42 
double timelineCoordinateOriginRealTime; 

43  42 
eventnumber_t timelineCoordinateRangeStartEventNumber; // 1 means undefined, the beginning of the continuous event range which has timeline coordinates assigned 
44  43 
eventnumber_t timelineCoordinateRangeEndEventNumber; // 1 means undefined, the end of the continuous event range which has timeline coordinates assigned 
45  44 
TimelineMode timelineMode; 
46  45 
double nonLinearFocus; // a useful constant for the nonlinear transformation between simulation time and timeline coordinate 
47  46 
double nonLinearMinimumTimelineCoordinateDelta; // minimum timeline coordinate difference between two events 
48  47  
49 
long smallestComplexity; 

50 
long largestComplexity; 

51  
52 
double maximumOverlapping; 

53  
54 
simtime_t smallestDuration; 

55 
simtime_t largestDuration; 

56  
57 
simtime_t biggestEarliestProcessingTime; 

58 
IEvent* biggestEarliestProcessingTimeEvent; 

59  
60 
IEvent* biggestEndTimeEvent; 

61  
62 
std::set<ptr_t> cachedParallelSet; 

63 
IEvent* lastSelected; 

64  
65 
std::set<ptr_t> cachedCriticalPath; 

66  48 
public: 
67  49 
SequenceChartFacade(IEventLog *eventLog); 
68  50 
virtual ~SequenceChartFacade() {} 
...  ...  
87  69 
*/ 
88  70 
double getTimelineCoordinate(ptr_t ptr, double lowerTimelineCoordinateCalculationLimit = DBL_MAX, double upperTimelineCoordinateCalculationLimit = DBL_MAX); 
89  71 
double getTimelineCoordinate(IEvent *event, double lowerTimelineCoordinateCalculationLimit = DBL_MAX, double upperTimelineCoordinateCalculationLimit = DBL_MAX); 
90 
double getTimelineEventEndCoordinate(IEvent *event, double lowerTimelineCoordinateCalculationLimit = DBL_MAX, double upperTimelineCoordinateCalculationLimit = DBL_MAX); 

91 
double getTimelineEventEndCoordinate(ptr_t ptr, double lowerTimelineCoordinateCalculationLimit = DBL_MAX, double upperTimelineCoordinateCalculationLimit = DBL_MAX); 

92  72 
double getCachedTimelineCoordinate(IEvent *event); 
93  73 
double IEvent_getTimelineCoordinate(ptr_t ptr); 
94 
double IEvent_getTimelineEventEndCoordinate(ptr_t ptr); 

95  74 
void undefineTimelineCoordinateSystem(); 
96  75 
void relocateTimelineCoordinateSystem(IEvent *event); 
97  76  
...  ...  
99  78 
IEvent *getLastEventNotAfterTimelineCoordinate(double timelineCoordinate); 
100  79 
IEvent *getFirstEventNotBeforeTimelineCoordinate(double timelineCoordinate); 
101  80  
102 
/* 

103 
* returns smallest event complexity in the event log 

104 
*/ 

105 
long getSmallestEventComplexity(); 

106 
/* 

107 
* returns largest event complexity in the event log 

108 
*/ 

109 
long getLargestEventComplexity(); 

110  
111 
/* 

112 
* returns smallest event duration in the event log 

113 
*/ 

114 
simtime_t getSmallestEventDuration(); 

115 
/* 

116 
* returns largest event duration in the event log 

117 
*/ 

118 
simtime_t getLargestEventDuration(); 

119  
120 
double getOverlappingQuotient(ptr_t eventPtr); 

121  
122 
/* 

123 
* returns true when the events overlap in the REAL_TIME domain (i.e. are executed on two cpus in parallel) 

124 
*/ 

125 
bool isOverlappingInRealTimeDomain(ptr_t eventPtr1, ptr_t eventPtr2); 

126  
127  
128 
/* 

129 
* Returns whether an event not part of a set of parallel events with more than treshold elements. 

130 
*/ 

131 
bool isBottleneck(IEvent* event, double threshold); 

132  
133 
bool isParallelWithEvent(IEvent* event, IEvent* selected); 

134  
135 
IEvent* getPreviousBottleneck(IEvent* e, double threshold); 

136 
IEvent* getNextBottleneck(IEvent* e, double threshold); 

137  
138 
bool isOnCriticalPath(IEvent* event); 

139  
140 
ptr_t getLargestEndtimeInEventRange(ptr_t startEventPtr, ptr_t endEventPtr, bool duration=false); 

141  
142  81 
/** 
143  82 
* Timeline coordinate can be given in the range (infinity, +infinity). 
144  83 
* Simulation time will be in the range [0, lastEventSimulationTime]. 
...  ...  
163  102 
simtime_t &eventSimulationTime, double &eventTimelineCoordinate, 
164  103 
simtime_t &nextEventSimulationTime, double &nextEventTimelineCoordinate, 
165  104 
simtime_t &simulationTimeDelta, double &timelineCoordinateDelta); 
166  
167 
std::set<ptr_t>* getLargestParallelSet(IEvent* event, std::set<ptr_t>* parallelSet); 

168  
169 
unsigned int getLargestParallelSetSize(IEvent* event); 

170  
171 
void getParallelSet(IEvent* event, std::set<ptr_t>* parallelSet); 

172  
173 
simtime_t getSmallestParallelEndtime(IEvent* event); 

174  
175 
void calculateCriticalPath(); 

176  
177 
void cacheRealTimeEventOrder(); 

178  
179 
double getOverlapping(ptr_t eventPtr); 

180  
181 
double getMaximumOverlapping(); 

182  
183  
184  105 
}; 
185  106  
186  107 
NAMESPACE_END 
Also available in: Unified diff