X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=org.eclipse.linuxtools.tmf.core%2Fsrc%2Forg%2Feclipse%2Flinuxtools%2Ftmf%2Fcore%2Fctfadaptor%2FCtfTmfEvent.java;h=c7a2129d743b6ec1bee0f9226caacb077d359c01;hb=bd54d363b79ab554de3036a01c59c40aff78c1a9;hp=1500c504aed0ecdaacde085060ad13d998d53eb2;hpb=836032241599f09ab801d01d59648675f627deb5;p=deliverable%2Ftracecompass.git
diff --git a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java
index 1500c504ae..c7a2129d74 100644
--- a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java
+++ b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java
@@ -1,36 +1,48 @@
/*******************************************************************************
- * Copyright (c) 2011 Ericsson
+ * Copyright (c) 2011-2013 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
* http://www.eclipse.org/legal/epl-v10.html
*
- * Contributors: Alexandre Montplaisir - Initial API and implementation
+ * Contributors:
+ * Alexandre Montplaisir - Initial API and implementation
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.ctfadaptor;
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
+import java.util.Set;
+import org.eclipse.linuxtools.ctf.core.event.CTFCallsite;
import org.eclipse.linuxtools.ctf.core.event.EventDefinition;
+import org.eclipse.linuxtools.ctf.core.event.IEventDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.Definition;
+import org.eclipse.linuxtools.ctf.core.event.types.IntegerDefinition;
import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventPropertySource;
+import org.eclipse.ui.views.properties.IPropertySource;
/**
- * CTFEvent
- *
- * This is a wrapper class around CTF's Event Definition/Declaration so that we
- * can map all types of Declaration to native Java types.
+ * A wrapper class around CTF's Event Definition/Declaration that maps all
+ * types of Declaration to native Java types.
+ *
+ * @version 1.0
+ * @author Alexandre Montplaisir
+ * @since 2.0
*/
-public final class CtfTmfEvent implements ITmfEvent {
+public final class CtfTmfEvent implements ITmfEvent, Cloneable {
// ------------------------------------------------------------------------
// Constants
@@ -38,20 +50,23 @@ public final class CtfTmfEvent implements ITmfEvent {
private static final String NO_STREAM = "No stream"; //$NON-NLS-1$
private static final String EMPTY_CTF_EVENT_NAME = "Empty CTF event"; //$NON-NLS-1$
- private static final String CONTEXT_ID = "Ctf Event"; //$NON-NLS-1$
+
+ /** Prefix for Context information stored as CtfTmfEventfield */
+ private static final String CONTEXT_FIELD_PREFIX = "context."; //$NON-NLS-1$
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
private final CtfTmfTrace fTrace;
- private final long timestamp;
+ private final ITmfTimestamp fTimestamp;
private final int sourceCPU;
private final long typeId;
private final String eventName;
private final String fileName;
- private final CtfTmfContent fContent;
+ private final TmfEventField fContent;
+ private final IEventDeclaration fDeclaration;
// ------------------------------------------------------------------------
// Constructors
@@ -62,63 +77,101 @@ public final class CtfTmfEvent implements ITmfEvent {
* the StreamInputReader).
*
* @param eventDef
- * @param top
+ * CTF EventDefinition object corresponding to this trace event
+ * @param fileName
+ * The path to the trace file
+ * @param originTrace
+ * The trace from which this event originates
*/
public CtfTmfEvent(EventDefinition eventDef, String fileName,
CtfTmfTrace originTrace) {
this.fTrace = originTrace;
if (eventDef == null) {
- this.timestamp = -1;
+ this.fTimestamp = new CtfTmfTimestamp(-1);
this.sourceCPU = -1;
this.typeId = -1;
this.fileName = NO_STREAM;
this.eventName = EMPTY_CTF_EVENT_NAME;
this.fContent = null;
+ this.fDeclaration = null;
return;
}
/* Read the base event info */
- Long offset = originTrace.getCTFTrace().getOffset();
- this.timestamp = eventDef.timestamp + offset;
+ long ts = this.getTrace().getCTFTrace().timestampCyclesToNanos(eventDef.getTimestamp());
+ this.fTimestamp = new CtfTmfTimestamp(ts);
this.sourceCPU = eventDef.getCPU();
this.typeId = eventDef.getDeclaration().getId();
this.eventName = eventDef.getDeclaration().getName();
this.fileName = fileName;
/* Read the fields */
- this.fContent = new CtfTmfContent(ITmfEventField.ROOT_FIELD_ID,
- parseFields(eventDef));
+ this.fContent = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, parseFields(eventDef));
+
+ /* Keep a reference to this event's CTF declaration */
+ this.fDeclaration = eventDef.getDeclaration();
}
/**
* Extract the field information from the structDefinition haze-inducing
* mess, and put them into something ITmfEventField can cope with.
- *
- * @param eventDef
- * @return
*/
- private static CtfTmfEventField[] parseFields(EventDefinition eventDef) {
+ private CtfTmfEventField[] parseFields(EventDefinition eventDef) {
List fields = new ArrayList();
StructDefinition structFields = eventDef.getFields();
HashMap definitions = structFields.getDefinitions();
- String curFieldName;
+ String curFieldName = null;
Definition curFieldDef;
CtfTmfEventField curField;
-
- for (Entry entry : definitions.entrySet()) {
+ Iterator> it = definitions.entrySet().iterator();
+ while(it.hasNext()) {
+ Entry entry = it.next();
curFieldName = entry.getKey();
curFieldDef = entry.getValue();
curField = CtfTmfEventField.parseField(curFieldDef, curFieldName);
- if (curField == null) {
-// TmfCorePlugin.getDefault().log(
-// "We've parsed an unimplemented field type for event \"" + this.eventName //$NON-NLS-1$
-// + "\", field \"" + curFieldName + "\" of type " + curFieldDef.getClass().toString()); //$NON-NLS-1$ //$NON-NLS-2$
- }
fields.add(curField);
}
+ /* Add context information as CtfTmfEventField */
+ long ip = -1;
+ StructDefinition structContext = eventDef.getContext();
+ if (structContext != null) {
+ definitions = structContext.getDefinitions();
+ String curContextName;
+ Definition curContextDef;
+ CtfTmfEventField curContext;
+ it = definitions.entrySet().iterator();
+ while(it.hasNext()) {
+ Entry entry = it.next();
+ /* This is to get the instruction pointer if available */
+ if (entry.getKey().equals("_ip") && //$NON-NLS-1$
+ (entry.getValue() instanceof IntegerDefinition)) {
+ ip = ((IntegerDefinition) entry.getValue()).getValue();
+ }
+ /* Prefix field name to */
+ curContextName = CONTEXT_FIELD_PREFIX + entry.getKey();
+ curContextDef = entry.getValue();
+ curContext = CtfTmfEventField.parseField(curContextDef, curContextName);
+ fields.add(curContext);
+ }
+ }
+ /* Add callsite */
+ final String name = eventDef.getDeclaration().getName();
+ List eventList = fTrace.getCTFTrace().getCallsiteCandidates(name);
+ if (!eventList.isEmpty()) {
+ final String callsite = "callsite"; //$NON-NLS-1$
+ if (eventList.size() == 1 || ip == -1) {
+ CTFCallsite cs = eventList.get(0);
+ fields.add(new CTFStringField(cs.toString(), callsite));
+ } else {
+ fields.add(new CTFStringField(
+ fTrace.getCTFTrace().getCallsite(name, ip).toString(),
+ callsite));
+ }
+ }
+
return fields.toArray(new CtfTmfEventField[fields.size()]);
}
@@ -126,11 +179,16 @@ public final class CtfTmfEvent implements ITmfEvent {
* Copy constructor
*
* @param other
+ * CtfTmfEvent to copy
*/
public CtfTmfEvent(CtfTmfEvent other) {
+ /* There is only one reference to the trace, so we can shallow-copy it */
this.fTrace = other.getTrace();
+
+ /* Copy the timestamp (immutable) */
+ this.fTimestamp = other.fTimestamp;
+
/* Primitives, those will be copied by value */
- this.timestamp = other.timestamp;
this.sourceCPU = other.sourceCPU;
this.typeId = other.typeId;
@@ -138,66 +196,66 @@ public final class CtfTmfEvent implements ITmfEvent {
this.eventName = other.eventName;
this.fileName = other.fileName;
- /* Copy the fields over */
- this.fContent = (CtfTmfContent) other.fContent.clone();
+ /* Copy the fields over (immutable) */
+ this.fContent = other.fContent;
+
+ /*
+ * Copy the reference to the custom attributes (should be the same
+ * object for all events of this type)
+ */
+ this.fDeclaration = other.fDeclaration;
}
/**
- * Inner constructor to create "null" events. Don't use this directly, use
- * CTFEvent.getNullEvent();
+ * Inner constructor to create "null" events. Don't use this directly in
+ * normal usage, use CtfTmfEvent.getNullEvent() to get an instance of an
+ * empty event.
+ *
+ * This needs to be public however because it's used in extension points,
+ * and the framework will use this constructor to get the class type.
*/
public CtfTmfEvent() {
this.fTrace = null;
- this.timestamp = -1;
+ this.fTimestamp = new CtfTmfTimestamp(-1);
this.sourceCPU = -1;
this.typeId = -1;
this.fileName = NO_STREAM;
this.eventName = EMPTY_CTF_EVENT_NAME;
- this.fContent = null;
+ this.fContent = new TmfEventField("", new CtfTmfEventField[0]); //$NON-NLS-1$
+ this.fDeclaration = null;
}
// ------------------------------------------------------------------------
// Getters/Setters/Predicates
// ------------------------------------------------------------------------
- private static CtfTmfEvent nullEvent = null;
+ private static CtfTmfEvent nullEvent = new CtfTmfEvent();
/**
* Get a null event
*
- * @return an empty event.
+ * @return An empty event.
*/
public static CtfTmfEvent getNullEvent() {
- if (nullEvent == null) {
- nullEvent = new CtfTmfEvent();
- }
return nullEvent;
}
- /**
- * Gets the current timestamp of the event
- *
- * @return the current timestamp (long)
- */
- public long getTimestampValue() {
- return this.timestamp;
- }
-
/**
* Gets the cpu core the event was recorded on.
*
- * @return the cpu id for a given source. In lttng it's from CPUINFO
+ * @return The cpu id for a given source. In lttng it's from CPUINFO
*/
public int getCPU() {
return this.sourceCPU;
}
/**
- * Return this event's ID, according to the trace's metadata. Watch out,
- * this ID is not constant from one trace to another for the same event
- * types! Use "getEventName()" for a constant reference.
+ * Return this event's ID, according to the trace's metadata.
*
- * @return the event ID
+ * Watch out, this ID is not constant from one trace to another for the same
+ * event types! Use "getEventName()" for a constant reference.
+ *
+ * @return The event ID
*/
public long getID() {
return this.typeId;
@@ -206,7 +264,7 @@ public final class CtfTmfEvent implements ITmfEvent {
/**
* Gets the name of a current event.
*
- * @return the event name
+ * @return The event name
*/
public String getEventName() {
return eventName;
@@ -215,7 +273,7 @@ public final class CtfTmfEvent implements ITmfEvent {
/**
* Gets the channel name of a field.
*
- * @return the channel name.
+ * @return The channel name.
*/
public String getChannelName() {
return this.fileName;
@@ -232,35 +290,24 @@ public final class CtfTmfEvent implements ITmfEvent {
return 0;
}
- private ITmfTimestamp fTimestamp = null;
-
- // TODO Benchmark if the singleton approach is faster than just
- // instantiating a final fTimestramp right away at creation time
@Override
public ITmfTimestamp getTimestamp() {
- if (fTimestamp == null) {
- fTimestamp = new CtfTmfTimestamp(timestamp, fTrace);
- }
return fTimestamp;
}
- String fSource = null;
@Override
public String getSource() {
// TODO Returns CPU for now
- if(fSource == null) {
- fSource= Integer.toString(getCPU());
- }
- return fSource;
+ return Integer.toString(getCPU());
}
- private CtfTmfEventType type = null;
@Override
public ITmfEventType getType() {
- if(type == null){
- type = new CtfTmfEventType(CONTEXT_ID, eventName, fContent);
+ CtfTmfEventType ctfTmfEventType = CtfTmfEventType.get(eventName);
+ if( ctfTmfEventType == null ){
+ ctfTmfEventType = new CtfTmfEventType( this.getEventName(), this.getContent());
}
- return type;
+ return ctfTmfEventType;
}
@Override
@@ -268,17 +315,54 @@ public final class CtfTmfEvent implements ITmfEvent {
return fContent;
}
- String fReference = null;
@Override
public String getReference() {
- if( fReference == null){
- fReference = getChannelName();
+ return getChannelName();
+ }
+
+ /**
+ * List the custom CTF attributes for events of this type.
+ *
+ * @return The list of custom attribute names. Should not be null, but could
+ * be empty.
+ * @since 2.0
+ */
+ public Set listCustomAttributes() {
+ if (fDeclaration == null) {
+ return new HashSet();
}
- return fReference;
+ return fDeclaration.getCustomAttributes();
+ }
+
+ /**
+ * Get the value of a custom CTF attributes for this event's type.
+ *
+ * @param name
+ * Name of the the custom attribute
+ * @return Value of this attribute, or null if there is no attribute with
+ * that name
+ * @since 2.0
+ */
+ public String getCustomAttribute(String name) {
+ if (fDeclaration == null) {
+ return null;
+ }
+ return fDeclaration.getCustomAttribute(name);
}
@Override
public CtfTmfEvent clone() {
return new CtfTmfEvent(this);
}
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public Object getAdapter(Class adapter) {
+ if (adapter == IPropertySource.class) {
+ return new TmfEventPropertySource(this);
+ }
+ return null;
+ }
}