import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.tracecompass.analysis.graph.core.base.TmfGraph;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
/**
@Override
public long getStartTime() {
- return fTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ return fTrace.getStartTime().toNanos();
}
@Override
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.aspect.TmfCpuAspect;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
/**
* @return the timestamp in long format
*/
public static long getTimestamp(ITmfEvent event) {
- return event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ return event.getTimestamp().toNanos();
}
/**
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
}
AbstractSegmentStoreAnalysisModule module = getAnalysisModule();
- final long startTimeInNanos = getTimeInNanos(fCurrentRange.getStartTime());
- final long endTimeInNanos = getTimeInNanos(fCurrentRange.getEndTime());
+ final long startTimeInNanos = fCurrentRange.getStartTime().toNanos();
+ final long endTimeInNanos = fCurrentRange.getEndTime().toNanos();
if (module == null) {
setWindowRange(startTimeInNanos, endTimeInNanos);
redraw(statusMonitor, startTimeInNanos, startTimeInNanos, Collections.EMPTY_LIST);
public void updateModel(@Nullable ISegmentStore<ISegment> dataInput) {
// Update new window range
TmfTimeRange currentRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
- long currentStart = getTimeInNanos(currentRange.getStartTime());
- long currentEnd = getTimeInNanos(currentRange.getEndTime());
+ long currentStart = currentRange.getStartTime().toNanos();
+ long currentEnd = currentRange.getEndTime().toNanos();
if (dataInput == null) {
if (!getDisplay().isDisposed()) {
Display.getDefault().syncExec(new Runnable() {
if (trace != null) {
final TmfTimeRange timeRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
setWindowRange(
- timeRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(),
- timeRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
+ timeRange.getStartTime().toNanos(),
+ timeRange.getEndTime().toNanos());
setData(getSegmentStoreAnalysisModule(trace));
updateRange(timeRange);
}
final AbstractSegmentStoreAnalysisModule analysisModuleOfClass = getSegmentStoreAnalysisModule(trace);
final TmfTimeRange timeRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
setWindowRange(
- getTimeInNanos(timeRange.getStartTime()),
- getTimeInNanos(timeRange.getEndTime()));
+ timeRange.getStartTime().toNanos(),
+ timeRange.getEndTime().toNanos());
setData(analysisModuleOfClass);
}
private void setAnalysisModule(AbstractSegmentStoreAnalysisModule analysisModule) {
fAnalysisModule = analysisModule;
}
-
- private static long getTimeInNanos(final ITmfTimestamp currentTime) {
- return currentTime.normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- }
}
\ No newline at end of file
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
fixture.indexTrace(true);
- startTime = fixture.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- endTime = fixture.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ startTime = fixture.getStartTime().toNanos();
+ endTime = fixture.getEndTime().toNanos();
}
/**
public void setUp() {
fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
fixture.indexTrace(true);
- fStartTime = fixture.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- fEndTime = fixture.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ fStartTime = fixture.getStartTime().toNanos();
+ fEndTime = fixture.getEndTime().toNanos();
long foregroundStartTime = fStartTime + ((fEndTime - fStartTime) / 4);
long foregroundEndTime = fStartTime + ((fEndTime - fStartTime) / 2);
/** Time-out tests after 20 seconds */
@Rule
- public TestRule globalTimeout= new Timeout(20, TimeUnit.SECONDS);
+ public TestRule globalTimeout = new Timeout(20, TimeUnit.SECONDS);
private static final int SCALE = ITmfTimestamp.NANOSECOND_SCALE;
private static ITmfTrace trace1;
private static final long t1start = 1331668247314038062L;
- private static final long t1end = 1331668259054285979L;
+ private static final long t1end = 1331668259054285979L;
private static ITmfTrace trace2;
private static final long t2start = 1332170682440133097L;
- private static final long t2end = 1332170692664579801L;
+ private static final long t2end = 1332170692664579801L;
private static final long ONE_SECOND = 1000000000L;
private TmfTraceManager tm;
-
/**
* Test class initialization
*/
}
/**
- * Test selecting a range whose end time is after the trace's end time.
- * The selected range should get clamped to the trace's range.
+ * Test selecting a range whose end time is after the trace's end time. The
+ * selected range should get clamped to the trace's range.
*/
@Test
public void testTraceTimeRangeClampingEnd() {
* Basically a "initial + offset" operation, but for ITmfTimetamp objects.
*/
private static @NonNull ITmfTimestamp calculateOffset(ITmfTimestamp initialTs, ITmfTimestamp offsetTs) {
- long start = initialTs.normalize(0, SCALE).getValue();
- long offset = offsetTs.normalize(0, SCALE).getValue();
+ long start = initialTs.toNanos();
+ long offset = offsetTs.toNanos();
return new TmfTimestamp(start + offset, SCALE);
}
}
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
/* Make sure the generated state system exists, but is empty */
ITmfStateSystem ss = module.getStateSystem();
assertNotNull(ss);
- assertTrue(ss.getStartTime() >= ustTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
+ assertTrue(ss.getStartTime() >= ustTrace.getStartTime().toNanos());
assertEquals(0, ss.getNbAttributes());
} finally {
if (module != null) {
*/
public TmfXmlPatternSegment generatePatternSegment(ITmfEvent event, ITmfTimestamp start, ITmfTimestamp end) {
int scale = event.getTimestamp().getScale();
- long startValue = start.normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long endValue = end.normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long startValue = start.toNanos();
+ long endValue = end.toNanos();
String segmentName = getPatternSegmentName(event);
Map<String, ITmfStateValue> fields = new HashMap<>();
setPatternSegmentContent(event, start, end, fields);
@Override
protected void eventHandle(ITmfEvent ev) {
ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder());
- final long ts = ev.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ final long ts = ev.getTimestamp().toNanos();
try {
int quark = ss.getQuarkAbsoluteAndAdd(TEST_ATTRIBUTE_NAME);
ITmfStateValue value = (ITmfStateValue) ev.getContent().getValue();
import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.statesystem.AbstractTmfStateProvider;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
/**
/* Check if the event is a function entry */
String functionEntryName = functionEntry(event);
if (functionEntryName != null) {
- long timestamp = event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long timestamp = event.getTimestamp().toNanos();
String thread = getThreadName(event);
int threadQuark = ss.getQuarkAbsoluteAndAdd(THREADS, thread);
Long threadId = getThreadId(event);
/* Check if the event is a function exit */
String functionExitName = functionExit(event);
if (functionExitName != null) {
- long timestamp = event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long timestamp = event.getTimestamp().toNanos();
String thread = getThreadName(event);
int quark = ss.getQuarkAbsoluteAndAdd(THREADS, thread, CALL_STACK);
ITmfStateValue poppedValue = ss.popAttribute(timestamp, quark);
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.TmfEvent;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
@Override
public long getStartTime() {
- return fTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ return fTrace.getStartTime().toNanos();
}
@Override
private void closeStateSystem() {
ITmfEvent event = currentEvent;
final long endTime = (event == null) ? 0 :
- event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ event.getTimestamp().toNanos();
if (fSS != null) {
fSS.closeHistory(endTime);
public void handleData(ITmfEvent event) {
super.handleData(event);
if (event.getTrace() == trace) {
- long ts = event.getTimestamp().normalize(0, SCALE).getValue();
+ long ts = event.getTimestamp().toNanos();
Long key = results.floorKey(ts);
if (key != null) {
incrementValue(key);
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStateStatistics.Attributes;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
/**
/* Since this can be used for any trace types, normalize all the
* timestamp values to nanoseconds. */
- final long ts = event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ final long ts = event.getTimestamp().toNanos();
final String eventName = event.getName();
ITmfStateValue value1 = TmfStateValue.newValueInt((int) (curVal + le.getNbLostEvents()));
ss.modifyAttribute(ts, value1, quark);
- long lostEventsStartTime = le.getTimeRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long lostEventsEndTime = le.getTimeRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long lostEventsStartTime = le.getTimeRange().getStartTime().toNanos();
+ long lostEventsEndTime = le.getTimeRange().getEndTime().toNanos();
int lostEventsQuark = ss.getQuarkAbsoluteAndAdd(Attributes.LOST_EVENTS);
ITmfStateValue currentLostEventsEndTime = ss.queryOngoingState(lostEventsQuark);
if (currentLostEventsEndTime.isNull() || currentLostEventsEndTime.unboxLong() < lostEventsStartTime) {
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStateStatistics.Attributes;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
/**
/* Since this can be used for any trace types, normalize all the
* timestamp values to nanoseconds. */
- final long ts = event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ final long ts = event.getTimestamp().toNanos();
try {
/* Total number of events */
if (factor == 1.0) {
return createWithOffset(offset);
}
- return new TmfTimestampTransformLinearFast(factor, offset.normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
+ return new TmfTimestampTransformLinearFast(factor, offset.toNanos());
}
/**
* @return the timestamp converted to a long value of nanoseconds
* @since 2.0
*/
- default long toNanos(){
+ default long toNanos() {
if (getScale() == NANOSECOND_SCALE) {
return getValue();
}
* The timestamp to copy
*/
public TmfNanoTimestamp(final ITmfTimestamp timestamp) {
- super(timestamp.normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(), ITmfTimestamp.NANOSECOND_SCALE);
+ super(timestamp.toNanos(), ITmfTimestamp.NANOSECOND_SCALE);
}
// ------------------------------------------------------------------------
@Override
public String toString(final TmfTimestampFormat format) {
try {
- ITmfTimestamp ts = normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
- return format.format(ts.getValue());
+ return format.format(toNanos());
}
catch (ArithmeticException e) {
return format.format(0);
import org.eclipse.tracecompass.internal.tmf.core.Activator;
import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
import org.eclipse.tracecompass.tmf.core.signal.TmfEventFilterAppliedSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
-import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
final IFile editorFile = signal.getEditorFile();
final ITmfTimestamp startTs = trace.getStartTime();
- /* Calculate the initial time range */
- final int SCALE = ITmfTimestamp.NANOSECOND_SCALE;
- long offset = trace.getInitialRangeOffset().normalize(0, SCALE).getValue();
- long endTime = startTs.normalize(0, SCALE).getValue() + offset;
+ long offset = trace.getInitialRangeOffset().toNanos();
+ long endTime = startTs.toNanos() + offset;
final TmfTimeRange selectionRange = new TmfTimeRange(startTs, startTs);
- final TmfTimeRange windowRange = new TmfTimeRange(startTs, new TmfTimestamp(endTime, SCALE));
+ final TmfTimeRange windowRange = new TmfTimeRange(startTs, new TmfTimestamp(endTime, ITmfTimestamp.NANOSECOND_SCALE));
final TmfTraceContext startCtx = new TmfTraceContext(selectionRange, windowRange, editorFile, null);
} else {
try {
ITmfTimestamp refTime = map.get(element);
- long ref = refTime == null ? 0 : refTime.normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long ref = refTime == null ? 0 : refTime.toNanos();
Long newVal = TIME_FORMAT.parseValue(string, ref);
map.put((TmfTraceElement) element, new TmfNanoTimestamp(newVal));
} catch (ParseException e) {
if (ts == null) {
return ""; //$NON-NLS-1$
}
- return TIME_FORMAT.format(ts.normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
+ return TIME_FORMAT.format(ts.toNanos());
}
}
import org.eclipse.tracecompass.tmf.core.statistics.ITmfStatistics;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsEventTypesModule;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsModule;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
*/
private static final long LIVE_UPDATE_DELAY = 1000;
- /**
- * Timestamp scale used for all statistics (nanosecond)
- */
- private static final byte TIME_SCALE = ITmfTimestamp.NANOSECOND_SCALE;
private TmfTimeRange fTimerange;
/**
* The generic statistics are stored in nanoseconds, so we must make
* sure the time range is scaled correctly.
*/
- start = localtimeRange.getStartTime().normalize(0, TIME_SCALE).getValue();
- end = localtimeRange.getEndTime().normalize(0, TIME_SCALE).getValue();
+ start = localtimeRange.getStartTime().toNanos();
+ end = localtimeRange.getEndTime().toNanos();
Map<String, Long> map = stats.getEventTypesInRange(start, end);
updateStats(map);
package org.eclipse.tracecompass.tmf.ui.viewers;
import org.eclipse.swt.widgets.Composite;
-import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalThrottler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
}
/**
- * Sets the start time and end of the current time range window (visible range)
+ * Sets the start time and end of the current time range window (visible
+ * range)
*
* @param windowStartTime
* The start time to set
fTrace = trace;
TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
- long selectionStart = ctx.getSelectionRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long selectionEnd = ctx.getSelectionRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long selectionStart = ctx.getSelectionRange().getStartTime().toNanos();
+ long selectionEnd = ctx.getSelectionRange().getEndTime().toNanos();
TmfTimeRange windowRange = ctx.getWindowRange();
- long windowStartTime = windowRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long windowEndTime = windowRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long startTime = fTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long endTime = fTrace.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long windowStartTime = windowRange.getStartTime().toNanos();
+ long windowEndTime = windowRange.getEndTime().toNanos();
+ long startTime = fTrace.getStartTime().toNanos();
+ long endTime = fTrace.getEndTime().toNanos();
setSelectionRange(selectionStart, selectionEnd);
@TmfSignalHandler
public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
if ((signal.getSource() != this) && (fTrace != null)) {
- ITmfTimestamp selectedTime = signal.getBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
- ITmfTimestamp selectedEndTime = signal.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
- setSelectionRange(selectedTime.getValue(), selectedEndTime.getValue());
+ long selectedTime = signal.getBeginTime().toNanos();
+ long selectedEndTime = signal.getEndTime().toNanos();
+ setSelectionRange(selectedTime, selectedEndTime);
}
}
if (signal.getSource() != this) {
// Update the time range
- long windowStartTime = range.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long windowEndTime = range.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long windowStartTime = range.getStartTime().toNanos();
+ long windowEndTime = range.getEndTime().toNanos();
setWindowRange(windowStartTime, windowEndTime);
}
TmfTimeRange fullRange = signal.getRange();
- long traceStartTime = fullRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long traceEndTime = fullRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long traceStartTime = fullRange.getStartTime().toNanos();
+ long traceEndTime = fullRange.getEndTime().toNanos();
setStartTime(traceStartTime);
setEndTime(traceEndTime);
return;
}
TmfTimeRange fullRange = signal.getTrace().getTimeRange();
- long traceStartTime = fullRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long traceEndTime = fullRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+
+ long traceStartTime = fullRange.getStartTime().toNanos();
+ long traceEndTime = fullRange.getEndTime().toNanos();
setStartTime(traceStartTime);
setEndTime(traceEndTime);
if (signal.getSource() == this || getTrace() == null || isPinned()) {
return;
}
- final long beginTime = signal.getBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- final long endTime = signal.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ final long beginTime = signal.getBeginTime().toNanos();
+ final long endTime = signal.getEndTime().toNanos();
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
ITmfTrace trace = fParentView.getTrace();
if (trace != null) {
TmfTimeRange range = trace.getTimeRange();
- long startTime = range.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long endTime = range.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long startTime = range.getStartTime().toNanos();
+ long endTime = range.getEndTime().toNanos();
if (value < startTime) {
value = startTime;
} else if (value > endTime) {
import org.eclipse.tracecompass.tmf.core.event.ITmfLostEvent;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
/**
fHistogram.countLostEvent(lostEvents.getTimeRange(), lostEvents.getNbLostEvents(), fFullRange);
} else { /* handle lost event */
- long timestamp = event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long timestamp = event.getTimestamp().toNanos();
fHistogram.countEvent(getNbRead(), timestamp, event.getTrace());
}
}
TmfTimeRange fullRange = signal.getRange();
- fTraceStartTime = fullRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- fTraceEndTime = fullRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ fTraceStartTime = fullRange.getStartTime().toNanos();
+ fTraceEndTime = fullRange.getEndTime().toNanos();
fFullTraceHistogram.setFullRange(fTraceStartTime, fTraceEndTime);
fTimeRangeHistogram.setFullRange(fTraceStartTime, fTraceEndTime);
return;
}
TmfTimeRange fullRange = signal.getTrace().getTimeRange();
- fTraceStartTime = fullRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- fTraceEndTime = fullRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ fTraceStartTime = fullRange.getStartTime().toNanos();
+ fTraceEndTime = fullRange.getEndTime().toNanos();
fFullTraceHistogram.setFullRange(fTraceStartTime, fTraceEndTime);
fTimeRangeHistogram.setFullRange(fTraceStartTime, fTraceEndTime);
}
// Update the selected time range
- ITmfTimestamp beginTime = signal.getBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
- ITmfTimestamp endTime = signal.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
- updateDisplayedSelectionTime(beginTime.getValue(), endTime.getValue());
+ long beginTime = signal.getBeginTime().toNanos();
+ long endTime = signal.getEndTime().toNanos();
+
+ updateDisplayedSelectionTime(beginTime, endTime);
}
/**
}
updateDisplayedTimeRange(
- range.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(),
- range.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
+ range.getStartTime().toNanos(),
+ range.getEndTime().toNanos());
// Send the event request to populate the small histogram
sendTimeRangeRequest(fWindowStartTime, fWindowEndTime);
TmfTimeRange fullRange = updateTraceTimeRange();
TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
- long selectionBeginTime = ctx.getSelectionRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long selectionEndTime = ctx.getSelectionRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long startTime = ctx.getWindowRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long duration = ctx.getWindowRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue() - startTime;
+ long selectionBeginTime = ctx.getSelectionRange().getStartTime().toNanos();
+ long selectionEndTime = ctx.getSelectionRange().getEndTime().toNanos();
+ long startTime = ctx.getWindowRange().getStartTime().toNanos();
+ long duration = ctx.getWindowRange().getEndTime().toNanos() - startTime;
if ((fTimeRangeRequest != null) && !fTimeRangeRequest.isCompleted()) {
fTimeRangeRequest.cancel();
TmfTimeRange timeRange = fTrace.getTimeRange();
if (!timeRange.equals(TmfTimeRange.NULL_RANGE)) {
- fTraceStartTime = timeRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- fTraceEndTime = timeRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ fTraceStartTime = timeRange.getStartTime().toNanos();
+ fTraceEndTime = timeRange.getEndTime().toNanos();
}
return timeRange;
}
fSelection = start;
} else {
TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
- fSelection = ctx.getSelectionRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ fSelection = ctx.getSelectionRange().getStartTime().toNanos();
}
if (getTrace() == null) {
*/
public class TimeChartEvent implements ITimeEvent {
- private static final byte TIMESTAMP_SCALE = -9;
-
private final TimeChartAnalysisEntry fParentEntry;
private long fTime;
private long fDuration;
public TimeChartEvent(TimeChartAnalysisEntry parentEntry, ITmfEvent event,
long rank, TimeChartDecorationProvider decorationProvider) {
fParentEntry = parentEntry;
- fTime = event.getTimestamp().normalize(0, TIMESTAMP_SCALE).getValue();
+ fTime = event.getTimestamp().toNanos();
fDuration = 0;
fFirstRank = fLastRank = rank;
fRankRangeList = new RankRangeList(rank);
TmfTimeRange range = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE,
- range.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue(),
- range.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
+ range.getStartTime().toNanos(),
+ range.getEndTime().toNanos());
}
}
if (event == null) {
break;
}
- long eventTime = event.getTimestamp().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long eventTime = event.getTimestamp().toNanos();
if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {
priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));
}
}
}
TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
- long beginTime = ctx.getSelectionRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long endTime = ctx.getSelectionRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long beginTime = ctx.getSelectionRange().getStartTime().toNanos();
+ long endTime = ctx.getSelectionRange().getEndTime().toNanos();
fViewer.setSelectionRange(beginTime, endTime, false);
}
}
*/
@TmfSignalHandler
public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
- final long beginTime = signal.getBeginTime().normalize(0, TIMESTAMP_SCALE).getValue();
- final long endTime = signal.getEndTime().normalize(0, TIMESTAMP_SCALE).getValue();
+ final long beginTime = signal.getBeginTime().toNanos();
+ final long endTime = signal.getEndTime().toNanos();
+
+
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
if (signal.getSource() == this) {
return;
}
- final long startTime = signal.getCurrentRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- final long endTime = signal.getCurrentRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ final long startTime = signal.getCurrentRange().getStartTime().toNanos();
+ final long endTime = signal.getCurrentRange().getEndTime().toNanos();
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
-import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
if (signal.getSource() == this || fTrace == null) {
return;
}
- final long beginTime = signal.getBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- final long endTime = signal.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ final long beginTime = signal.getBeginTime().toNanos();
+ final long endTime = signal.getEndTime().toNanos();
Display.getDefault().asyncExec(new Runnable() {
@Override
if (signal.getCurrentRange().getIntersection(fTrace.getTimeRange()) == null) {
return;
}
- final long startTime = signal.getCurrentRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- final long endTime = signal.getCurrentRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ final long startTime = signal.getCurrentRange().getStartTime().toNanos();
+ final long endTime = signal.getCurrentRange().getEndTime().toNanos();
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
if (fEntryList == null) {
rebuild();
} else {
- fStartTime = fTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- fEndTime = fTrace.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ fStartTime = fTrace.getStartTime().toNanos();
+ fEndTime = fTrace.getEndTime().toNanos();
refresh();
}
}
fTimeGraphWrapper.getTimeGraphViewer().setTimeBounds(startBound, endBound);
TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
- long selectionBeginTime = fTrace == null ? SWT.DEFAULT : ctx.getSelectionRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long selectionEndTime = fTrace == null ? SWT.DEFAULT : ctx.getSelectionRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long startTime = fTrace == null ? SWT.DEFAULT : ctx.getWindowRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
- long endTime = fTrace == null ? SWT.DEFAULT : ctx.getWindowRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
+ long selectionBeginTime = fTrace == null ? SWT.DEFAULT : ctx.getSelectionRange().getStartTime().toNanos();
+ long selectionEndTime = fTrace == null ? SWT.DEFAULT : ctx.getSelectionRange().getEndTime().toNanos();
+ long startTime = fTrace == null ? SWT.DEFAULT : ctx.getWindowRange().getStartTime().toNanos();
+ long endTime = fTrace == null ? SWT.DEFAULT : ctx.getWindowRange().getEndTime().toNanos();
startTime = (fStartTime == Long.MAX_VALUE ? SWT.DEFAULT : Math.max(startTime, fStartTime));
endTime = (fEndTime == Long.MIN_VALUE ? SWT.DEFAULT : Math.min(endTime, fEndTime));
fTimeGraphWrapper.getTimeGraphViewer().setSelectionRange(selectionBeginTime, selectionEndTime, false);
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
-import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
-import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
-import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
fLock.lock();
try {
TmfTimeRange currentRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
- long offset = fTrace == null ? 0 : currentRange.getEndTime().getDelta(currentRange.getStartTime()).normalize(0, startTime.getScale()).getValue();
+ long offset = fTrace == null ? 0 : currentRange.getEndTime().getDelta(currentRange.getStartTime()).toNanos();
TmfTimestamp initialEndOfWindow = new TmfTimestamp(startTime.getValue() + offset, startTime.getScale());
return new TmfTimeRange(startTime, initialEndOfWindow);
}