lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/views/memusage/MemoryUsageViewer.java

   1 /**********************************************************************
   2  * Copyright (c) 2014 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  *   Bernd Hufmann - Initial API and implementation
  11  *   Geneviève Bastien - Create and use base class for XY plots
  12  **********************************************************************/
  13
  14 package org.eclipse.tracecompass.internal.lttng2.ust.ui.views.memusage;
  15
  16 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  17
  18 import java.util.HashMap;
  19 import java.util.List;
  20 import java.util.Map;
  21
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.swt.SWT;
  24 import org.eclipse.swt.widgets.Composite;
  25 import org.eclipse.tracecompass.common.core.format.DataSizeWithUnitFormat;
  26 import org.eclipse.tracecompass.internal.lttng2.ust.core.analysis.memory.UstMemoryStrings;
  27 import org.eclipse.tracecompass.internal.lttng2.ust.ui.Activator;
  28 import org.eclipse.tracecompass.lttng2.ust.core.analysis.memory.UstMemoryAnalysisModule;
  29 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
  30 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  31 import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
  32 import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
  33 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  34 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
  35 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  36 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
  37 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  38 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  39 import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.linecharts.TmfCommonXLineChartViewer;
  40 import org.swtchart.Chart;
  41
  42 /**
  43  * Memory usage view
  44  *
  45  * @author Matthew Khouzam
  46  */
  47 public class MemoryUsageViewer extends TmfCommonXLineChartViewer {
  48
  49     private TmfStateSystemAnalysisModule fModule = null;
  50
  51     private final Map<Integer, double[]> fYValues = new HashMap<>();
  52     private final Map<Integer, Integer> fMemoryQuarks = new HashMap<>();
  53     private final Map<Integer, String> fSeriesName = new HashMap<>();
  54
  55     // Timeout between updates in the updateData thread
  56     private static final long BUILD_UPDATE_TIMEOUT = 500;
  57
  58     /**
  59      * Constructor
  60      *
  61      * @param parent
  62      *            parent view
  63      */
  64     public MemoryUsageViewer(Composite parent) {
  65         super(parent, Messages.MemoryUsageViewer_Title, Messages.MemoryUsageViewer_XAxis, Messages.MemoryUsageViewer_YAxis);
  66         Chart chart = getSwtChart();
  67         chart.getLegend().setPosition(SWT.LEFT);
  68         chart.getAxisSet().getYAxis(0).getTick().setFormat(DataSizeWithUnitFormat.getInstance());
  69     }
  70
  71     @Override
  72     protected void initializeDataSource() {
  73         ITmfTrace trace = getTrace();
  74         if (trace != null) {
  75             fModule = TmfTraceUtils.getAnalysisModuleOfClass(trace, TmfStateSystemAnalysisModule.class, UstMemoryAnalysisModule.ID);
  76             if (fModule == null) {
  77                 return;
  78             }
  79             fModule.schedule();
  80         }
  81     }
  82
  83     @Override
  84     protected void updateData(long start, long end, int nb, IProgressMonitor monitor) {
  85         try {
  86             if (getTrace() == null || fModule == null) {
  87                 return;
  88             }
  89             if (!fModule.waitForInitialization()) {
  90                 return;
  91             }
  92             ITmfStateSystem ss = fModule.getStateSystem();
  93             /* Don't wait for the module completion, when it's ready, we'll know */
  94             if (ss == null) {
  95                 return;
  96             }
  97
  98             double[] xvalues = getXAxis(start, end, nb);
  99             setXAxis(xvalues);
 100
 101             boolean complete = false;
 102             long currentEnd = start;
 103
 104             while (!complete && currentEnd < end) {
 105                 if (monitor.isCanceled()) {
 106                     return;
 107                 }
 108                 complete = ss.waitUntilBuilt(BUILD_UPDATE_TIMEOUT);
 109                 currentEnd = ss.getCurrentEndTime();
 110                 List<Integer> tidQuarks = ss.getSubAttributes(-1, false);
 111                 long traceStart = getStartTime();
 112                 long traceEnd = getEndTime();
 113                 long offset = this.getTimeOffset();
 114
 115                 /* Initialize quarks and series names */
 116                 List<ITmfStateInterval> fullState = ss.queryFullState(start);
 117                 for (int quark : tidQuarks) {
 118                     fYValues.put(quark, new double[xvalues.length]);
 119                     fMemoryQuarks.put(quark, ss.getQuarkRelative(quark, UstMemoryStrings.UST_MEMORY_MEMORY_ATTRIBUTE));
 120                     int procNameQuark = ss.getQuarkRelative(quark, UstMemoryStrings.UST_MEMORY_PROCNAME_ATTRIBUTE);
 121                     String oldSeriesName = fSeriesName.get(quark);
 122                     String seriesName = null;
 123                     try {
 124                         ITmfStateValue procnameValue = fullState.get(procNameQuark).getStateValue();
 125                         String procname = ""; //$NON-NLS-1$
 126                         if (!procnameValue.isNull()) {
 127                             procname = procnameValue.unboxStr();
 128                         }
 129                         seriesName = (procname + ' ' + '(' + ss.getAttributeName(quark) + ')').trim();
 130                     } catch (TimeRangeException e) {
 131                         seriesName = '(' + ss.getAttributeName(quark) + ')';
 132                     }
 133
 134                     if (oldSeriesName != null && !oldSeriesName.equals(seriesName)) {
 135                         deleteSeries(oldSeriesName);
 136                     }
 137                     fSeriesName.put(quark, seriesName);
 138                 }
 139
 140                 /*
 141                  * TODO: It should only show active threads in the time range.
 142                  * If a tid does not have any memory value (only 1 interval in
 143                  * the time range with value null or 0), then its series should
 144                  * not be displayed.
 145                  */
 146                 double yvalue = 0.0;
 147                 for (int i = 0; i < xvalues.length; i++) {
 148                     if (monitor.isCanceled()) {
 149                         return;
 150                     }
 151                     double x = xvalues[i];
 152                     long time = (long) x + offset;
 153                     // make sure that time is in the trace range after double to
 154                     // long conversion
 155                     time = time < traceStart ? traceStart : time;
 156                     time = time > traceEnd ? traceEnd : time;
 157                     try {
 158                         fullState = ss.queryFullState(time);
 159                         for (int quark : tidQuarks) {
 160                             double[] values = checkNotNull(fYValues.get(quark));
 161
 162                             Integer memQuark = checkNotNull(fMemoryQuarks.get(quark));
 163                             yvalue = fullState.get(memQuark.intValue()).getStateValue().unboxLong();
 164                             values[i] = yvalue;
 165                         }
 166                     } catch (TimeRangeException e) {
 167                         for (int quark : tidQuarks) {
 168                             double[] values = checkNotNull(fYValues.get(quark));
 169                             values[i] = 0;
 170                         }
 171                     }
 172                 }
 173                 for (int quark : tidQuarks) {
 174                     setSeries(fSeriesName.get(quark), fYValues.get(quark));
 175                 }
 176                 updateDisplay();
 177             }
 178         } catch (AttributeNotFoundException | StateValueTypeException e) {
 179             Activator.getDefault().logError("Error updating the data of the Memory usage view", e); //$NON-NLS-1$
 180         } catch (StateSystemDisposedException e) {
 181             /* State system is closing down, no point continuing */
 182         }
 183     }
 184
 185 }