final List<Long> list = new LinkedList<>();
final long increment = (end - start) / nb;
- totalsStats.waitUntilBuilt();
if (totalsStats.isCancelled()) {
return list;
}
@Override
public long getEventsTotal() {
- /* We need the complete state history to be built to answer this. */
- totalsStats.waitUntilBuilt();
-
long endTime = totalsStats.getCurrentEndTime();
int count = 0;
} catch (TimeRangeException e) {
/* Assume there is no events for that range */
return 0;
- } catch (AttributeNotFoundException e) {
- e.printStackTrace();
- } catch (StateValueTypeException e) {
- e.printStackTrace();
- } catch (StateSystemDisposedException e) {
+ } catch (AttributeNotFoundException | StateValueTypeException | StateSystemDisposedException e) {
e.printStackTrace();
}
@Override
public Map<String, Long> getEventTypesTotal() {
- /* We need the complete state history to be built to answer this. */
- typesStats.waitUntilBuilt();
-
- Map<String, Long> map = new HashMap<>();
+ final Map<String, Long> map = new HashMap<>();
long endTime = typesStats.getCurrentEndTime();
try {
@Override
public long getEventsInRange(long start, long end) {
- // FIXME Instead of waiting until the end, we could check the current
- // end time, and answer as soon as possible...
- totalsStats.waitUntilBuilt();
-
long startCount;
if (start == totalsStats.getStartTime()) {
startCount = 0;
@Override
public Map<String, Long> getEventTypesInRange(long start, long end) {
- // FIXME Instead of waiting until the end, we could check the current
- // end time, and answer as soon as possible...
- typesStats.waitUntilBuilt();
-
- Map<String, Long> map = new HashMap<>();
+ final Map<String, Long> map = new HashMap<>();
+ List<Integer> quarks;
/* Make sure the start/end times are within the state history, so we
* don't get TimeRange exceptions.
try {
/* Get the list of quarks, one for each even type in the database */
int quark = typesStats.getQuarkAbsolute(Attributes.EVENT_TYPES);
- List<Integer> quarks = typesStats.getSubAttributes(quark, false);
+ quarks = typesStats.getSubAttributes(quark, false);
+ } catch (AttributeNotFoundException e) {
+ /*
+ * The state system does not (yet?) have the needed attributes, it
+ * probably means there are no events counted yet. Return the empty
+ * map.
+ */
+ return map;
+ }
+ try {
List<ITmfStateInterval> endState = typesStats.queryFullState(endTime);
- String curEventName;
- long countAtStart, countAtEnd, eventCount;
-
if (startTime == typesStats.getStartTime()) {
/* Only use the values picked up at the end time */
for (int typeQuark : quarks) {
- curEventName = typesStats.getAttributeName(typeQuark);
- eventCount = endState.get(typeQuark).getStateValue().unboxInt();
+ String curEventName = typesStats.getAttributeName(typeQuark);
+ long eventCount = endState.get(typeQuark).getStateValue().unboxInt();
if (eventCount == -1) {
eventCount = 0;
}
*/
List<ITmfStateInterval> startState = typesStats.queryFullState(startTime - 1);
for (int typeQuark : quarks) {
- curEventName = typesStats.getAttributeName(typeQuark);
- countAtStart = startState.get(typeQuark).getStateValue().unboxInt();
- countAtEnd = endState.get(typeQuark).getStateValue().unboxInt();
+ String curEventName = typesStats.getAttributeName(typeQuark);
+ long countAtStart = startState.get(typeQuark).getStateValue().unboxInt();
+ long countAtEnd = endState.get(typeQuark).getStateValue().unboxInt();
if (countAtStart == -1) {
countAtStart = 0;
if (countAtEnd == -1) {
countAtEnd = 0;
}
- eventCount = countAtEnd - countAtStart;
+ long eventCount = countAtEnd - countAtStart;
map.put(curEventName, eventCount);
}
}
- } catch (TimeRangeException e) {
- /* Assume there is no events, nothing will be put in the map. */
- } catch (AttributeNotFoundException | StateValueTypeException | StateSystemDisposedException e) {
+ } catch (TimeRangeException | StateSystemDisposedException e) {
+ /* Assume there is no (more) events, nothing will be put in the map. */
+ } catch (StateValueTypeException e) {
/*
- * These other exception types would show a logic problem however,
+ * This exception type would show a logic problem however,
* so they should not happen.
*/
- e.printStackTrace();
+ throw new IllegalStateException();
}
return map;
}
import java.util.List;
import java.util.Map;
-import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceRangeUpdatedSignal;
+import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
import org.eclipse.linuxtools.tmf.core.statistics.ITmfStatistics;
+import org.eclipse.linuxtools.tmf.core.statistics.TmfStatisticsEventTypesModule;
import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
*/
protected final Long STATS_INPUT_CHANGED_REFRESH = 5000L;
+ /**
+ * The delay (in ms) between each update in live-reading mode
+ */
+ private static final long LIVE_UPDATE_DELAY = 1000;
+
/**
* The actual tree viewer to display
*/
Thread statsThread = new Thread("Statistics update") { //$NON-NLS-1$
@Override
public void run() {
- /* Wait until the analysis is ready */
- if (!statsMod.waitForCompletion(new NullProgressMonitor())) {
- return;
- }
-
+ /* Wait until the analysis is ready to be queried */
+ statsMod.waitForInitialization();
ITmfStatistics stats = statsMod.getStatistics();
if (stats == null) {
/* It should have worked, but didn't */
- return;
+ throw new IllegalStateException();
}
/*
long start = timeRange.getStartTime().normalize(0, TIME_SCALE).getValue();
long end = timeRange.getEndTime().normalize(0, TIME_SCALE).getValue();
+ /*
+ * Wait on the state system object we are going to query.
+ *
+ * TODO Eventually this could be exposed through the
+ * TmfStateSystemAnalysisModule directly.
+ */
+ ITmfStateSystem ss = statsMod.getStateSystem(TmfStatisticsEventTypesModule.ID);
+ if (ss == null) {
+ /* It should be instantiated after the
+ * statsMod.waitForInitialization() above. */
+ throw new IllegalStateException();
+ }
+
+ /*
+ * Periodically update the statistics while they are
+ * being built (or, if the back-end is already completely
+ * built, it will skip over the while() immediately.
+ */
+ while(!ss.waitUntilBuilt(LIVE_UPDATE_DELAY)) {
+ Map<String, Long> map = stats.getEventTypesInRange(start, end);
+ updateStats(isGlobal, map);
+ }
+ /* Query one last time for the final values */
Map<String, Long> map = stats.getEventTypesInRange(start, end);
updateStats(isGlobal, map);
}
private void updateStats(boolean isGlobal, Map<String, Long> eventsPerType) {
final TmfStatisticsTree statsData = TmfStatisticsTreeManager.getStatTree(getTreeID());
+ if (statsData == null) {
+ /* The stat tree has been disposed, abort mission. */
+ return;
+ }
+
Map<String, Long> map = eventsPerType;
String name = fTrace.getName();
projects / deliverable / tracecompass.git / commitdiff
