analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/internal/analysis/os/linux/core/latency/SystemCallLatencyAnalysis.java

   1 /*******************************************************************************
   2  * Copyright (c) 2015, 2016 EfficiOS Inc., Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *******************************************************************************/
   9
  10 package org.eclipse.tracecompass.internal.analysis.os.linux.core.latency;
  11
  12 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  13
  14 import java.io.IOException;
  15 import java.io.ObjectInputStream;
  16 import java.util.Collection;
  17 import java.util.Collections;
  18 import java.util.Comparator;
  19 import java.util.HashMap;
  20 import java.util.Map;
  21
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.NullProgressMonitor;
  24 import org.eclipse.jdt.annotation.NonNull;
  25 import org.eclipse.jdt.annotation.Nullable;
  26 import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelTidAspect;
  27 import org.eclipse.tracecompass.analysis.os.linux.core.tid.TidAnalysisModule;
  28 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
  29 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelTrace;
  30 import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisEventBasedModule;
  31 import org.eclipse.tracecompass.segmentstore.core.ISegment;
  32 import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
  33 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
  34 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  35 import org.eclipse.tracecompass.tmf.core.segment.ISegmentAspect;
  36 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  37
  38 import com.google.common.collect.ImmutableList;
  39 import com.google.common.collect.ImmutableSet;
  40
  41 /**
  42  * @author Alexandre Montplaisir
  43  * @since 2.0
  44  */
  45 public class SystemCallLatencyAnalysis extends AbstractSegmentStoreAnalysisEventBasedModule {
  46
  47     /**
  48      * The ID of this analysis
  49      */
  50     public static final String ID = "org.eclipse.tracecompass.analysis.os.linux.latency.syscall"; //$NON-NLS-1$
  51
  52     private static final String DATA_FILENAME = "latency-analysis.dat"; //$NON-NLS-1$
  53
  54     private static final Collection<ISegmentAspect> BASE_ASPECTS =
  55             ImmutableList.of(SyscallNameAspect.INSTANCE);
  56
  57     @Override
  58     public String getId() {
  59         return ID;
  60     }
  61
  62     @Override
  63     protected Iterable<IAnalysisModule> getDependentAnalyses() {
  64         ITmfTrace trace = getTrace();
  65         if (trace == null) {
  66             throw new IllegalStateException();
  67         }
  68         IAnalysisModule module = trace.getAnalysisModule(TidAnalysisModule.ID);
  69         if (module == null) {
  70             return Collections.EMPTY_SET;
  71         }
  72         return ImmutableSet.of(module);
  73     }
  74
  75     @Override
  76     public Iterable<ISegmentAspect> getSegmentAspects() {
  77         return BASE_ASPECTS;
  78     }
  79
  80     @Override
  81     public @NonNull String getDataFileName() {
  82         return DATA_FILENAME;
  83     }
  84
  85     @Override
  86     public AbstractSegmentStoreAnalysisRequest createAnalysisRequest(ISegmentStore<ISegment> syscalls) {
  87         return new SyscallLatencyAnalysisRequest(syscalls);
  88     }
  89
  90     @Override
  91     protected Object[] readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
  92         return checkNotNull((Object[]) ois.readObject());
  93     }
  94
  95     private class SyscallLatencyAnalysisRequest extends AbstractSegmentStoreAnalysisRequest {
  96
  97         private final Map<Integer, SystemCall.InitialInfo> fOngoingSystemCalls = new HashMap<>();
  98         private @Nullable IKernelAnalysisEventLayout fLayout;
  99         private final IProgressMonitor fMonitor = new NullProgressMonitor();
 100
 101         public SyscallLatencyAnalysisRequest(ISegmentStore<ISegment> syscalls) {
 102             super(syscalls);
 103         }
 104
 105         @Override
 106         public void handleData(final ITmfEvent event) {
 107             super.handleData(event);
 108             IKernelAnalysisEventLayout layout = fLayout;
 109             if (layout == null) {
 110                 IKernelTrace trace = (IKernelTrace) event.getTrace();
 111                 layout = trace.getKernelEventLayout();
 112                 fLayout = layout;
 113             }
 114             final String eventName = event.getType().getName();
 115
 116             if (eventName.startsWith(layout.eventSyscallEntryPrefix()) ||
 117                     eventName.startsWith(layout.eventCompatSyscallEntryPrefix())) {
 118                 /* This is a system call entry event */
 119
 120                 Integer tid;
 121                 try {
 122                     tid = KernelTidAspect.INSTANCE.resolve(event, true, fMonitor);
 123                 } catch (InterruptedException e) {
 124                     return;
 125                 }
 126                 if (tid == null) {
 127                     // no information on this event/trace ?
 128                     return;
 129                 }
 130
 131                 /* Record the event's data into the intial system call info */
 132                 // String syscallName = fLayout.getSyscallNameFromEvent(event);
 133                 long startTime = event.getTimestamp().getValue();
 134                 String syscallName = eventName.substring(layout.eventSyscallEntryPrefix().length());
 135
 136                 SystemCall.InitialInfo newSysCall = new SystemCall.InitialInfo(startTime, syscallName.intern());
 137                 fOngoingSystemCalls.put(tid, newSysCall);
 138
 139             } else if (eventName.startsWith(layout.eventSyscallExitPrefix())) {
 140                 /* This is a system call exit event */
 141
 142                 Integer tid;
 143                 try {
 144                     tid = KernelTidAspect.INSTANCE.resolve(event, true, fMonitor);
 145                 } catch (InterruptedException e) {
 146                     return;
 147                 }
 148                 if (tid == null) {
 149                     return;
 150                 }
 151
 152                 SystemCall.InitialInfo info = fOngoingSystemCalls.remove(tid);
 153                 if (info == null) {
 154                     /*
 155                      * We have not seen the entry event corresponding to this
 156                      * exit (lost event, or before start of trace).
 157                      */
 158                     return;
 159                 }
 160
 161                 long endTime = event.getTimestamp().getValue();
 162                 ISegment syscall = new SystemCall(info, endTime);
 163                 getSegmentStore().add(syscall);
 164             }
 165         }
 166
 167         @Override
 168         public void handleCompleted() {
 169             fOngoingSystemCalls.clear();
 170             super.handleCompleted();
 171         }
 172
 173         @Override
 174         public void handleCancel() {
 175             fMonitor.setCanceled(true);
 176             super.handleCancel();
 177         }
 178     }
 179
 180     private static final class SyscallNameAspect implements ISegmentAspect {
 181         public static final ISegmentAspect INSTANCE = new SyscallNameAspect();
 182
 183         private SyscallNameAspect() { }
 184
 185         @Override
 186         public String getHelpText() {
 187             return checkNotNull(Messages.SegmentAspectHelpText_SystemCall);
 188         }
 189         @Override
 190         public String getName() {
 191             return checkNotNull(Messages.SegmentAspectName_SystemCall);
 192         }
 193         @Override
 194         public @Nullable Comparator<?> getComparator() {
 195             return null;
 196         }
 197         @Override
 198         public @Nullable String resolve(ISegment segment) {
 199             if (segment instanceof SystemCall) {
 200                 return ((SystemCall) segment).getName();
 201             }
 202             return EMPTY_STRING;
 203         }
 204     }
 205
 206 }