try {
File newStateFile = new File("/tmp/helloworldctf.ht"); //$NON-NLS-1$
IStateChangeInput input = new CtfKernelStateInput(CtfTestFiles.getTestTrace());
- ITmfStateSystem ss = StateSystemManager.loadStateHistory(newStateFile, input, true);
+ String name = "test-ss"; //$NON-NLS-1$
+ ITmfStateSystem ss = StateSystemManager.loadStateHistory(newStateFile, input, name, true);
requestExample(ss);
} catch (TmfTraceException e) {
/* Offset in the trace + start time of the trace */
private final static long interestingTimestamp1 = 18670067372290L + 1331649577946812237L;
+ /* ID we give to the state system we build */
+ private static final String STATE_ID = "test-ss";
+
protected static String getTestFileName() {
return "/tmp/statefile.ht"; //$NON-NLS-1$
}
stateFileBenchmark = new File(getTestFileName() + ".benchmark"); //$NON-NLS-1$
try {
input = new CtfKernelStateInput(CtfTestFiles.getTestTrace());
- ssq = StateSystemManager.loadStateHistory(stateFile, input, true);
+ ssq = StateSystemManager.loadStateHistory(stateFile, input, STATE_ID, true);
} catch (Exception e) {
e.printStackTrace();
}
ITmfStateSystem ssb2;
input2 = new CtfKernelStateInput(CtfTestFiles.getTestTrace());
- ssb2 = StateSystemManager.loadStateHistory(stateFileBenchmark, input2, true);
+ ssb2 = StateSystemManager.loadStateHistory(stateFileBenchmark, input2, STATE_ID, true);
assertEquals(CtfTestFiles.startTime, ssb2.getStartTime());
assertEquals(CtfTestFiles.endTime, ssb2.getCurrentEndTime());
ITmfStateSystem ssb2;
/* 'newStateFile' should have already been created */
- ssb2 = StateSystemManager.loadStateHistory(stateFile, null, true);
+ ssb2 = StateSystemManager.loadStateHistory(stateFile, null, STATE_ID, true);
assertNotNull(ssb2);
assertEquals(CtfTestFiles.startTime, ssb2.getStartTime());
*/
public final static String HISTORY_TREE_FILE_NAME = "stateHistory.ht"; //$NON-NLS-1$
+ /**
+ * ID of the state system we will build
+ * @since 2.0
+ * */
+ public static final String STATE_ID = "org.eclipse.linuxtools.lttng2.kernel"; //$NON-NLS-1$
+
/**
* Default constructor
*/
final File htFile = new File(supplDirectory + File.separator + HISTORY_TREE_FILE_NAME);
final IStateChangeInput htInput = new CtfKernelStateInput(this);
- this.ss = StateSystemManager.loadStateHistory(htFile, htInput, false);
+ this.ss = StateSystemManager.loadStateHistory(htFile, htInput, STATE_ID, false);
}
}
private final IStateChangeInput sci;
private final StateSystem ss;
private final IStateHistoryBackend hb;
+ private final String id;
private boolean started = true; /* Don't handle signals until we're ready */
/**
* The input plugin to use. This is required.
* @param backend
* The backend storage to use.
+ * @param id
+ * The ID (or name) of the state system that will be built. This
+ * can be useful in cases where there are more than 1 state
+ * system per trace/experiment.
* @param buildManually
* Should we build this history in-band or not. True means we
* will start the building ourselves and block the caller until
- * construction is done. False (out-of-band) means we will
- * start listening for the signal and return immediately. Another
+ * construction is done. False (out-of-band) means we will start
+ * listening for the signal and return immediately. Another
* signal will be sent when finished.
* @throws IOException
* Is thrown if anything went wrong (usually with the storage
* backend)
*/
public HistoryBuilder(IStateChangeInput stateChangeInput,
- IStateHistoryBackend backend, boolean buildManually)
+ IStateHistoryBackend backend, String id, boolean buildManually)
throws IOException {
if (stateChangeInput == null || backend == null) {
throw new IllegalArgumentException();
}
sci = stateChangeInput;
hb = backend;
+ this.id = id;
ss = new StateSystem(hb, true);
sci.assignTargetStateSystem(ss);
/* We won't broadcast the signal if the request was cancelled */
} else {
/* Broadcast the signal saying the history is done building */
- doneSig = new TmfStateSystemBuildCompleted(this, sci.getTrace());
+ doneSig = new TmfStateSystemBuildCompleted(this, sci.getTrace(), id);
TmfSignalManager.dispatchSignal(doneSig);
}
public class TmfStateSystemBuildCompleted extends TmfSignal {
private final ITmfTrace fTrace;
+ private final String fID;
/**
* Constructor
* Object sending this signal
* @param trace
* The state system of which trace just finished building
+ * @param id
+ * ID associated with this state system. This can be used in the
+ * case of a trace containing multiple state systems, to
+ * differentiate between them.
+ * @since 2.0
*/
- public TmfStateSystemBuildCompleted(Object source, ITmfTrace trace) {
+ public TmfStateSystemBuildCompleted(Object source, ITmfTrace trace, String id) {
super(source);
fTrace = trace;
+ fID = id;
}
/**
return fTrace;
}
+ /**
+ * @return The ID of the state system that just finished building
+ * @since 2.0
+ */
+ public String getID() {
+ return fID;
+ }
+
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
- return "[TmfStateSystemBuildCompleted (" + fTrace.toString() + ")]"; //$NON-NLS-1$ //$NON-NLS-2$
+ return "[TmfStateSystemBuildCompleted (trace = " + fTrace.toString() + //$NON-NLS-1$
+ ", ID = " + fID + ")]"; //$NON-NLS-1$ //$NON-NLS-2$
}
}
* The IStateChangeInput to use for building the history file. It
* may be required even if we are opening an already-existing
* history (ie, for partial histories).
+ * @param id
+ * The ID, or name, to give to the state system we will build.
+ * The signal that when be sent when the construction is finished
+ * will carry this ID. It has no effect if the file already
+ * exists.
* @param buildManually
* If false, the construction will wait for a signal before
* starting. If true, it will build everything right now and
* @since 2.0
*/
public static ITmfStateSystem loadStateHistory(File htFile,
- IStateChangeInput htInput, boolean buildManually)
+ IStateChangeInput htInput, String id, boolean buildManually)
throws TmfTraceException {
ITmfStateSystem ss;
IStateHistoryBackend htBackend;
try {
htBackend = new ThreadedHistoryTreeBackend(htFile,
htInput.getStartTime(), QUEUE_SIZE);
- builder = new HistoryBuilder(htInput, htBackend, buildManually);
+ builder = new HistoryBuilder(htInput, htBackend, id, buildManually);
} catch (IOException e) {
/*
* If it fails here however, it means there was a problem writing to
public class TmfStatistics implements ITmfStatistics {
+ /** ID for the statistics state system */
+ public static final String STATE_ID = "org.eclipse.linuxtools.tmf.statistics"; //$NON-NLS-1$
+
/* Filename the "statistics state history" file will have */
private static final String STATS_STATE_FILENAME = "statistics.ht"; //$NON-NLS-1$
final File htFile = new File(supplDirectory + File.separator + STATS_STATE_FILENAME);
final IStateChangeInput htInput = new StatsStateProvider(trace);
- this.stats = StateSystemManager.loadStateHistory(htFile, htInput, false);
+ this.stats = StateSystemManager.loadStateHistory(htFile, htInput, STATE_ID, false);
}
// ------------------------------------------------------------------------
projects / deliverable / tracecompass.git / commitdiff
