Attachment #184142 for bug #325016

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




package org.eclipse.linuxtools.tmf.ui.views.timechart;

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Vector;

import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;

public class TimeChartAnalysisEntry implements ITmfTimeAnalysisEntry {

    private ITmfTrace fTrace;
    private String fGroup;
    private Vector<TimeChartEvent> fTraceEvents;
    private int fPower = 0; // 2^fPower nanoseconds per vector position
    private long fReferenceTime = -1; // time corresponding to beginning of index 0
    private long fStartTime = -1; // time of first event
    private long fStopTime = -1; // time of last event
    private long fLastRank = -1; // rank of last processed trace event

    TimeChartAnalysisEntry(ITmfTrace trace, int modelSize) {
        fTrace = trace;
        fTraceEvents = new Vector<TimeChartEvent>(modelSize);
    }
    
    TimeChartAnalysisEntry(ITmfTrace trace, String group, int modelSize) {
        fTrace = trace;
        fTraceEvents = new Vector<TimeChartEvent>(modelSize);
        fGroup = group;
    }
    
    @Override
    public String getGroupName() {
        return fGroup;
    }

    @Override
    public int getId() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public String getName() {
        return fTrace.getName();
    }

    @Override
    public long getStartTime() {
        return fStartTime;
    }

    @Override
    public long getStopTime() {
        return fStopTime;
    }

    @Override
    @Deprecated public <T extends ITimeEvent> Vector<T> getTraceEvents() {
        return null;
    }

    @Override
    public Iterator<ITimeEvent> getTraceEventsIterator() {
        return new EntryIterator(0, Long.MAX_VALUE, 0);
    }
    
    @Override
    public Iterator<ITimeEvent> getTraceEventsIterator(long startTime, long stopTime, long maxDuration) {
        return new EntryIterator(startTime, stopTime, maxDuration);
    }
    
    private class EntryIterator implements Iterator<ITimeEvent> {
        private final long fIteratorStartTime;
        private final long fIteratorStopTime;
        private final long fIteratorMaxDuration;
        private long lastTime = -1;
        private TimeChartEvent next = null;
        private Iterator<ITimeEvent> nestedIterator = null;
        
        public EntryIterator(long startTime, long stopTime, long maxDuration) {
            fIteratorStartTime = startTime;
            fIteratorStopTime = stopTime;
            fIteratorMaxDuration = maxDuration;
        }
        
        @Override
        public boolean hasNext() {
            synchronized (fTraceEvents) {
                if (next != null) return true;
                if (nestedIterator != null) {
                    if (nestedIterator.hasNext()) {
                        return true;
                    } else {
                        nestedIterator = null;
                    }
                }
                long time = (lastTime == -1) ? fStartTime : lastTime;
                int index = (fReferenceTime == -1) ? 0 : (int) ((time - fReferenceTime) >> fPower);
                while (index < fTraceEvents.size()) {
                    TimeChartEvent event = fTraceEvents.get(index++);
                    if (event != null && (lastTime == -1 || event.getTime() > time)) {
                        if (event.getTime() + event.getDuration() >= fIteratorStartTime && event.getTime() <= fIteratorStopTime) {
                            if (event.getItemizedEntry() == null || event.getDuration() <= fIteratorMaxDuration) {
                                lastTime = event.getTime() + event.getDuration();
                                next = event;
                                return true;
                            } else {
                                nestedIterator = event.getItemizedEntry().getTraceEventsIterator(fIteratorStartTime, fIteratorStopTime, fIteratorMaxDuration);
                                return nestedIterator.hasNext();
                            }
                        }
                    }
                }
                return false;
            }
        }

        @Override
        public TimeChartEvent next() {
            synchronized (fTraceEvents) {
                if (nestedIterator != null) {
                    TimeChartEvent event = (TimeChartEvent) nestedIterator.next();
                    lastTime = event.getTime() + event.getDuration();
                    return event;  
                }
                if (hasNext()) {
                    TimeChartEvent event = next;
                    next = null;
                    return event;
                }
                throw new NoSuchElementException();
            }
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
            
    }

