| /******************************************************************************* |
| * Copyright (c) 2016 École Polytechnique de Montréal |
| * |
| * All rights reserved. This program and the accompanying materials are |
| * made available under the terms of the Eclipse Public License 2.0 which |
| * accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| *******************************************************************************/ |
| |
| package org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout; |
| import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelTrace; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.backend.BackendStateValue; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.backend.StateMachineBackendAnalysis; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.constraint.Operator; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.constraint.StateMachineConstraint; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.constraint.ValueType; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.exception.StateMachineNoInvalidCaseException; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.exception.StateMachineNoValidCaseException; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.exception.StateMachineStateSystemNotFoundException; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.exception.StateMachineStateSystemTimeRangeException; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.exception.StateMachineTIDNotFoundException; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.exception.StateMachineVariableException; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable.StateMachineVariableAnalysis.InterruptionEventRunner; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable.utils.InterruptionEvent; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable.utils.InterruptionEventList; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable.utils.InterruptionReason; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable.utils.ResponsibilityMap; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable.utils.State; |
| import org.eclipse.tracecompass.incubator.internal.xaf.core.statemachine.variable.utils.StateMachineVariableHelpers; |
| import org.eclipse.tracecompass.incubator.internal.xaf.ui.statemachine.StateMachineBenchmark; |
| import org.eclipse.tracecompass.incubator.internal.xaf.ui.statemachine.StateMachineInstance; |
| import org.eclipse.tracecompass.incubator.internal.xaf.ui.statemachine.StateMachineInstanceGroup; |
| import org.eclipse.tracecompass.incubator.internal.xaf.ui.statemachine.StateMachineReport; |
| import org.eclipse.tracecompass.incubator.internal.xaf.ui.statemachine.StateMachineUtils; |
| import org.eclipse.tracecompass.incubator.internal.xaf.ui.statemachine.StateMachineInstance.InstanceStepInformation; |
| import org.eclipse.tracecompass.incubator.internal.xaf.ui.statemachine.StateMachineUtils.TimestampInterval; |
| import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem; |
| import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval; |
| import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; |
| import org.eclipse.tracecompass.tmf.core.event.ITmfEventField; |
| import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp; |
| import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp; |
| import org.eclipse.tracecompass.tmf.core.trace.ITmfContext; |
| import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace; |
| |
| /** |
| * Class that represents a state machine variable of timer class |
| * |
| * @author Raphaël Beamonte |
| */ |
| public abstract class StateMachineVariableTimer extends StateMachineVariable { |
| |
| /** |
| * @param name |
| * The name of the variable |
| * @param value |
| * The initial value of the variable |
| */ |
| @SuppressWarnings("rawtypes") |
| public StateMachineVariableTimer(String name, Comparable value) { |
| super(name, value); |
| } |
| |
| /** |
| * @return The attribute of this variable in the backend |
| */ |
| public abstract String getTimerAttribute(); |
| |
| @Override |
| public Comparable getValue(ITmfEvent event, StateMachineInstance stateMachineInstance) throws StateMachineVariableException { |
| if (stateMachineInstance.getStateMachineInstanceGroup().getStateMachineBackendAnalysisModules().isEmpty()) { |
| throw new StateMachineVariableException("State system unavailable"); //$NON-NLS-1$ |
| } |
| |
| ITmfTimestamp intervalStart = (ITmfTimestamp) getValue(); |
| ITmfTimestamp intervalEnd = event.getTimestamp(); |
| |
| int tid = stateMachineInstance.getVTid(); |
| long usage = 0; |
| for (StateMachineBackendAnalysis kernelAnalysisModule : stateMachineInstance.getStateMachineInstanceGroup().getStateMachineBackendAnalysisModules()) { |
| Long lusage = kernelAnalysisModule.getTimerIntvl(tid, intervalStart.getValue(), intervalEnd.getValue(), getTimerAttribute()); |
| if (lusage != null) { |
| usage += lusage; |
| } |
| } |
| |
| return usage; |
| } |
| |
| @Override |
| public Integer compareTo(Comparable toCompare, ITmfEvent event, StateMachineInstance stateMachineInstance) throws StateMachineVariableException { |
| ITmfTimestamp intervalStart = (ITmfTimestamp) getValue(); |
| ITmfTimestamp intervalEnd = event.getTimestamp(); |
| |
| long usage = (long) getValue(event, stateMachineInstance); |
| double intvl = intervalEnd.getValue() - intervalStart.getValue(); |
| Integer comparison = new Double(usage).compareTo(StateMachineUtils.getValueFromPercent((String) toCompare, intvl)); |
| |
| return comparison; |
| } |
| |
| @Override |
| public Double getNumericalValue(Comparable format, ITmfEvent event, StateMachineInstance stateMachineInstance) { |
| try { |
| Double delta = ((Long) getValue(event, stateMachineInstance)).doubleValue(); |
| |
| if (((String) format).endsWith("%")) { //$NON-NLS-1$ |
| ITmfTimestamp intervalStart = (ITmfTimestamp) getValue(); |
| ITmfTimestamp intervalEnd = event.getTimestamp(); |
| double intvl = intervalEnd.getValue() - intervalStart.getValue(); |
| delta = delta / intvl * 100; |
| } |
| |
| return delta; |
| } catch (StateMachineVariableException e) { |
| return null; |
| } |
| } |
| |
| @Override |
| public String getFormattedValue(Comparable format, ITmfEvent event, StateMachineInstance stateMachineInstance) { |
| Double delta; |
| try { |
| delta = ((Long) getValue(event, stateMachineInstance)).doubleValue(); |
| |
| if (((String) format).endsWith("%")) { //$NON-NLS-1$ |
| ITmfTimestamp intervalStart = (ITmfTimestamp) getValue(); |
| ITmfTimestamp intervalEnd = event.getTimestamp(); |
| double intvl = intervalEnd.getValue() - intervalStart.getValue(); |
| delta = delta / intvl * 100; |
| } |
| } catch (StateMachineVariableException e) { |
| delta = null; |
| } |
| |
| return getFormattedValue(format, delta); |
| } |
| |
| @Override |
| public String getFormattedValue(Comparable format, Double value) { |
| if (value == null) { |
| return "unavailable"; //$NON-NLS-1$ |
| } |
| |
| String result = null; |
| |
| if (((String) format).endsWith("%")) { //$NON-NLS-1$ |
| result = String.format("%.4f%%", //$NON-NLS-1$ |
| value); |
| } else { |
| result = String.valueOf(value); |
| } |
| return result; |
| } |
| |
| /** |
| * Interruption event runner for Timers |
| * |
| * @author Raphaël Beamonte |
| */ |
| public class DefaultTimerInterruptionEventRunner extends InterruptionEventRunner { |
| private final StateMachineVariableTimer variable; |
| private final String attribute; |
| private Map<ITmfTrace, ITmfContext> contextPerTrace = new HashMap<>(); |
| |
| /** |
| * To create a DefaultTimerInterruptionEventRunner |
| * |
| * @param variable |
| * The variable for which this interruption event runner will |
| * run |
| */ |
| public DefaultTimerInterruptionEventRunner(StateMachineVariableTimer variable) { |
| this.variable = variable; |
| this.attribute = variable.getTimerAttribute(); |
| } |
| |
| @Override |
| public List<InterruptionEventList> execute(InstanceStepInformation isi) throws StateMachineStateSystemNotFoundException, StateMachineTIDNotFoundException, StateMachineStateSystemTimeRangeException { |
| // Get the instance group |
| StateMachineInstanceGroup group = isi.instance.getStateMachineInstanceGroup(); |
| |
| /* |
| * If we don't have kernel analysis modules for that group, we can |
| * just drop that analysis as we won't have the needed information |
| * to analyze that constraint. We can thus return. |
| */ |
| if (group.getStateMachineBackendAnalysisModules().isEmpty()) { |
| throw new StateMachineStateSystemNotFoundException(); |
| } |
| |
| /* |
| * Thread ID of our instance. We currently only manage situations in |
| * which our model follows an unique TID |
| */ |
| Integer tid = isi.instance.getVTid(); |
| if (tid == null) { |
| throw new StateMachineTIDNotFoundException(); |
| } |
| |
| /* |
| * Get the timestamp interval for this variable application |
| */ |
| TimestampInterval ti = isi.getVariableInterval(variable.getName()); |
| |
| /* |
| * List in which we will store the events corresponding to an |
| * increment of the counter on which that variable is based |
| */ |
| List<InterruptionEventList> interruptionEventList = new ArrayList<>(); |
| |
| /// USING THE NEW STATE ATTRIBUTE |
| boolean analysisDone = false; |
| // For each analysis module... |
| for (StateMachineBackendAnalysis stateMachineBackendAnalysis : group.getStateMachineBackendAnalysisModules()) { |
| ITmfStateSystem ss = stateMachineBackendAnalysis.getStateSystem(); |
| if (ss == null || ss.getCurrentEndTime() < ti.getEndTime().getValue() || ss.getStartTime() > ti.getStartTime().getValue()) { |
| continue; |
| } |
| analysisDone = true; |
| |
| // Kernel trace on which we're currently working |
| ITmfTrace trace = stateMachineBackendAnalysis.getKernelTrace(); |
| |
| // To store the events we'll read |
| ITmfEvent e = null; |
| |
| // To store the context for this trace |
| ITmfContext ctx = contextPerTrace.get(trace); |
| |
| if (ctx != null) { |
| // Get the next event in the trace |
| e = trace.getNext(ctx); |
| |
| // If our event is after our intervalStart... we'll need to |
| // seek :( |
| if (e.getTimestamp().compareTo(ti.getStartTime()) > 0) { |
| ctx.dispose(); |
| ctx = null; |
| } |
| } |
| |
| if (ctx == null) { |
| ctx = trace.seekEvent(ti.getStartTime()); |
| contextPerTrace.put(trace, ctx); |
| |
| // Get the initial event of the interval |
| e = trace.getNext(ctx); |
| } |
| |
| // Can't happen |
| if (e == null) { |
| System.out.println("e is null and can't be null... what happened?!"); //$NON-NLS-1$ |
| return null; |
| } |
| |
| // Long value of the interval start timestamp |
| long seek = ti.getStartTime().getValue(); |
| |
| /* |
| * Get the whole interval for which the counter had the same |
| * value as the one it has at seeking time 'seek' |
| */ |
| StateMachineBenchmark benchmarkObject = new StateMachineBenchmark("Analysis SS Get"); //$NON-NLS-1$ |
| ITmfStateInterval si = stateMachineBackendAnalysis.getStateInterval(tid, seek, attribute); |
| benchmarkObject.stop(); |
| |
| /* |
| * Change the value of 'seek' to reference the start of the next |
| * value interval for that counter |
| */ |
| seek = si.getEndTime() + 1; |
| |
| /* |
| * If the new value of 'seek' is before the end of the interval, |
| * it means we incremented the counter during that interval, we |
| * thus need to get the event information and store it in our |
| * list. We'll do that as long as our 'seek' value stays before |
| * the end of the interval... |
| */ |
| |
| IKernelAnalysisEventLayout layout = ((IKernelTrace) e.getTrace()).getKernelEventLayout(); |
| while (seek < ti.getEndTime().getValue()) { |
| // Loop until we get to the event we're searching |
| while (e.getTimestamp().getValue() < seek |
| || !e.getName().equals(layout.eventSchedSwitch())) { |
| e = trace.getNext(ctx); |
| } |
| |
| /* |
| * Get the whole interval for which the counter had the same |
| * value as the one it has at seeking time 'seek' |
| */ |
| benchmarkObject = new StateMachineBenchmark("Analysis SS Get"); //$NON-NLS-1$ |
| si = stateMachineBackendAnalysis.getStateInterval(tid, seek, attribute); |
| benchmarkObject.stop(); |
| |
| /* |
| * The event should never be 'null'. If it is, show an |
| * error. If not, add it to the list. |
| */ |
| if (e.getTimestamp().getValue() > seek) { |
| System.out.println("Didn't find the event at " + seek); //$NON-NLS-1$ |
| } else { |
| ITmfEventField content = e.getContent(); |
| int tasktid = Integer.parseInt(content.getField(layout.fieldNextTid()).getFormattedValue()); |
| |
| // Get the reason of the interruption |
| int state = Integer.parseInt(content.getField(layout.fieldPrevState()).getFormattedValue()); |
| |
| InterruptionEventList taskList = new InterruptionEventList(); |
| |
| benchmarkObject = new StateMachineBenchmark("Analysis SS Get"); //$NON-NLS-1$ |
| ITmfStateInterval si2 = stateMachineBackendAnalysis.getStateInterval(tasktid, seek, attribute); |
| benchmarkObject.stop(); |
| |
| while (si2.getStartTime() < si.getEndTime()) { |
| State stateObj = new State( |
| ((state == 0 || state == 1024) ? BackendStateValue.PREEMPTED : BackendStateValue.BLOCKED).getValue(), |
| StateMachineVariableHelpers.getSchedSwitchNextProcessInformation(e)); |
| taskList.events.add(new InterruptionEvent( |
| e, TmfTimestamp.create(si2.getEndTime(), ITmfTimestamp.NANOSECOND_SCALE), |
| stateObj)); |
| |
| while (e.getTimestamp().getValue() < si2.getEndTime() |
| || !e.getName().equals(layout.eventSchedSwitch())) { |
| e = trace.getNext(ctx); |
| } |
| |
| tasktid = Integer.parseInt(e.getContent().getField(layout.fieldNextTid()).getFormattedValue()); |
| if (tasktid == tid) { |
| break; |
| } |
| |
| benchmarkObject = new StateMachineBenchmark("Analysis SS Get"); //$NON-NLS-1$ |
| si2 = stateMachineBackendAnalysis.getStateInterval(tasktid, si2.getEndTime() + 1, attribute); |
| benchmarkObject.stop(); |
| } |
| |
| if (tasktid != tid) { |
| benchmarkObject = new StateMachineBenchmark("Analysis SS Get"); //$NON-NLS-1$ |
| taskList.events.add(new InterruptionEvent(e, |
| TmfTimestamp.create( |
| si.getEndTime() - stateMachineBackendAnalysis.getTimerIntvl(tid, si.getStartTime(), si.getEndTime(), attribute), |
| ITmfTimestamp.NANOSECOND_SCALE))); |
| benchmarkObject.stop(); |
| } |
| |
| interruptionEventList.add(taskList); |
| } |
| |
| /* |
| * Change the value of seek to be able to seek the next |
| * interval in the next loop |
| */ |
| seek = si.getEndTime() + 1; |
| } |
| } |
| |
| // If we couldn't do the analysis |
| if (!analysisDone) { |
| throw new StateMachineStateSystemTimeRangeException(); |
| } |
| |
| return interruptionEventList; |
| } |
| } |
| |
| /** |
| * @return The interruption event runner for that variable |
| */ |
| public InterruptionEventRunner getInterruptionEventRunner() { |
| return new DefaultTimerInterruptionEventRunner(this); |
| } |
| |
| @Override |
| public StateMachineVariableAnalysis analyze(StateMachineConstraint constraint, List<InstanceStepInformation> invalidIsiList, List<InstanceStepInformation> validIsiList) { |
| // Treat only constants for now |
| // TODO: treat comparison between variables |
| if (constraint.getValueType() != ValueType.CONSTANT) { |
| System.out.println("TODO"); //$NON-NLS-1$ |
| return null; |
| } |
| |
| boolean partial = (constraint.getOperator() == Operator.EQ && constraint.getValue().matches("^100 *%$")); //$NON-NLS-1$ |
| |
| StateMachineVariableAnalysis smva = new StateMachineVariableAnalysis( |
| this, |
| constraint, |
| invalidIsiList, |
| validIsiList); |
| |
| InterruptionEventRunner interruptionEventRunner = getInterruptionEventRunner(); |
| |
| StateMachineReport.R.println(); |
| StateMachineReport.R.println_subsubsubsection(String.format("%s analysis: (%s)", //$NON-NLS-1$ |
| getVariableType(), |
| (partial) ? "partial" : "full")); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| if (partial) { |
| try { |
| smva.doPartialAnalysis(interruptionEventRunner); |
| } catch (StateMachineNoInvalidCaseException e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } else { |
| if (validIsiList == null || validIsiList.isEmpty()) { |
| System.out.print("No valid instance for a full analysis"); //$NON-NLS-1$ |
| return null; |
| } |
| |
| try { |
| smva.doAnalysis(interruptionEventRunner); |
| } catch (StateMachineNoValidCaseException | StateMachineNoInvalidCaseException e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| StateMachineReport.R.inc(); |
| |
| StateMachineReport.R.printDropped(smva); |
| |
| if (!partial) { |
| StateMachineReport.R.println(smva.getDifferentValidCases() + |
| " different valid situation" + (smva.getDifferentValidCases() > 1 ? "s" : "") + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| " for " + validIsiList.size() + //$NON-NLS-1$ |
| " different valid case" + (validIsiList.size() > 1 ? "s" : "") + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| "." //$NON-NLS-1$ |
| ); |
| } |
| StateMachineReport.R.println(smva.getDifferentInvalidCases() + |
| " different invalid situation" + (smva.getDifferentInvalidCases() > 1 ? "s" : "") + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| " for " + invalidIsiList.size() + //$NON-NLS-1$ |
| " different invalid case" + (invalidIsiList.size() > 1 ? "s" : "") + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| "." //$NON-NLS-1$ |
| ); |
| StateMachineReport.R.println(); |
| |
| ResponsibilityMap<InterruptionReason> analysisResponsibilityMap = smva.getAnalysisResponsibilityMap(); |
| |
| if (!partial) { |
| StateMachineReport.R.println("General computed difference between invalid and valid instances:"); //$NON-NLS-1$ |
| } |
| String[] header = { "Concerning process", "Responsibility" }; //$NON-NLS-1$ //$NON-NLS-2$ |
| String[][] strs = new String[analysisResponsibilityMap.getCollection().size()][2]; |
| int idx = 0; |
| int progressSize = 20; |
| for (Entry<InterruptionReason, Double> entry : analysisResponsibilityMap.getCollection()) { |
| double ratioValue = entry.getValue() * 100; |
| String symbol = StateMachineReport.progressBar(ratioValue, progressSize); |
| |
| strs[idx][0] = entry.getKey().getTaskId(); |
| strs[idx][1] = String.format("%.2f%% %s", ratioValue, symbol); //$NON-NLS-1$ |
| idx++; |
| } |
| StateMachineReport.R.println_table(header, strs, Arrays.asList(new Integer[] { 1 })); |
| StateMachineReport.R.println(); |
| |
| StateMachineReport.R.dec(); |
| |
| return smva; |
| } |
| |
| @Override |
| public String getVariableType() { |
| return this.getClass() |
| .getSimpleName() |
| .substring(StateMachineVariableTimer.class.getSimpleName().length()); |
| } |
| |
| @Override |
| public String toString() { |
| return String.format("(%s)%s", //$NON-NLS-1$ |
| getVariableType(), |
| super.toString()); |
| } |
| |
| } |
