org.eclipse.linuxtools.lttng2.kernel.ui/src/org/eclipse/linuxtools/internal/lttng2/kernel/ui/views/controlflow/ControlFlowPresentationProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Ericsson, École Polytechnique de Montréal
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Patrick Tasse - Initial API and implementation
  11  *   Geneviève Bastien - Move code to provide base classes for time graph view
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.controlflow;
  15
  16 import java.util.LinkedHashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19
  20 import org.eclipse.linuxtools.internal.lttng2.kernel.core.Attributes;
  21 import org.eclipse.linuxtools.internal.lttng2.kernel.core.StateValues;
  22 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Messages;
  23 import org.eclipse.linuxtools.lttng2.kernel.core.trace.LttngKernelTrace;
  24 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  25 import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
  26 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  27 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  28 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  29 import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
  30 import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
  31 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.StateItem;
  32 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphPresentationProvider;
  33 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  34 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeEvent;
  35 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
  36 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils;
  37 import org.eclipse.swt.SWT;
  38 import org.eclipse.swt.graphics.GC;
  39 import org.eclipse.swt.graphics.RGB;
  40 import org.eclipse.swt.graphics.Rectangle;
  41
  42 /**
  43  * Presentation provider for the control flow view
  44  */
  45 public class ControlFlowPresentationProvider extends TimeGraphPresentationProvider {
  46
  47     private enum State {
  48         UNKNOWN        (new RGB(100, 100, 100)),
  49         WAIT_BLOCKED   (new RGB(200, 200, 0)),
  50         WAIT_FOR_CPU   (new RGB(200, 100, 0)),
  51         USERMODE       (new RGB(0,   200, 0)),
  52         SYSCALL        (new RGB(0,     0, 200)),
  53         INTERRUPTED    (new RGB(200,   0, 100));
  54
  55         public final RGB rgb;
  56
  57         private State(RGB rgb) {
  58             this.rgb = rgb;
  59         }
  60
  61     }
  62
  63     /**
  64      * Default constructor
  65      */
  66     public ControlFlowPresentationProvider() {
  67         super(Messages.ControlFlowView_stateTypeName);
  68     }
  69
  70     private static State[] getStateValues() {
  71         return State.values();
  72     }
  73
  74     @Override
  75     public StateItem[] getStateTable() {
  76         State[] states = getStateValues();
  77         StateItem[] stateTable = new StateItem[states.length];
  78         for (int i = 0; i < stateTable.length; i++) {
  79             State state = states[i];
  80             stateTable[i] = new StateItem(state.rgb, state.toString());
  81         }
  82         return stateTable;
  83     }
  84
  85     @Override
  86     public int getStateTableIndex(ITimeEvent event) {
  87         if (event instanceof TimeEvent && ((TimeEvent) event).hasValue()) {
  88             int status = ((TimeEvent) event).getValue();
  89             return getMatchingState(status).ordinal();
  90         }
  91         return TRANSPARENT;
  92     }
  93
  94     @Override
  95     public String getEventName(ITimeEvent event) {
  96         if (event instanceof TimeEvent) {
  97             TimeEvent ev = (TimeEvent) event;
  98             if (ev.hasValue()) {
  99                 return getMatchingState(ev.getValue()).toString();
 100             }
 101         }
 102         return Messages.ControlFlowView_multipleStates;
 103     }
 104
 105     private static State getMatchingState(int status) {
 106         switch (status) {
 107         case StateValues.PROCESS_STATUS_WAIT_BLOCKED:
 108             return State.WAIT_BLOCKED;
 109         case StateValues.PROCESS_STATUS_WAIT_FOR_CPU:
 110             return State.WAIT_FOR_CPU;
 111         case StateValues.PROCESS_STATUS_RUN_USERMODE:
 112             return State.USERMODE;
 113         case StateValues.PROCESS_STATUS_RUN_SYSCALL:
 114             return State.SYSCALL;
 115         case StateValues.PROCESS_STATUS_INTERRUPTED:
 116             return State.INTERRUPTED;
 117         default:
 118             return State.UNKNOWN;
 119         }
 120     }
 121
 122     @Override
 123     public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event) {
 124         Map<String, String> retMap = new LinkedHashMap<String, String>();
 125
 126         if (event instanceof TimeEvent && ((TimeEvent) event).hasValue()) {
 127             TimeGraphEntry entry = (TimeGraphEntry) event.getEntry();
 128             ITmfStateSystem ssq = entry.getTrace().getStateSystems().get(LttngKernelTrace.STATE_ID);
 129             if (entry instanceof ControlFlowEntry) {
 130                 ControlFlowEntry entry2 = (ControlFlowEntry) entry;
 131                 int tid = entry2.getThreadId();
 132
 133                 try {
 134                     // Find every CPU first, then get the current thread
 135                     int cpusQuark = ssq.getQuarkAbsolute(Attributes.CPUS);
 136                     List<Integer> cpuQuarks = ssq.getSubAttributes(cpusQuark, false);
 137                     for (Integer cpuQuark : cpuQuarks) {
 138                         int currentThreadQuark = ssq.getQuarkRelative(cpuQuark, Attributes.CURRENT_THREAD);
 139                         ITmfStateInterval interval = ssq.querySingleState(event.getTime(), currentThreadQuark);
 140                         if (!interval.getStateValue().isNull()) {
 141                             ITmfStateValue state = interval.getStateValue();
 142                             int currentThreadId = state.unboxInt();
 143                             if (tid == currentThreadId) {
 144                                 retMap.put(Messages.ControlFlowView_attributeCpuName, ssq.getAttributeName(cpuQuark));
 145                                 break;
 146                             }
 147                         }
 148                     }
 149
 150                 } catch (AttributeNotFoundException e) {
 151                     e.printStackTrace();
 152                 } catch (TimeRangeException e) {
 153                     e.printStackTrace();
 154                 } catch (StateValueTypeException e) {
 155                     e.printStackTrace();
 156                 } catch (StateSystemDisposedException e) {
 157                     /* Ignored */
 158                 }
 159                 int status = ((TimeEvent) event).getValue();
 160                 if (status == StateValues.PROCESS_STATUS_RUN_SYSCALL) {
 161                     try {
 162                         int syscallQuark = ssq.getQuarkRelative(entry2.getThreadQuark(), Attributes.SYSTEM_CALL);
 163                         ITmfStateInterval value = ssq.querySingleState(event.getTime(), syscallQuark);
 164                         if (!value.getStateValue().isNull()) {
 165                             ITmfStateValue state = value.getStateValue();
 166                             retMap.put(Messages.ControlFlowView_attributeSyscallName, state.toString());
 167                         }
 168
 169                     } catch (AttributeNotFoundException e) {
 170                         e.printStackTrace();
 171                     } catch (TimeRangeException e) {
 172                         e.printStackTrace();
 173                     } catch (StateSystemDisposedException e) {
 174                         /* Ignored */
 175                     }
 176                 }
 177             }
 178         }
 179
 180         return retMap;
 181     }
 182
 183     @Override
 184     public void postDrawEvent(ITimeEvent event, Rectangle bounds, GC gc) {
 185         if (bounds.width <= gc.getFontMetrics().getAverageCharWidth()) {
 186             return;
 187         }
 188         if (!(event instanceof TimeEvent)) {
 189             return;
 190         }
 191         ControlFlowEntry entry = (ControlFlowEntry) event.getEntry();
 192         ITmfStateSystem ss = entry.getTrace().getStateSystems().get(LttngKernelTrace.STATE_ID);
 193         int status = ((TimeEvent) event).getValue();
 194
 195         if (status != StateValues.PROCESS_STATUS_RUN_SYSCALL) {
 196             return;
 197         }
 198         try {
 199             int syscallQuark = ss.getQuarkRelative(entry.getThreadQuark(), Attributes.SYSTEM_CALL);
 200             ITmfStateInterval value = ss.querySingleState(event.getTime(), syscallQuark);
 201             if (!value.getStateValue().isNull()) {
 202                 ITmfStateValue state = value.getStateValue();
 203                 gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_WHITE));
 204                 Utils.drawText(gc, state.toString().substring(4), bounds.x, bounds.y - 2, bounds.width, true, true);
 205             }
 206         } catch (AttributeNotFoundException e) {
 207             e.printStackTrace();
 208         } catch (TimeRangeException e) {
 209             e.printStackTrace();
 210         } catch (StateSystemDisposedException e) {
 211             /* Ignored */
 212         }
 213     }
 214 }