Commit | Line | Data |
---|---|---|
fc526aef AM |
1 | /******************************************************************************* |
2 | * Copyright (c) 2013 Ericsson | |
3 | * | |
4 | * All rights reserved. This program and the accompanying materials are | |
5 | * made available under the terms of the Eclipse Public License v1.0 which | |
6 | * accompanies this distribution, and is available at | |
7 | * http://www.eclipse.org/legal/epl-v10.html | |
8 | * | |
9 | * Contributors: | |
10 | * Alexandre Montplaisir - Initial API and implementation | |
11 | *******************************************************************************/ | |
12 | ||
13 | package org.eclipse.linuxtools.tmf.core.trace; | |
14 | ||
e1385db9 | 15 | import java.io.File; |
fab18d20 | 16 | import java.util.Collections; |
fc526aef AM |
17 | import java.util.LinkedHashMap; |
18 | import java.util.Map; | |
fab18d20 | 19 | import java.util.Set; |
fc526aef | 20 | |
e1385db9 AM |
21 | import org.eclipse.core.resources.IResource; |
22 | import org.eclipse.core.runtime.CoreException; | |
23 | import org.eclipse.linuxtools.tmf.core.TmfCommonConstants; | |
fc526aef AM |
24 | import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal; |
25 | import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler; | |
26 | import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager; | |
27 | import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal; | |
28 | import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal; | |
29 | import org.eclipse.linuxtools.tmf.core.signal.TmfTraceOpenedSignal; | |
30 | import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal; | |
31 | import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp; | |
32 | import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange; | |
33 | import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp; | |
34 | ||
35 | /** | |
36 | * Central trace manager for TMF. It tracks the currently opened traces and | |
37 | * experiment, as well as the currently-selected timestamps and time ranges for | |
38 | * each one of those. | |
39 | * | |
40 | * It's a singleton class, so only one instance should exist (available via | |
41 | * {@link #getInstance()}). | |
42 | * | |
43 | * @author Alexandre Montplaisir | |
44 | * @since 2.0 | |
45 | */ | |
46 | public final class TmfTraceManager { | |
47 | ||
48 | // ------------------------------------------------------------------------ | |
49 | // Attributes | |
50 | // ------------------------------------------------------------------------ | |
51 | ||
52 | private final Map<ITmfTrace, TmfTraceContext> fTraces; | |
53 | ||
54 | /** The currently-selected trace. Should always be part of the trace map */ | |
55 | private ITmfTrace fCurrentTrace = null; | |
56 | ||
57 | // ------------------------------------------------------------------------ | |
58 | // Constructor | |
59 | // ------------------------------------------------------------------------ | |
60 | ||
61 | private TmfTraceManager() { | |
62 | fTraces = new LinkedHashMap<ITmfTrace, TmfTraceContext>(); | |
63 | TmfSignalManager.registerVIP(this); | |
64 | } | |
65 | ||
66 | /** Singleton instance */ | |
67 | private static TmfTraceManager tm = null; | |
68 | ||
69 | /** | |
70 | * Get an instance of the trace manager. | |
71 | * | |
72 | * @return The trace manager | |
73 | */ | |
74 | public static synchronized TmfTraceManager getInstance() { | |
75 | if (tm == null) { | |
76 | tm = new TmfTraceManager(); | |
77 | } | |
78 | return tm; | |
79 | } | |
80 | ||
81 | // ------------------------------------------------------------------------ | |
82 | // Accessors | |
83 | // ------------------------------------------------------------------------ | |
84 | ||
85 | /** | |
86 | * Return the current selected time. | |
87 | * | |
88 | * @return the current time stamp | |
89 | */ | |
90 | public synchronized ITmfTimestamp getCurrentTime() { | |
91 | return getCurrentTraceContext().getTimestamp(); | |
92 | } | |
93 | ||
94 | /** | |
95 | * Return the current selected range. | |
96 | * | |
97 | * @return the current time range | |
98 | */ | |
99 | public synchronized TmfTimeRange getCurrentRange() { | |
100 | return getCurrentTraceContext().getTimerange(); | |
101 | } | |
102 | ||
103 | /** | |
104 | * Get the currently selected trace (normally, the focused editor). | |
105 | * | |
106 | * @return The active trace | |
107 | */ | |
108 | public synchronized ITmfTrace getActiveTrace() { | |
109 | return fCurrentTrace; | |
110 | } | |
111 | ||
112 | /** | |
a6fc3a28 | 113 | * Get the trace set of the currently active trace. |
fc526aef AM |
114 | * |
115 | * @return The active trace set | |
a6fc3a28 | 116 | * @see #getTraceSet(ITmfTrace) |
fc526aef AM |
117 | */ |
118 | public synchronized ITmfTrace[] getActiveTraceSet() { | |
119 | final ITmfTrace trace = fCurrentTrace; | |
a6fc3a28 | 120 | return getTraceSet(trace); |
fc526aef AM |
121 | } |
122 | ||
fab18d20 AM |
123 | /** |
124 | * Get the currently-opened traces, as an unmodifiable set. | |
125 | * | |
126 | * @return A set containing the opened traces | |
127 | */ | |
128 | public synchronized Set<ITmfTrace> getOpenedTraces() { | |
129 | return Collections.unmodifiableSet(fTraces.keySet()); | |
130 | } | |
131 | ||
fc526aef AM |
132 | private TmfTraceContext getCurrentTraceContext() { |
133 | TmfTraceContext curCtx = fTraces.get(fCurrentTrace); | |
134 | if (curCtx == null) { | |
135 | /* There are no traces opened at the moment. */ | |
136 | return TmfTraceContext.NULL_CONTEXT; | |
137 | } | |
138 | return curCtx; | |
139 | } | |
140 | ||
e1385db9 AM |
141 | // ------------------------------------------------------------------------ |
142 | // Public utility methods | |
143 | // ------------------------------------------------------------------------ | |
144 | ||
a6fc3a28 AM |
145 | /** |
146 | * Get the trace set of a given trace. For a standard trace, this is simply | |
147 | * an array with only that trace in it. For experiments, this is an array of | |
148 | * all the traces contained in this experiment. | |
149 | * | |
150 | * @param trace | |
151 | * The trace or experiment | |
152 | * @return The corresponding trace set | |
153 | */ | |
154 | public static ITmfTrace[] getTraceSet(ITmfTrace trace) { | |
155 | if (trace == null) { | |
156 | return null; | |
157 | } | |
158 | if (trace instanceof TmfExperiment) { | |
159 | TmfExperiment exp = (TmfExperiment) trace; | |
160 | return exp.getTraces(); | |
161 | } | |
162 | return new ITmfTrace[] { trace }; | |
163 | } | |
164 | ||
e1385db9 AM |
165 | /** |
166 | * Return the path (as a string) to the directory for supplementary files to | |
167 | * use with a given trace. If no supplementary file directory has been | |
168 | * configured, a temporary directory based on the trace's name will be | |
169 | * provided. | |
170 | * | |
171 | * @param trace | |
172 | * The trace | |
173 | * @return The path to the supplementary file directory (trailing slash is | |
174 | * INCLUDED!) | |
175 | */ | |
176 | public static String getSupplementaryFileDir(ITmfTrace trace) { | |
177 | IResource resource = trace.getResource(); | |
178 | if (resource == null) { | |
179 | return getTemporaryDir(trace); | |
180 | } | |
181 | ||
182 | String supplDir = null; | |
183 | try { | |
184 | supplDir = resource.getPersistentProperty(TmfCommonConstants.TRACE_SUPPLEMENTARY_FOLDER); | |
185 | } catch (CoreException e) { | |
186 | return getTemporaryDir(trace); | |
187 | } | |
188 | return supplDir + File.separator; | |
189 | } | |
190 | ||
fc526aef AM |
191 | // ------------------------------------------------------------------------ |
192 | // Signal handlers | |
193 | // ------------------------------------------------------------------------ | |
194 | ||
195 | /** | |
196 | * Signal handler for the traceOpened signal. | |
197 | * | |
198 | * @param signal | |
199 | * The incoming signal | |
200 | */ | |
201 | @TmfSignalHandler | |
202 | public synchronized void traceOpened(final TmfTraceOpenedSignal signal) { | |
203 | final ITmfTrace trace = signal.getTrace(); | |
204 | final ITmfTimestamp startTs = trace.getStartTime(); | |
205 | ||
206 | /* Calculate the initial time range */ | |
207 | final int SCALE = ITmfTimestamp.NANOSECOND_SCALE; | |
208 | long offset = trace.getInitialRangeOffset().normalize(0, SCALE).getValue(); | |
209 | long endTime = startTs.normalize(0, SCALE).getValue() + offset; | |
210 | final TmfTimeRange startTr = new TmfTimeRange(startTs, new TmfTimestamp(endTime, SCALE)); | |
211 | ||
212 | final TmfTraceContext startCtx = new TmfTraceContext(startTs, startTr); | |
213 | ||
214 | fTraces.put(trace, startCtx); | |
215 | ||
216 | /* We also want to set the newly-opened trace as the active trace */ | |
217 | fCurrentTrace = trace; | |
218 | } | |
219 | ||
220 | ||
221 | /** | |
222 | * Handler for the TmfTraceSelectedSignal. | |
223 | * | |
224 | * @param signal | |
225 | * The incoming signal | |
226 | */ | |
227 | @TmfSignalHandler | |
228 | public synchronized void traceSelected(final TmfTraceSelectedSignal signal) { | |
229 | final ITmfTrace newTrace = signal.getTrace(); | |
230 | if (!fTraces.containsKey(newTrace)) { | |
231 | throw new RuntimeException(); | |
232 | } | |
233 | fCurrentTrace = newTrace; | |
234 | } | |
235 | ||
236 | /** | |
237 | * Signal handler for the traceClosed signal. | |
238 | * | |
239 | * @param signal | |
240 | * The incoming signal | |
241 | */ | |
242 | @TmfSignalHandler | |
243 | public synchronized void traceClosed(final TmfTraceClosedSignal signal) { | |
3fcf269e | 244 | fTraces.remove(signal.getTrace()); |
fc526aef AM |
245 | if (fTraces.size() == 0) { |
246 | fCurrentTrace = null; | |
247 | /* | |
248 | * In other cases, we should receive a traceSelected signal that | |
249 | * will indicate which trace is the new one. | |
250 | */ | |
251 | } | |
252 | } | |
253 | ||
254 | /** | |
255 | * Signal handler for the TmfTimeSynchSignal signal. | |
256 | * | |
257 | * The current time of *all* traces whose range contains the requested new | |
258 | * time will be updated. | |
259 | * | |
260 | * @param signal | |
261 | * The incoming signal | |
262 | */ | |
263 | @TmfSignalHandler | |
264 | public synchronized void timeUpdated(final TmfTimeSynchSignal signal) { | |
265 | final ITmfTimestamp ts = signal.getCurrentTime(); | |
266 | ||
267 | for (Map.Entry<ITmfTrace, TmfTraceContext> entry : fTraces.entrySet()) { | |
268 | final ITmfTrace trace = entry.getKey(); | |
269 | if (ts.intersects(getValidTimeRange(trace))) { | |
270 | TmfTraceContext prevCtx = entry.getValue(); | |
271 | TmfTraceContext newCtx = new TmfTraceContext(prevCtx, ts); | |
272 | entry.setValue(newCtx); | |
273 | } | |
274 | } | |
275 | } | |
276 | ||
277 | /** | |
278 | * Signal handler for the TmfRangeSynchSignal signal. | |
279 | * | |
280 | * The current timestamp and timerange of *all* valid traces will be updated | |
281 | * to the new requested times. | |
282 | * | |
283 | * @param signal | |
284 | * The incoming signal | |
285 | */ | |
286 | @TmfSignalHandler | |
287 | public synchronized void timeRangeUpdated(final TmfRangeSynchSignal signal) { | |
288 | final ITmfTimestamp signalTs = signal.getCurrentTime(); | |
289 | ||
290 | for (Map.Entry<ITmfTrace, TmfTraceContext> entry : fTraces.entrySet()) { | |
291 | final ITmfTrace trace = entry.getKey(); | |
292 | final TmfTraceContext curCtx = entry.getValue(); | |
293 | ||
294 | final TmfTimeRange validTr = getValidTimeRange(trace); | |
295 | ||
296 | /* Determine the new time stamp */ | |
297 | ITmfTimestamp newTs; | |
298 | if (signalTs != null && signalTs.intersects(validTr)) { | |
299 | newTs = signalTs; | |
300 | } else { | |
301 | newTs = curCtx.getTimestamp(); | |
302 | } | |
303 | ||
304 | /* Determine the new time range */ | |
305 | TmfTimeRange targetTr = signal.getCurrentRange().getIntersection(validTr); | |
306 | TmfTimeRange newTr = (targetTr == null ? curCtx.getTimerange() : targetTr); | |
307 | ||
308 | /* Update the values */ | |
309 | TmfTraceContext newCtx = new TmfTraceContext(newTs, newTr); | |
310 | entry.setValue(newCtx); | |
311 | } | |
312 | } | |
313 | ||
314 | // ------------------------------------------------------------------------ | |
e1385db9 | 315 | // Private utility methods |
fc526aef AM |
316 | // ------------------------------------------------------------------------ |
317 | ||
318 | /** | |
319 | * Return the valid time range of a trace (not the "current time range", but | |
320 | * the range of all possible valid timestamps). | |
321 | * | |
322 | * For a real trace this is the whole range of the trace. For an experiment, | |
323 | * it goes from the start time of the earliest trace to the end time of the | |
324 | * latest one. | |
325 | * | |
326 | * @param trace | |
327 | * The trace to check for | |
328 | * @return The valid time span, or 'null' if the trace is not valid | |
329 | */ | |
330 | private TmfTimeRange getValidTimeRange(ITmfTrace trace) { | |
331 | if (!fTraces.containsKey(trace)) { | |
332 | /* Trace is not part of the currently opened traces */ | |
333 | return null; | |
334 | } | |
335 | if (!(trace instanceof TmfExperiment)) { | |
336 | /* "trace" is a single trace, return its time range directly */ | |
337 | return trace.getTimeRange(); | |
338 | } | |
339 | final ITmfTrace[] traces = ((TmfExperiment) trace).getTraces(); | |
340 | if (traces.length == 0) { | |
341 | /* We are being trolled */ | |
342 | return null; | |
343 | } | |
344 | if (traces.length == 1) { | |
345 | /* Trace is an experiment with only 1 trace */ | |
346 | return traces[0].getTimeRange(); | |
347 | } | |
348 | /* | |
349 | * Trace is an experiment with 2+ traces, so get the earliest start and | |
350 | * the latest end. | |
351 | */ | |
352 | ITmfTimestamp start = traces[0].getStartTime(); | |
353 | ITmfTimestamp end = traces[0].getEndTime(); | |
354 | for (int i = 1; i < traces.length; i++) { | |
355 | ITmfTrace curTrace = traces[i]; | |
356 | if (curTrace.getStartTime().compareTo(start) < 0) { | |
357 | start = curTrace.getStartTime(); | |
358 | } | |
359 | if (curTrace.getEndTime().compareTo(end) > 0) { | |
360 | end = curTrace.getEndTime(); | |
361 | } | |
362 | } | |
363 | return new TmfTimeRange(start, end); | |
364 | } | |
e1385db9 AM |
365 | |
366 | /** | |
367 | * Get a temporary directory based on a trace's name | |
368 | */ | |
369 | private static String getTemporaryDir(ITmfTrace trace) { | |
370 | return System.getProperty("java.io.tmpdir") + //$NON-NLS-1$ | |
371 | File.separator + | |
372 | trace.getName() + | |
373 | File.separator; | |
374 | } | |
fc526aef | 375 | } |