[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / views / timechart / TimeChartAnalysisEntry.java

/*******************************************************************************\r
 * Copyright (c) 2010 Ericsson\r
 *\r
 * All rights reserved. This program and the accompanying materials are\r
 * made available under the terms of the Eclipse Public License v1.0 which\r
 * accompanies this distribution, and is available at\r
 * http://www.eclipse.org/legal/epl-v10.html\r
 *\r
 * Contributors:\r
 *   Patrick Tasse - Initial API and implementation\r
 *******************************************************************************/\r
\r
package org.eclipse.linuxtools.tmf.ui.views.timechart;\r
\r
import java.util.Iterator;\r
import java.util.NoSuchElementException;\r
import java.util.Vector;\r
\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;\r
\r
/**\r
 * An entry (row) in the time chart analysis view\r
 *\r
 * @version 1.0\r
 * @author Patrick Tasse\r
 */\r
public class TimeChartAnalysisEntry implements ITimeGraphEntry {\r
\r
    private final ITmfTrace<?> fTrace;\r
    private final Vector<TimeChartEvent> fTraceEvents;\r
    private int fPower = 0; // 2^fPower nanoseconds per vector position\r
    private long fReferenceTime = -1; // time corresponding to beginning of index 0\r
    private long fStartTime = -1; // time of first event\r
    private long fStopTime = -1; // time of last event\r
    private long fLastRank = -1; // rank of last processed trace event\r
\r
    TimeChartAnalysisEntry(ITmfTrace<?> trace, int modelSize) {\r
        fTrace = trace;\r
        fTraceEvents = new Vector<TimeChartEvent>(modelSize);\r
    }\r
\r
    @Override\r
    public ITimeGraphEntry[] getChildren() {\r
        return null;\r
    }\r
\r
    @Override\r
    public ITimeGraphEntry getParent() {\r
        return null;\r
    }\r
\r
    @Override\r
    public boolean hasChildren() {\r
        return false;\r
    }\r
\r
    @Override\r
    public String getName() {\r
        return fTrace.getName();\r
    }\r
\r
    @Override\r
    public long getStartTime() {\r
        return fStartTime;\r
    }\r
\r
    @Override\r
    public long getEndTime() {\r
        return fStopTime;\r
    }\r
\r
    @Override\r
    public boolean hasTimeEvents() {\r
        return true;\r
    }\r
\r
    @Override\r
    public Iterator<ITimeEvent> getTimeEventsIterator() {\r
        return new EntryIterator(0, Long.MAX_VALUE, 0);\r
    }\r
\r
    @Override\r
    public Iterator<ITimeEvent> getTimeEventsIterator(long startTime, long stopTime, long maxDuration) {\r
        return new EntryIterator(startTime, stopTime, maxDuration);\r
    }\r
\r
    private class EntryIterator implements Iterator<ITimeEvent> {\r
        private final long fIteratorStartTime;\r
        private final long fIteratorStopTime;\r
        private final long fIteratorMaxDuration;\r
        private long lastTime = -1;\r
        private TimeChartEvent next = null;\r
        private Iterator<ITimeEvent> nestedIterator = null;\r
\r
        public EntryIterator(long startTime, long stopTime, long maxDuration) {\r
            fIteratorStartTime = startTime;\r
            fIteratorStopTime = stopTime;\r
            fIteratorMaxDuration = maxDuration;\r
        }\r
\r
        @Override\r
        public boolean hasNext() {\r
            synchronized (fTraceEvents) {\r
                if (next != null) {\r
                    return true;\r
                }\r
                if (nestedIterator != null) {\r
                    if (nestedIterator.hasNext()) {\r
                        return true;\r
                    } else {\r
                        nestedIterator = null;\r
                    }\r
                }\r
                long time = (lastTime == -1) ? fStartTime : lastTime;\r
                int index = (fReferenceTime == -1) ? 0 : (int) ((time - fReferenceTime) >> fPower);\r
                while (index < fTraceEvents.size()) {\r
                    TimeChartEvent event = fTraceEvents.get(index++);\r
                    if (event != null && (lastTime == -1 || event.getTime() > time)) {\r
                        if (event.getTime() + event.getDuration() >= fIteratorStartTime && event.getTime() <= fIteratorStopTime) {\r
                            if (event.getItemizedEntry() == null || event.getDuration() <= fIteratorMaxDuration) {\r
                                lastTime = event.getTime() + event.getDuration();\r
                                next = event;\r
                                return true;\r
                            } else {\r
                                nestedIterator = event.getItemizedEntry().getTimeEventsIterator(fIteratorStartTime, fIteratorStopTime, fIteratorMaxDuration);\r
                                return nestedIterator.hasNext();\r
                            }\r
                        }\r
                    }\r
                }\r
                return false;\r
            }\r
        }\r
\r
        @Override\r
        public TimeChartEvent next() {\r
            synchronized (fTraceEvents) {\r
                if (nestedIterator != null) {\r
                    TimeChartEvent event = (TimeChartEvent) nestedIterator.next();\r
                    lastTime = event.getTime() + event.getDuration();\r
                    return event;\r
                }\r
                if (hasNext()) {\r
                    TimeChartEvent event = next;\r
                    next = null;\r
                    return event;\r
                }\r
                throw new NoSuchElementException();\r
            }\r
        }\r
\r
        @Override\r
        public void remove() {\r
            throw new UnsupportedOperationException();\r
        }\r
\r
    }\r
\r
    /**\r
     * Add a time event to the time chart entry\r
     *\r
     * @param timeEvent\r
     *            The event to add\r
     */\r
    public void addTraceEvent(ITimeEvent timeEvent) {\r
        long time = timeEvent.getTime();\r
        synchronized (fTraceEvents) {\r
            long index = (fReferenceTime == -1) ? 0 : (time - fReferenceTime) >> fPower;\r
            if (index < 0) {\r
                if (fTraceEvents.capacity() - fTraceEvents.size() < -index) {\r
                    int powershift = (-index + fTraceEvents.size() <= 2 * fTraceEvents.capacity()) ? 1 :\r
                        (int) Math.ceil(Math.log((double) (-index + fTraceEvents.size()) / fTraceEvents.capacity()) / Math.log(2));\r
                    merge(powershift);\r
                    index = (int) ((time - fReferenceTime) >> fPower);\r
                }\r
                shift((int) -index);\r
                index = 0;\r
                fTraceEvents.set(0, (TimeChartEvent) timeEvent);\r
            } else if (index < fTraceEvents.capacity()) {\r
                if (index >= fTraceEvents.size()) {\r
                    fTraceEvents.setSize((int) index + 1);\r
                }\r
            } else {\r
                int powershift = (index < 2 * fTraceEvents.capacity()) ? 1 :\r
                    (int) Math.ceil(Math.log((double) (index + 1) / fTraceEvents.capacity()) / Math.log(2));\r
                merge(powershift);\r
                index = (int) ((time - fReferenceTime) >> fPower);\r
                fTraceEvents.setSize((int) index + 1);\r
            }\r
            TimeChartEvent event = (TimeChartEvent) fTraceEvents.get((int) index);\r
            if (event == null) {\r
                fTraceEvents.set((int) index, (TimeChartEvent) timeEvent);\r
            } else {\r
                if (event.getItemizedEntry() == null) {\r
                    event.merge((TimeChartEvent) timeEvent);\r
                } else {\r
                	event.mergeDecorations((TimeChartEvent) timeEvent);\r
                    event.getItemizedEntry().addTraceEvent(timeEvent);\r
                }\r
            }\r
            if (fReferenceTime == -1 || time < fReferenceTime) {\r
                fReferenceTime = (time >> fPower) << fPower;\r
            }\r
            if (fStartTime == -1 || time < fStartTime) {\r
                fStartTime = time;\r
            }\r
            if (fStopTime == -1 || time > fStopTime) {\r
                fStopTime = time;\r
            }\r
        }\r
    }\r
\r
    private void merge(int powershift) {\r
        fPower += powershift;\r
        fReferenceTime = (fReferenceTime >> fPower) << fPower;\r
        int index = 0;\r
        for (int i = 0; i < fTraceEvents.size(); i++) {\r
            TimeChartEvent event = fTraceEvents.get(i);\r
            if (event != null) {\r
                index = (int) ((event.getTime() - fReferenceTime) >> fPower);\r
                TimeChartEvent mergedEvent = (TimeChartEvent) fTraceEvents.get(index);\r
                if (mergedEvent == null) {\r
                    fTraceEvents.set(index, event);\r
                } else {\r
                    mergedEvent.merge(event);\r
                }\r
                if (i != index) {\r
                    fTraceEvents.set(i, null);\r
                }\r
            }\r
        }\r
        fTraceEvents.setSize(index + 1);\r
    }\r
\r
    private void shift(int indexshift) {\r
        int oldSize = fTraceEvents.size();\r
        fTraceEvents.setSize(oldSize + indexshift);\r
        for (int i = oldSize - 1; i >= 0; i--) {\r
            fTraceEvents.set(i + indexshift, fTraceEvents.get(i));\r
        }\r
        for (int i = 0; i < indexshift; i++) {\r
            fTraceEvents.set(i, null);\r
        }\r
    }\r
\r
    /**\r
     * Retrieve the trace associated with this entry\r
     *\r
     * @return The trace object\r
     */\r
    public ITmfTrace<?> getTrace() {\r
        return fTrace;\r
    }\r
\r
    /**\r
     * Set the last rank of the entry\r
     *\r
     * @param rank\r
     *            The rank to set\r
     */\r
    public void setLastRank(long rank) {\r
        fLastRank = rank;\r
    }\r
\r
    /**\r
     * Retrieve the last rank of the entry\r
     *\r
     * @return The last rank\r
     */\r
    public long getLastRank() {\r
        return fLastRank;\r
    }\r
}\r
Commit	Line	Data
ce62370f FC	1	/*******************************************************************************\r
ce62370f FC	2	* Copyright (c) 2010 Ericsson\r
013a5f1c	3	*\r
ce62370f FC	4	* All rights reserved. This program and the accompanying materials are\r
	5	* made available under the terms of the Eclipse Public License v1.0 which\r
	6	* accompanies this distribution, and is available at\r
	7	* http://www.eclipse.org/legal/epl-v10.html\r
013a5f1c	8	*\r
ce62370f FC	9	* Contributors:\r
	10	* Patrick Tasse - Initial API and implementation\r
	11	*******************************************************************************/\r
	12	\r
	13	package org.eclipse.linuxtools.tmf.ui.views.timechart;\r
	14	\r
	15	import java.util.Iterator;\r
	16	import java.util.NoSuchElementException;\r
	17	import java.util.Vector;\r
	18	\r
6c13869b	19	import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
2fa130b8	20	import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;\r
fb5cad3d	21	import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;\r
ce62370f	22	\r
013a5f1c AM	23	/**\r
	24	* An entry (row) in the time chart analysis view\r
	25	*\r
	26	* @version 1.0\r
	27	* @author Patrick Tasse\r
	28	*/\r
fb5cad3d	29	public class TimeChartAnalysisEntry implements ITimeGraphEntry {\r
ce62370f	30	\r
013a5f1c AM	31	private final ITmfTrace<?> fTrace;\r
013a5f1c AM	32	private final Vector<TimeChartEvent> fTraceEvents;\r
ce62370f FC	33	private int fPower = 0; // 2^fPower nanoseconds per vector position\r
	34	private long fReferenceTime = -1; // time corresponding to beginning of index 0\r
	35	private long fStartTime = -1; // time of first event\r
	36	private long fStopTime = -1; // time of last event\r
	37	private long fLastRank = -1; // rank of last processed trace event\r
	38	\r
828e5592	39	TimeChartAnalysisEntry(ITmfTrace<?> trace, int modelSize) {\r
ce62370f FC	40	fTrace = trace;\r
	41	fTraceEvents = new Vector<TimeChartEvent>(modelSize);\r
	42	}\r
013a5f1c	43	\r
fb5cad3d PT	44	@Override\r
	45	public ITimeGraphEntry[] getChildren() {\r
	46	return null;\r
ce62370f	47	}\r
fb5cad3d	48	\r
ce62370f	49	@Override\r
fb5cad3d PT	50	public ITimeGraphEntry getParent() {\r
fb5cad3d PT	51	return null;\r
ce62370f FC	52	}\r
	53	\r
	54	@Override\r
fb5cad3d PT	55	public boolean hasChildren() {\r
fb5cad3d PT	56	return false;\r
ce62370f FC	57	}\r
	58	\r
	59	@Override\r
	60	public String getName() {\r
	61	return fTrace.getName();\r
	62	}\r
	63	\r
	64	@Override\r
	65	public long getStartTime() {\r
	66	return fStartTime;\r
	67	}\r
	68	\r
	69	@Override\r
b83af2c3	70	public long getEndTime() {\r
ce62370f FC	71	return fStopTime;\r
	72	}\r
	73	\r
bc51e30c PT	74	@Override\r
	75	public boolean hasTimeEvents() {\r
	76	return true;\r
	77	}\r
	78	\r
ce62370f	79	@Override\r
fb5cad3d	80	public Iterator<ITimeEvent> getTimeEventsIterator() {\r
ce62370f FC	81	return new EntryIterator(0, Long.MAX_VALUE, 0);\r
ce62370f FC	82	}\r
013a5f1c	83	\r
ce62370f	84	@Override\r
fb5cad3d	85	public Iterator<ITimeEvent> getTimeEventsIterator(long startTime, long stopTime, long maxDuration) {\r
ce62370f FC	86	return new EntryIterator(startTime, stopTime, maxDuration);\r
ce62370f FC	87	}\r
013a5f1c	88	\r
ce62370f FC	89	private class EntryIterator implements Iterator<ITimeEvent> {\r
	90	private final long fIteratorStartTime;\r
	91	private final long fIteratorStopTime;\r
	92	private final long fIteratorMaxDuration;\r
	93	private long lastTime = -1;\r
	94	private TimeChartEvent next = null;\r
	95	private Iterator<ITimeEvent> nestedIterator = null;\r
013a5f1c	96	\r
ce62370f FC	97	public EntryIterator(long startTime, long stopTime, long maxDuration) {\r
	98	fIteratorStartTime = startTime;\r
	99	fIteratorStopTime = stopTime;\r
	100	fIteratorMaxDuration = maxDuration;\r
	101	}\r
013a5f1c	102	\r
ce62370f FC	103	@Override\r
	104	public boolean hasNext() {\r
	105	synchronized (fTraceEvents) {\r
013a5f1c AM	106	if (next != null) {\r
	107	return true;\r
	108	}\r
ce62370f FC	109	if (nestedIterator != null) {\r
	110	if (nestedIterator.hasNext()) {\r
	111	return true;\r
	112	} else {\r
	113	nestedIterator = null;\r
	114	}\r
	115	}\r
	116	long time = (lastTime == -1) ? fStartTime : lastTime;\r
	117	int index = (fReferenceTime == -1) ? 0 : (int) ((time - fReferenceTime) >> fPower);\r
	118	while (index < fTraceEvents.size()) {\r
	119	TimeChartEvent event = fTraceEvents.get(index++);\r
	120	if (event != null && (lastTime == -1 \|\| event.getTime() > time)) {\r
	121	if (event.getTime() + event.getDuration() >= fIteratorStartTime && event.getTime() <= fIteratorStopTime) {\r
	122	if (event.getItemizedEntry() == null \|\| event.getDuration() <= fIteratorMaxDuration) {\r
	123	lastTime = event.getTime() + event.getDuration();\r
	124	next = event;\r
	125	return true;\r
	126	} else {\r
fb5cad3d	127	nestedIterator = event.getItemizedEntry().getTimeEventsIterator(fIteratorStartTime, fIteratorStopTime, fIteratorMaxDuration);\r
ce62370f FC	128	return nestedIterator.hasNext();\r
	129	}\r
	130	}\r
	131	}\r
	132	}\r
	133	return false;\r
	134	}\r
	135	}\r
	136	\r
	137	@Override\r
	138	public TimeChartEvent next() {\r
	139	synchronized (fTraceEvents) {\r
	140	if (nestedIterator != null) {\r
	141	TimeChartEvent event = (TimeChartEvent) nestedIterator.next();\r
	142	lastTime = event.getTime() + event.getDuration();\r
013a5f1c	143	return event;\r
ce62370f FC	144	}\r
	145	if (hasNext()) {\r
	146	TimeChartEvent event = next;\r
	147	next = null;\r
	148	return event;\r
	149	}\r
	150	throw new NoSuchElementException();\r
	151	}\r
	152	}\r
	153	\r
	154	@Override\r
	155	public void remove() {\r
	156	throw new UnsupportedOperationException();\r
	157	}\r
013a5f1c	158	\r
ce62370f FC	159	}\r
ce62370f FC	160	\r
20ff3b75 AM	161	/**\r
	162	* Add a time event to the time chart entry\r
	163	*\r
	164	* @param timeEvent\r
	165	* The event to add\r
	166	*/\r
ce62370f FC	167	public void addTraceEvent(ITimeEvent timeEvent) {\r
	168	long time = timeEvent.getTime();\r
	169	synchronized (fTraceEvents) {\r
	170	long index = (fReferenceTime == -1) ? 0 : (time - fReferenceTime) >> fPower;\r
	171	if (index < 0) {\r
	172	if (fTraceEvents.capacity() - fTraceEvents.size() < -index) {\r
	173	int powershift = (-index + fTraceEvents.size() <= 2 * fTraceEvents.capacity()) ? 1 :\r
	174	(int) Math.ceil(Math.log((double) (-index + fTraceEvents.size()) / fTraceEvents.capacity()) / Math.log(2));\r
	175	merge(powershift);\r
	176	index = (int) ((time - fReferenceTime) >> fPower);\r
	177	}\r
	178	shift((int) -index);\r
	179	index = 0;\r
	180	fTraceEvents.set(0, (TimeChartEvent) timeEvent);\r
	181	} else if (index < fTraceEvents.capacity()) {\r
	182	if (index >= fTraceEvents.size()) {\r
	183	fTraceEvents.setSize((int) index + 1);\r
	184	}\r
	185	} else {\r
	186	int powershift = (index < 2 * fTraceEvents.capacity()) ? 1 :\r
	187	(int) Math.ceil(Math.log((double) (index + 1) / fTraceEvents.capacity()) / Math.log(2));\r
	188	merge(powershift);\r
	189	index = (int) ((time - fReferenceTime) >> fPower);\r
	190	fTraceEvents.setSize((int) index + 1);\r
	191	}\r
	192	TimeChartEvent event = (TimeChartEvent) fTraceEvents.get((int) index);\r
	193	if (event == null) {\r
	194	fTraceEvents.set((int) index, (TimeChartEvent) timeEvent);\r
	195	} else {\r
	196	if (event.getItemizedEntry() == null) {\r
	197	event.merge((TimeChartEvent) timeEvent);\r
	198	} else {\r
	199	event.mergeDecorations((TimeChartEvent) timeEvent);\r
	200	event.getItemizedEntry().addTraceEvent(timeEvent);\r
	201	}\r
	202	}\r
	203	if (fReferenceTime == -1 \|\| time < fReferenceTime) {\r
	204	fReferenceTime = (time >> fPower) << fPower;\r
	205	}\r
	206	if (fStartTime == -1 \|\| time < fStartTime) {\r
	207	fStartTime = time;\r
	208	}\r
	209	if (fStopTime == -1 \|\| time > fStopTime) {\r
	210	fStopTime = time;\r
	211	}\r
	212	}\r
	213	}\r
	214	\r
	215	private void merge(int powershift) {\r
	216	fPower += powershift;\r
	217	fReferenceTime = (fReferenceTime >> fPower) << fPower;\r
	218	int index = 0;\r
	219	for (int i = 0; i < fTraceEvents.size(); i++) {\r
	220	TimeChartEvent event = fTraceEvents.get(i);\r
	221	if (event != null) {\r
	222	index = (int) ((event.getTime() - fReferenceTime) >> fPower);\r
	223	TimeChartEvent mergedEvent = (TimeChartEvent) fTraceEvents.get(index);\r
	224	if (mergedEvent == null) {\r
	225	fTraceEvents.set(index, event);\r
	226	} else {\r
	227	mergedEvent.merge(event);\r
	228	}\r
	229	if (i != index) {\r
	230	fTraceEvents.set(i, null);\r
231	}\r
232	}\r
233	}\r
234	fTraceEvents.setSize(index + 1);\r
235	}\r
236	\r
237	private void shift(int indexshift) {\r
238	int oldSize = fTraceEvents.size();\r
239	fTraceEvents.setSize(oldSize + indexshift);\r
240	for (int i = oldSize - 1; i >= 0; i--) {\r
241	fTraceEvents.set(i + indexshift, fTraceEvents.get(i));\r
242	}\r
243	for (int i = 0; i < indexshift; i++) {\r
244	fTraceEvents.set(i, null);\r
245	}\r
246	}\r
013a5f1c	247	\r
20ff3b75 AM	248	/**\r
	249	* Retrieve the trace associated with this entry\r
	250	*\r
	251	* @return The trace object\r
	252	*/\r
828e5592	253	public ITmfTrace<?> getTrace() {\r
ce62370f FC	254	return fTrace;\r
ce62370f FC	255	}\r
013a5f1c	256	\r
20ff3b75 AM	257	/**\r
	258	* Set the last rank of the entry\r
	259	*\r
	260	* @param rank\r
	261	* The rank to set\r
	262	*/\r
ce62370f FC	263	public void setLastRank(long rank) {\r
	264	fLastRank = rank;\r
	265	}\r
013a5f1c	266	\r
20ff3b75 AM	267	/**\r
	268	* Retrieve the last rank of the entry\r
	269	*\r
	270	* @return The last rank\r
	271	*/\r
ce62370f FC	272	public long getLastRank() {\r
	273	return fLastRank;\r
	274	}\r
	275	}\r