Revision 842775ab src/eventlog/sequencechartfacade.h

View differences:

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