    @Override
    public void addTraceEvent(ITimeEvent timeEvent) {
        long time = timeEvent.getTime();
        synchronized (fTraceEvents) {
            long index = (fReferenceTime == -1) ? 0 : (time - fReferenceTime) >> fPower;
            if (index < 0) {
                if (fTraceEvents.capacity() - fTraceEvents.size() < -index) {
                    int powershift = (-index + fTraceEvents.size() <= 2 * fTraceEvents.capacity()) ? 1 :
                        (int) Math.ceil(Math.log((double) (-index + fTraceEvents.size()) / fTraceEvents.capacity()) / Math.log(2));
                    merge(powershift);
                    index = (int) ((time - fReferenceTime) >> fPower);
                }
                shift((int) -index);
                index = 0;
                fTraceEvents.set(0, (TimeChartEvent) timeEvent);
            } else if (index < fTraceEvents.capacity()) {
                if (index >= fTraceEvents.size()) {
                    fTraceEvents.setSize((int) index + 1);
                }
            } else {
                int powershift = (index < 2 * fTraceEvents.capacity()) ? 1 :
                    (int) Math.ceil(Math.log((double) (index + 1) / fTraceEvents.capacity()) / Math.log(2));
                merge(powershift);
                index = (int) ((time - fReferenceTime) >> fPower);
                fTraceEvents.setSize((int) index + 1);
            }
            TimeChartEvent event = (TimeChartEvent) fTraceEvents.get((int) index);
            if (event == null) {
                fTraceEvents.set((int) index, (TimeChartEvent) timeEvent);
            } else {
                if (event.getItemizedEntry() == null) {
                    event.merge((TimeChartEvent) timeEvent);
                } else {
                	event.mergeDecorations((TimeChartEvent) timeEvent);
                    event.getItemizedEntry().addTraceEvent(timeEvent);
                }
            }
            if (fReferenceTime == -1 || time < fReferenceTime) {
                fReferenceTime = (time >> fPower) << fPower;
            }
            if (fStartTime == -1 || time < fStartTime) {
                fStartTime = time;
            }
            if (fStopTime == -1 || time > fStopTime) {
                fStopTime = time;
            }
        }
    }

    private void merge(int powershift) {
        fPower += powershift;
        fReferenceTime = (fReferenceTime >> fPower) << fPower;
        int index = 0;
        for (int i = 0; i < fTraceEvents.size(); i++) {
            TimeChartEvent event = fTraceEvents.get(i);
            if (event != null) {
                index = (int) ((event.getTime() - fReferenceTime) >> fPower);
                TimeChartEvent mergedEvent = (TimeChartEvent) fTraceEvents.get(index);
                if (mergedEvent == null) {
                    fTraceEvents.set(index, event);
                } else {
                    mergedEvent.merge(event);
                }
                if (i != index) {
                    fTraceEvents.set(i, null);
                }
            }
        }
        fTraceEvents.setSize(index + 1);
    }

    private void shift(int indexshift) {
        int oldSize = fTraceEvents.size();
        fTraceEvents.setSize(oldSize + indexshift);
        for (int i = oldSize - 1; i >= 0; i--) {
            fTraceEvents.set(i + indexshift, fTraceEvents.get(i));
        }
        for (int i = 0; i < indexshift; i++) {
            fTraceEvents.set(i, null);
        }
    }
    
    public ITmfTrace getTrace() {
        return fTrace;
    }
    
    public void setLastRank(long rank) {
        fLastRank = rank;
    }
    
