/*******************************************************************************
- * Copyright (c) 2013 Ericsson
+ * Copyright (c) 2013, 2014 Ericsson
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* accompanies this distribution, and is available at
import java.util.TreeMap;
import java.util.concurrent.CountDownLatch;
-import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHistoryBackend;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.linuxtools.statesystem.core.ITmfStateSystem;
+import org.eclipse.linuxtools.statesystem.core.backend.IStateHistoryBackend;
+import org.eclipse.linuxtools.statesystem.core.exceptions.AttributeNotFoundException;
+import org.eclipse.linuxtools.statesystem.core.exceptions.StateSystemDisposedException;
+import org.eclipse.linuxtools.statesystem.core.exceptions.TimeRangeException;
+import org.eclipse.linuxtools.statesystem.core.interval.ITmfStateInterval;
+import org.eclipse.linuxtools.statesystem.core.interval.TmfStateInterval;
+import org.eclipse.linuxtools.statesystem.core.statevalue.ITmfStateValue;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
-import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
-import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
-import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
-import org.eclipse.linuxtools.tmf.core.interval.TmfStateInterval;
-import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
-import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
-import org.eclipse.linuxtools.tmf.core.statesystem.AbstractStateChangeInput;
-import org.eclipse.linuxtools.tmf.core.statesystem.IStateChangeInput;
-import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
+import org.eclipse.linuxtools.tmf.core.statesystem.AbstractTmfStateProvider;
+import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateProvider;
+import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
* A partial history needs the state input plugin to re-generate state
* between checkpoints.
*/
- private final IStateChangeInput partialInput;
+ private final @NonNull ITmfStateProvider partialInput;
/**
* Fake state system that is used for partially rebuilding the states (when
* going from a checkpoint to a target query timestamp).
*/
- private final PartialStateSystem partialSS;
+ private final @NonNull PartialStateSystem partialSS;
/** Reference to the "real" state history that is used for storage */
- private final IStateHistoryBackend innerHistory;
+ private final @NonNull IStateHistoryBackend innerHistory;
/** Checkpoints map, <Timestamp, Rank in the trace> */
- private final TreeMap<Long, Long> checkpoints =
- new TreeMap<Long, Long>();
+ private final @NonNull TreeMap<Long, Long> checkpoints = new TreeMap<>();
/** Latch tracking if the initial checkpoint registration is done */
- private final CountDownLatch checkpointsReady = new CountDownLatch(1);
+ private final @NonNull CountDownLatch checkpointsReady = new CountDownLatch(1);
private final long granularity;
* Configuration parameter indicating how many trace events there
* should be between each checkpoint
*/
- public PartialHistoryBackend(IStateChangeInput partialInput, PartialStateSystem pss,
+ public PartialHistoryBackend(ITmfStateProvider partialInput, PartialStateSystem pss,
IStateHistoryBackend realBackend, long granularity) {
- if (granularity <= 0 || partialInput == null || pss == null) {
+ if (granularity <= 0 || partialInput == null || pss == null ||
+ partialInput.getAssignedStateSystem() != pss) {
throw new IllegalArgumentException();
}
- if (partialInput.getAssignedStateSystem() != pss) {
- throw new RuntimeException();
- }
final long startTime = realBackend.getStartTime();
@Override
public void dispose() {
+ partialInput.dispose();
+ partialSS.dispose();
innerHistory.dispose();
}
* caused by the event(s) happening exactly at 'checkpointTime',
* if any. We must not include those events in the query.
*/
- new TmfTimestamp(checkpointTime + 1, -9),
- new TmfTimestamp(t, -9));
+ new TmfTimestamp(checkpointTime + 1, ITmfTimestamp.NANOSECOND_SCALE),
+ new TmfTimestamp(t, ITmfTimestamp.NANOSECOND_SCALE));
ITmfEventRequest request = new PartialStateSystemRequest(partialInput, range);
partialInput.getTrace().sendRequest(request);
for (int i = 0; i < currentStateInfo.size(); i++) {
long start = 0;
ITmfStateValue val = null;
- start = partialSS.getOngoingStartTime(i);
- val = partialSS.queryOngoingState(i);
+ start = ((ITmfStateSystem) partialSS).getOngoingStartTime(i);
+ val = ((ITmfStateSystem) partialSS).queryOngoingState(i);
ITmfStateInterval interval = new TmfStateInterval(start, t, i, val);
currentStateInfo.set(i, interval);
// ------------------------------------------------------------------------
private class CheckpointsRequest extends TmfEventRequest {
-
- /** The amount of events queried at a time through the requests */
- private final static int chunkSize = 50000;
-
private final ITmfTrace trace;
private final Map<Long, Long> checkpts;
private long eventCount;
private long lastCheckpointAt;
- public CheckpointsRequest(IStateChangeInput input, Map<Long, Long> checkpoints) {
+ public CheckpointsRequest(ITmfStateProvider input, Map<Long, Long> checkpoints) {
super(input.getExpectedEventType(),
TmfTimeRange.ETERNITY,
- TmfDataRequest.ALL_DATA,
- chunkSize,
- ITmfDataRequest.ExecutionType.BACKGROUND);
+ 0,
+ ITmfEventRequest.ALL_DATA,
+ ITmfEventRequest.ExecutionType.FOREGROUND);
checkpoints.clear();
this.trace = input.getTrace();
this.checkpts = checkpoints;
- eventCount = lastCheckpointAt = 0;
+ eventCount = 0;
+ lastCheckpointAt = 0;
/* Insert a checkpoint at the start of the trace */
checkpoints.put(input.getStartTime(), 0L);
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
- if (event != null && event.getTrace() == trace) {
+ if (event.getTrace() == trace) {
eventCount++;
/* Check if we need to register a new checkpoint */
}
private class PartialStateSystemRequest extends TmfEventRequest {
-
- private final static int chunkSize = 50000;
- private final IStateChangeInput sci;
+ private final ITmfStateProvider sci;
private final ITmfTrace trace;
- PartialStateSystemRequest(IStateChangeInput sci, TmfTimeRange range) {
+ PartialStateSystemRequest(ITmfStateProvider sci, TmfTimeRange range) {
super(sci.getExpectedEventType(),
range,
- TmfDataRequest.ALL_DATA,
- chunkSize,
- ITmfDataRequest.ExecutionType.BACKGROUND);
+ 0,
+ ITmfEventRequest.ALL_DATA,
+ ITmfEventRequest.ExecutionType.BACKGROUND);
this.sci = sci;
this.trace = sci.getTrace();
}
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
- if (event != null && event.getTrace() == trace) {
+ if (event.getTrace() == trace) {
sci.processEvent(event);
}
}
* all events have been handled by the state system before doing
* queries on it.
*/
- if (partialInput instanceof AbstractStateChangeInput) {
- ((AbstractStateChangeInput) partialInput).waitForEmptyQueue();
+ if (partialInput instanceof AbstractTmfStateProvider) {
+ ((AbstractTmfStateProvider) partialInput).waitForEmptyQueue();
}
super.handleCompleted();
}
-
}
}
projects / deliverable / tracecompass.git / blobdiff