/*******************************************************************************
- * Copyright (c) 2012, 2013 Ericsson
+ * Copyright (c) 2012, 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
*
* Contributors:
* Alexandre Montplaisir - Initial API and implementation
+ * Patrick Tasse - Fix TimeRangeException
******************************************************************************/
package org.eclipse.linuxtools.tmf.core.statistics;
-import java.io.File;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
-import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
-import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;
-import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
-import org.eclipse.linuxtools.tmf.core.signal.TmfStatsUpdatedSignal;
-import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
-import org.eclipse.linuxtools.tmf.core.statesystem.TmfStateSystemFactory;
-import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
/**
* Implementation of ITmfStatistics which uses a state history for storing its
// Fields
// ------------------------------------------------------------------------
- private final ITmfTrace trace;
-
/** The event totals state system */
private final ITmfStateSystem totalsStats;
/**
* Constructor
*
- * @param trace
- * The trace for which we build these statistics
* @param totals
* The state system containing the "totals" information
* @param eventTypes
* The state system containing the "event types" information
* @since 3.0
*/
- public TmfStateStatistics(@NonNull ITmfTrace trace,
- @NonNull ITmfStateSystem totals,
- @NonNull ITmfStateSystem eventTypes) {
- this.trace = trace;
+ public TmfStateStatistics(@NonNull ITmfStateSystem totals, @NonNull ITmfStateSystem eventTypes) {
this.totalsStats = totals;
this.typesStats = eventTypes;
}
- /**
- * Manual constructor. This should be used if the trace's Resource is null
- * (ie, for unit tests). It requires specifying the location of the history
- * files manually.
- *
- * @param trace
- * The trace for which we build these statistics
- * @param totalsHistoryFile
- * The location of the totals state history file
- * @param typesHistoryFile
- * The location of the types state history file
- * @throws TmfTraceException
- * If the file could not be written to
- * @since 2.2
- */
- @Deprecated
- public TmfStateStatistics(ITmfTrace trace, File totalsHistoryFile,
- File typesHistoryFile) throws TmfTraceException {
- this.trace = trace;
- final ITmfStateProvider totalsInput = new TmfStatisticsTotalsModule().new StatsProviderTotals(trace);
- final ITmfStateProvider typesInput = new TmfStatisticsEventTypesModule().new StatsProviderEventTypes(trace);
- this.totalsStats = TmfStateSystemFactory.newFullHistory(totalsHistoryFile, totalsInput, true);
- this.typesStats = TmfStateSystemFactory.newFullHistory(typesHistoryFile, typesInput, true);
- }
-
/**
* Return the state system containing the "totals" values
*
typesStats.dispose();
}
- @Override
- public void updateStats(final boolean isGlobal, final long start,
- final long end) {
- /*
- * Since we are currently in a signal handler (ie, in the UI thread),
- * and since state system queries can be arbitrarily long (O(log n) wrt
- * the size of the trace), we will run those queries in a separate
- * thread and update the statistics view out-of-band.
- */
- Thread statsThread = new Thread("Statistics update") { //$NON-NLS-1$
- @Override
- public void run() {
- /* Wait until the history building is completed */
- if (!waitUntilBuilt()) {
- return;
- }
-
- /* Range should be valid for both global and time range queries */
- long total = getEventsInRange(start, end);
- Map<String, Long> map = getEventTypesInRange(start, end);
-
- /* Send the signal to notify the stats viewer to update its display */
- TmfSignal sig = new TmfStatsUpdatedSignal(this, trace, isGlobal, total, map);
- TmfSignalManager.dispatchSignal(sig);
- }
- };
- statsThread.start();
- return;
- }
-
@Override
public List<Long> histogramQuery(final long start, final long end, final int nb) {
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.
*/
- long startTime = checkStartTime(start);
- long endTime = checkEndTime(end);
+ long startTime = checkStartTime(start, typesStats);
+ long endTime = checkEndTime(end, typesStats);
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;
}
private long getEventCountAt(long timestamp) {
/* Make sure the target time is within the range of the history */
- long ts = checkStartTime(timestamp);
- ts = checkEndTime(ts);
+ long ts = checkStartTime(timestamp, totalsStats);
+ ts = checkEndTime(ts, totalsStats);
try {
final int quark = totalsStats.getQuarkAbsolute(Attributes.TOTAL);
return 0;
}
- private long checkStartTime(long initialStart) {
+ private static long checkStartTime(long initialStart, ITmfStateSystem ss) {
long start = initialStart;
- if (start < totalsStats.getStartTime()) {
- return totalsStats.getStartTime();
+ if (start < ss.getStartTime()) {
+ return ss.getStartTime();
}
return start;
}
- private long checkEndTime(long initialEnd) {
+ private static long checkEndTime(long initialEnd, ITmfStateSystem ss) {
long end = initialEnd;
- if (end > totalsStats.getCurrentEndTime()) {
- return totalsStats.getCurrentEndTime();
+ if (end > ss.getCurrentEndTime()) {
+ return ss.getCurrentEndTime();
}
return end;
}
- /**
- * Wait until both backing state systems are finished building.
- *
- * @return If both state systems were built successfully
- */
- private boolean waitUntilBuilt() {
- totalsStats.waitUntilBuilt();
- typesStats.waitUntilBuilt();
- boolean check1 = !totalsStats.isCancelled();
- boolean check2 = !typesStats.isCancelled();
- return (check1 && check2);
- }
-
-
/**
* The attribute names that are used in the state provider
*/