    public long getLastRank() {
        return fLastRank;
    }
}

Return to bug 325016

Line 0 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisEntry.java (+237 lines)
		1	package org.eclipse.linuxtools.tmf.ui.views.timechart;
		2
		3	import java.util.Iterator;
		4	import java.util.NoSuchElementException;
		5	import java.util.Vector;
		6
		7	import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
		8	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
		9	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
		10
		11	public class TimeChartAnalysisEntry implements ITmfTimeAnalysisEntry {
		12
		13	private ITmfTrace fTrace;
		14	private String fGroup;
		15	private Vector<TimeChartEvent> fTraceEvents;
		16	private int fPower = 0; // 2^fPower nanoseconds per vector position
		17	private long fReferenceTime = -1; // time corresponding to beginning of index 0
		18	private long fStartTime = -1; // time of first event
		19	private long fStopTime = -1; // time of last event
		20	private long fLastRank = -1; // rank of last processed trace event
		21
		22	TimeChartAnalysisEntry(ITmfTrace trace, int modelSize) {
		23	fTrace = trace;
		24	fTraceEvents = new Vector<TimeChartEvent>(modelSize);
		25	}
		26
		27	TimeChartAnalysisEntry(ITmfTrace trace, String group, int modelSize) {
		28	fTrace = trace;
		29	fTraceEvents = new Vector<TimeChartEvent>(modelSize);
		30	fGroup = group;
		31	}
		32
		33	@Override
		34	public String getGroupName() {
		35	return fGroup;
		36	}
		37
		38	@Override
		39	public int getId() {
		40	// TODO Auto-generated method stub
		41	return 0;
		42	}
		43
		44	@Override
		45	public String getName() {
		46	return fTrace.getName();
		47	}
		48
		49	@Override
		50	public long getStartTime() {
		51	return fStartTime;
		52	}
		53
		54	@Override
		55	public long getStopTime() {
		56	return fStopTime;
		57	}
		58
		59	@Override
		60	@Deprecated public <T extends ITimeEvent> Vector<T> getTraceEvents() {
		61	return null;
		62	}
		63
		64	@Override
65	public Iterator<ITimeEvent> getTraceEventsIterator() {
66	return new EntryIterator(0, Long.MAX_VALUE, 0);
67	}
68
69	@Override
70	public Iterator<ITimeEvent> getTraceEventsIterator(long startTime, long stopTime, long maxDuration) {
71	return new EntryIterator(startTime, stopTime, maxDuration);
72	}
73
74	private class EntryIterator implements Iterator<ITimeEvent> {
75	private final long fIteratorStartTime;
76	private final long fIteratorStopTime;
77	private final long fIteratorMaxDuration;
78	private long lastTime = -1;
79	private TimeChartEvent next = null;
80	private Iterator<ITimeEvent> nestedIterator = null;
81
82	public EntryIterator(long startTime, long stopTime, long maxDuration) {
83	fIteratorStartTime = startTime;
84	fIteratorStopTime = stopTime;
85	fIteratorMaxDuration = maxDuration;
86	}
87
88	@Override
89	public boolean hasNext() {
90	synchronized (fTraceEvents) {
91	if (next != null) return true;
92	if (nestedIterator != null) {
93	if (nestedIterator.hasNext()) {
94	return true;
95	} else {
96	nestedIterator = null;
97	}
98	}
99	long time = (lastTime == -1) ? fStartTime : lastTime;
100	int index = (fReferenceTime == -1) ? 0 : (int) ((time - fReferenceTime) >> fPower);
101	while (index < fTraceEvents.size()) {
102	TimeChartEvent event = fTraceEvents.get(index++);
103	if (event != null && (lastTime == -1 \|\| event.getTime() > time)) {
104	if (event.getTime() + event.getDuration() >= fIteratorStartTime && event.getTime() <= fIteratorStopTime) {
105	if (event.getItemizedEntry() == null \|\| event.getDuration() <= fIteratorMaxDuration) {
106	lastTime = event.getTime() + event.getDuration();
107	next = event;
108	return true;
109	} else {
110	nestedIterator = event.getItemizedEntry().getTraceEventsIterator(fIteratorStartTime, fIteratorStopTime, fIteratorMaxDuration);
111	return nestedIterator.hasNext();
112	}
113	}
114	}
115	}
116	return false;
117	}
118	}
119
120	@Override
121	public TimeChartEvent next() {
122	synchronized (fTraceEvents) {
123	if (nestedIterator != null) {
124	TimeChartEvent event = (TimeChartEvent) nestedIterator.next();
125	lastTime = event.getTime() + event.getDuration();
126	return event;
127	}
128	if (hasNext()) {
129	TimeChartEvent event = next;
130	next = null;
131	return event;
132	}
133	throw new NoSuchElementException();
134	}
135	}
136
137	@Override
138	public void remove() {
139	throw new UnsupportedOperationException();
140	}
141
142	}
143
144	@Override
145	public void addTraceEvent(ITimeEvent timeEvent) {
146	long time = timeEvent.getTime();
147	synchronized (fTraceEvents) {
148	long index = (fReferenceTime == -1) ? 0 : (time - fReferenceTime) >> fPower;
149	if (index < 0) {
150	if (fTraceEvents.capacity() - fTraceEvents.size() < -index) {
151	int powershift = (-index + fTraceEvents.size() <= 2 * fTraceEvents.capacity()) ? 1 :
152	(int) Math.ceil(Math.log((double) (-index + fTraceEvents.size()) / fTraceEvents.capacity()) / Math.log(2));
153	merge(powershift);
154	index = (int) ((time - fReferenceTime) >> fPower);
155	}
156	shift((int) -index);
157	index = 0;
158	fTraceEvents.set(0, (TimeChartEvent) timeEvent);
159	} else if (index < fTraceEvents.capacity()) {
160	if (index >= fTraceEvents.size()) {
161	fTraceEvents.setSize((int) index + 1);
162	}
163	} else {
164	int powershift = (index < 2 * fTraceEvents.capacity()) ? 1 :
165	(int) Math.ceil(Math.log((double) (index + 1) / fTraceEvents.capacity()) / Math.log(2));
166	merge(powershift);
167	index = (int) ((time - fReferenceTime) >> fPower);
168	fTraceEvents.setSize((int) index + 1);
169	}
170	TimeChartEvent event = (TimeChartEvent) fTraceEvents.get((int) index);
171	if (event == null) {
172	fTraceEvents.set((int) index, (TimeChartEvent) timeEvent);
173	} else {
174	if (event.getItemizedEntry() == null) {
175	event.merge((TimeChartEvent) timeEvent);
176	} else {
177	event.mergeDecorations((TimeChartEvent) timeEvent);
178	event.getItemizedEntry().addTraceEvent(timeEvent);
179	}
180	}
181	if (fReferenceTime == -1 \|\| time < fReferenceTime) {
182	fReferenceTime = (time >> fPower) << fPower;
183	}
184	if (fStartTime == -1 \|\| time < fStartTime) {
185	fStartTime = time;
186	}
187	if (fStopTime == -1 \|\| time > fStopTime) {
188	fStopTime = time;
189	}
190	}
191	}
192
193	private void merge(int powershift) {
194	fPower += powershift;
195	fReferenceTime = (fReferenceTime >> fPower) << fPower;
196	int index = 0;
197	for (int i = 0; i < fTraceEvents.size(); i++) {
198	TimeChartEvent event = fTraceEvents.get(i);
199	if (event != null) {
200	index = (int) ((event.getTime() - fReferenceTime) >> fPower);
201	TimeChartEvent mergedEvent = (TimeChartEvent) fTraceEvents.get(index);
202	if (mergedEvent == null) {
203	fTraceEvents.set(index, event);
204	} else {
205	mergedEvent.merge(event);
206	}
207	if (i != index) {
208	fTraceEvents.set(i, null);
209	}
210	}
211	}
212	fTraceEvents.setSize(index + 1);
213	}
214
215	private void shift(int indexshift) {
216	int oldSize = fTraceEvents.size();
217	fTraceEvents.setSize(oldSize + indexshift);
218	for (int i = oldSize - 1; i >= 0; i--) {
219	fTraceEvents.set(i + indexshift, fTraceEvents.get(i));
220	}
221	for (int i = 0; i < indexshift; i++) {
222	fTraceEvents.set(i, null);
223	}
224	}
225
226	public ITmfTrace getTrace() {
227	return fTrace;
228	}
229
230	public void setLastRank(long rank) {
231	fLastRank = rank;
232	}
233
234	public long getLastRank() {
235	return fLastRank;
236	}
237	}