[deliverable/tracecompass.git] / btf / org.eclipse.tracecompass.btf.core / src / org / eclipse / tracecompass / btf / core / analysis / BtfStateProvider.java

/*******************************************************************************
 * Copyright (c) 2014, 2015 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
 *   Matthew Khouzam - Add the task state system from figure 3 from the spec
 *******************************************************************************/

package org.eclipse.tracecompass.btf.core.analysis;

import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;

import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.btf.core.event.BtfEvent;
import org.eclipse.tracecompass.btf.core.trace.BtfColumnNames;
import org.eclipse.tracecompass.btf.core.trace.BtfTrace;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.statesystem.AbstractTmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;

/**
 * State provider for the default BTF analysis.
 *
 * The generated attribute tree will look like this:
 *
 * <pre>
 * {root}
 *   +- Cores
 *   |   +- Core 1            (not running/Name of the running Task)
 *   |   +- Core 2            (not running/Name of the running Task)
 *   |
 *   +- Tasks
 *       +- Task A
 *       |   +- Core 1             (not running/running/suspended)
 *       |   |    +- Runnable A1   (not running/running/suspended)
 *       |   |    +- Runnable A2   (not running/running/suspended)
 *       |   +- Core 2
 *       |   |    +- Runnable A1
 *       |   |    +- Runnable A2
 *       |   +- ActiveCore
 *       |
 *       +- Task B
 *           +- Core 1
 *           |    +- Runnable B1
 *           |    +- Runnable B2
 *           +- Core 2
 *           |    +- Runnable B1
 *           |    +- Runnable B2
 *           +- ActiveCore
 * </pre>
 *
 * @author Alexandre Montplaisir
 */
public class BtfStateProvider extends AbstractTmfStateProvider {

    private static final int PROVIDER_VERSION = 3;

    private static class TmfNamedStateValue {
        private final String fName;
        private final @NonNull TmfStateValue fValue;

        public TmfNamedStateValue(@NonNull TmfStateValue value, String name) {
            fValue = value;
            fName = name;
        }

        public @NonNull TmfStateValue getValue() {
            return fValue;
        }

        @Override
        public String toString() {
            return fName;
        }
    }

    private static final TmfNamedStateValue STATE_CORE_IDLE = new TmfNamedStateValue(TmfStateValue.newValueInt(0), "Idle"); //$NON-NLS-1$

    private static final TmfNamedStateValue STATE_NOT_RUNNING = new TmfNamedStateValue(TmfStateValue.nullValue(), "Not Running"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_RUNNING = new TmfNamedStateValue(TmfStateValue.newValueInt((1)), "RUNNING"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_SUSPENDED = new TmfNamedStateValue(TmfStateValue.newValueInt((2)), "SUSPENDED"); //$NON-NLS-1$

    private static final TmfNamedStateValue STATE_TASK_ACTIVE = new TmfNamedStateValue(TmfStateValue.newValueInt((4)), "Active"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_TASK_READY = new TmfNamedStateValue(TmfStateValue.newValueInt((5)), "Ready"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_TASK_RUNNING = new TmfNamedStateValue(TmfStateValue.newValueInt((6)), "Task Running"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_TASK_WAITING = new TmfNamedStateValue(TmfStateValue.newValueInt((7)), "Waiting"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_TASK_PARKING = new TmfNamedStateValue(TmfStateValue.newValueInt((8)), "Parking"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_TASK_POLLING = new TmfNamedStateValue(TmfStateValue.newValueInt((9)), "Polling"); //$NON-NLS-1$
    private static final TmfNamedStateValue STATE_TASK_TERMINATED = new TmfNamedStateValue(TmfStateValue.nullValue(), "Terminated"); //$NON-NLS-1$

    private static final String ENTITY_CORE = "Core"; //$NON-NLS-1$
    private static final String ENTITY_TASK = "TASK"; //$NON-NLS-1$
    // private static final String ENTITY_RUNNABLE = "RUNNABLE";

    private static final String ATTRIBUTE_TASKS = "Tasks"; //$NON-NLS-1$
    private static final String ATTRIBUTE_CORES = "Cores"; //$NON-NLS-1$
    private static final String ATTRIBUTE_ACTIVE_CORE = "ActiveCore"; //$NON-NLS-1$

    /**
     * Constructor
     *
     * @param trace
     *            The trace for which we will be building this state system
     */
    public BtfStateProvider(BtfTrace trace) {
        super(trace, "Btf State Provider"); //$NON-NLS-1$
    }

    @Override
    public BtfTrace getTrace() {
        return (BtfTrace) super.getTrace();
    }

    @Override
    public int getVersion() {
        return PROVIDER_VERSION;
    }

    @Override
    public ITmfStateProvider getNewInstance() {
        return new BtfStateProvider(getTrace());
    }

    @Override
    protected void eventHandle(ITmfEvent ev) {
        if (!(ev instanceof BtfEvent)) {
            return;
        }

        BtfEvent event = (BtfEvent) ev;
        final ITmfStateSystemBuilder ssb = checkNotNull(getStateSystemBuilder());

        final long ts = event.getTimestamp().getValue();
        final String eventType = (String) event.getContent().getField(BtfColumnNames.EVENT.toString()).getValue();
        final String source = event.getSource();
        final String target = event.getTarget();
        String task;
        int quark;
        try {
            switch (eventType) {

            case "activate": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_ACTIVE);
                break;

            case "start": //$NON-NLS-1$
            case "resume": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_RUNNING);

                if (source.startsWith(ENTITY_CORE)) {
                    String core = source;
                    task = target;

                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
                    ssb.modifyAttribute(ts, STATE_RUNNING.getValue(), quark);

                    /* Mark this task as active in the ActiveCore attribute */
                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
                    ITmfStateValue value = TmfStateValue.newValueString(core);
                    ssb.modifyAttribute(ts, value, quark);

                    /* Mark this task as active in the Cores/* attribute */
                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_CORES, core);
                    /* Until the view can display the string */
                    value = STATE_RUNNING.getValue();
                    ssb.modifyAttribute(ts, value, quark);

                } else if (source.startsWith(ENTITY_TASK)) {
                    task = source;
                    String runnable = target;
                    String core = getCoreOfTask(ssb, task);

                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core, runnable);
                    ssb.modifyAttribute(ts, STATE_RUNNING.getValue(), quark);
                }
                break;

            case "suspend": //$NON-NLS-1$
                /* "suspend" events only happen on Tasks */
                if (source.startsWith(ENTITY_TASK)) {
                    task = source;
                    String runnable = target;
                    String core = getCoreOfTask(ssb, task);

                    /* We'll update both the Core and Runnable attributes */
                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
                    ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark);
                    quark = ssb.getQuarkRelativeAndAdd(quark, runnable);
                    ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark);
                }
                break;

            case "terminate": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_TERMINATED);

                if (source.startsWith(ENTITY_CORE)) {
                    String core = source;
                    task = target;

                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
                    ssb.modifyAttribute(ts, STATE_NOT_RUNNING.getValue(), quark);

                    /* Remove our "active task on core" bookmark */
                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
                    ITmfStateValue value = TmfStateValue.nullValue();
                    ssb.modifyAttribute(ts, value, quark);

                    /* Mark the Cores/* attribute as not running */
                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_CORES, core);
                    ssb.modifyAttribute(ts, STATE_CORE_IDLE.getValue(), quark);

                } else if (source.startsWith(ENTITY_TASK)) {
                    task = source;
                    String runnable = target;
                    String core = getCoreOfTask(ssb, task);

                    quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core, runnable);
                    ssb.modifyAttribute(ts, STATE_NOT_RUNNING.getValue(), quark);
                }
                break;

            case "preempt": //$NON-NLS-1$
            case "release": //$NON-NLS-1$
            case "release_parking": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_READY);
                break;
            case "wait": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_WAITING);
                break;
            case "park": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_PARKING);
                break;
            case "poll": //$NON-NLS-1$
                //$FALL-THROUGH$
            case "poll_parking": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_POLLING);
                break;
            case "run": //$NON-NLS-1$
                updateTaskStateSystem(ssb, ts, event, STATE_TASK_RUNNING);
                break;
            default:
                break;

            }
        } catch (AttributeNotFoundException e) {
            throw new IllegalStateException(e);
        }
    }

    private static void updateTaskStateSystem(
            final ITmfStateSystemBuilder ssb,
            final long ts, BtfEvent event,
            TmfNamedStateValue stateValue)
            throws AttributeNotFoundException {
        String name = event.getName();
        if (name.equals("Task")) { //$NON-NLS-1$
            String task = event.getTarget();
            int quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task);
            ssb.modifyAttribute(ts, stateValue.getValue(), quark);
        }
    }

    private static String getCoreOfTask(ITmfStateSystemBuilder ssb, String task) {
        try {
            int quark = ssb.getQuarkAbsolute(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
            ITmfStateValue value = ssb.queryOngoingState(quark);
            return value.unboxStr();
        } catch (AttributeNotFoundException e) {
            throw new IllegalStateException(e);
        }
    }
}
Commit	Line	Data
ff71e543	1	/*******************************************************************************
ed902a2b	2	* Copyright (c) 2014, 2015 Ericsson
ff71e543 MK	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	* Alexandre Montplaisir - Initial API and implementation
	11	* Matthew Khouzam - Add the task state system from figure 3 from the spec
	12	*******************************************************************************/
	13
7ce90559	14	package org.eclipse.tracecompass.btf.core.analysis;
ff71e543	15
d0c7e4ba AM	16	import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
d0c7e4ba AM	17
30cdc5e5	18	import org.eclipse.jdt.annotation.NonNull;
7ce90559 AM	19	import org.eclipse.tracecompass.btf.core.event.BtfEvent;
	20	import org.eclipse.tracecompass.btf.core.trace.BtfColumnNames;
	21	import org.eclipse.tracecompass.btf.core.trace.BtfTrace;
e894a508 AM	22	import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
	23	import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
	24	import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
	25	import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
2bdf0193	26	import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
2bdf0193 AM	27	import org.eclipse.tracecompass.tmf.core.statesystem.AbstractTmfStateProvider;
2bdf0193 AM	28	import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
ff71e543 MK	29
	30	/**
	31	* State provider for the default BTF analysis.
	32	*
	33	* The generated attribute tree will look like this:
	34	*
	35	* <pre>
	36	* {root}
	37	* +- Cores
	38	* \| +- Core 1 (not running/Name of the running Task)
	39	* \| +- Core 2 (not running/Name of the running Task)
	40	* \|
	41	* +- Tasks
	42	* +- Task A
	43	* \| +- Core 1 (not running/running/suspended)
	44	* \| \| +- Runnable A1 (not running/running/suspended)
	45	* \| \| +- Runnable A2 (not running/running/suspended)
	46	* \| +- Core 2
	47	* \| \| +- Runnable A1
	48	* \| \| +- Runnable A2
	49	* \| +- ActiveCore
	50	* \|
	51	* +- Task B
	52	* +- Core 1
	53	* \| +- Runnable B1
	54	* \| +- Runnable B2
	55	* +- Core 2
	56	* \| +- Runnable B1
	57	* \| +- Runnable B2
	58	* +- ActiveCore
	59	* </pre>
	60	*
	61	* @author Alexandre Montplaisir
	62	*/
	63	public class BtfStateProvider extends AbstractTmfStateProvider {
	64
	65	private static final int PROVIDER_VERSION = 3;
	66
	67	private static class TmfNamedStateValue {
	68	private final String fName;
30cdc5e5	69	private final @NonNull TmfStateValue fValue;
ff71e543	70
30cdc5e5	71	public TmfNamedStateValue(@NonNull TmfStateValue value, String name) {
ff71e543 MK	72	fValue = value;
	73	fName = name;
	74	}
	75
30cdc5e5	76	public @NonNull TmfStateValue getValue() {
ff71e543 MK	77	return fValue;
	78	}
	79
	80	@Override
	81	public String toString() {
	82	return fName;
	83	}
	84	}
	85
	86	private static final TmfNamedStateValue STATE_CORE_IDLE = new TmfNamedStateValue(TmfStateValue.newValueInt(0), "Idle"); //$NON-NLS-1$
	87
	88	private static final TmfNamedStateValue STATE_NOT_RUNNING = new TmfNamedStateValue(TmfStateValue.nullValue(), "Not Running"); //$NON-NLS-1$
	89	private static final TmfNamedStateValue STATE_RUNNING = new TmfNamedStateValue(TmfStateValue.newValueInt((1)), "RUNNING"); //$NON-NLS-1$
	90	private static final TmfNamedStateValue STATE_SUSPENDED = new TmfNamedStateValue(TmfStateValue.newValueInt((2)), "SUSPENDED"); //$NON-NLS-1$
	91
	92	private static final TmfNamedStateValue STATE_TASK_ACTIVE = new TmfNamedStateValue(TmfStateValue.newValueInt((4)), "Active"); //$NON-NLS-1$
	93	private static final TmfNamedStateValue STATE_TASK_READY = new TmfNamedStateValue(TmfStateValue.newValueInt((5)), "Ready"); //$NON-NLS-1$
	94	private static final TmfNamedStateValue STATE_TASK_RUNNING = new TmfNamedStateValue(TmfStateValue.newValueInt((6)), "Task Running"); //$NON-NLS-1$
	95	private static final TmfNamedStateValue STATE_TASK_WAITING = new TmfNamedStateValue(TmfStateValue.newValueInt((7)), "Waiting"); //$NON-NLS-1$
	96	private static final TmfNamedStateValue STATE_TASK_PARKING = new TmfNamedStateValue(TmfStateValue.newValueInt((8)), "Parking"); //$NON-NLS-1$
	97	private static final TmfNamedStateValue STATE_TASK_POLLING = new TmfNamedStateValue(TmfStateValue.newValueInt((9)), "Polling"); //$NON-NLS-1$
	98	private static final TmfNamedStateValue STATE_TASK_TERMINATED = new TmfNamedStateValue(TmfStateValue.nullValue(), "Terminated"); //$NON-NLS-1$
	99
	100	private static final String ENTITY_CORE = "Core"; //$NON-NLS-1$
	101	private static final String ENTITY_TASK = "TASK"; //$NON-NLS-1$
	102	// private static final String ENTITY_RUNNABLE = "RUNNABLE";
	103
	104	private static final String ATTRIBUTE_TASKS = "Tasks"; //$NON-NLS-1$
	105	private static final String ATTRIBUTE_CORES = "Cores"; //$NON-NLS-1$
	106	private static final String ATTRIBUTE_ACTIVE_CORE = "ActiveCore"; //$NON-NLS-1$
	107
	108	/**
	109	* Constructor
	110	*
	111	* @param trace
	112	* The trace for which we will be building this state system
	113	*/
	114	public BtfStateProvider(BtfTrace trace) {
e2bcc8a5	115	super(trace, "Btf State Provider"); //$NON-NLS-1$
ff71e543 MK	116	}
	117
	118	@Override
	119	public BtfTrace getTrace() {
	120	return (BtfTrace) super.getTrace();
	121	}
	122
	123	@Override
	124	public int getVersion() {
	125	return PROVIDER_VERSION;
	126	}
	127
	128	@Override
	129	public ITmfStateProvider getNewInstance() {
	130	return new BtfStateProvider(getTrace());
	131	}
	132
	133	@Override
	134	protected void eventHandle(ITmfEvent ev) {
e2bcc8a5 AM	135	if (!(ev instanceof BtfEvent)) {
	136	return;
	137	}
	138
ff71e543	139	BtfEvent event = (BtfEvent) ev;
d0c7e4ba	140	final ITmfStateSystemBuilder ssb = checkNotNull(getStateSystemBuilder());
ff71e543 MK	141
	142	final long ts = event.getTimestamp().getValue();
	143	final String eventType = (String) event.getContent().getField(BtfColumnNames.EVENT.toString()).getValue();
	144	final String source = event.getSource();
df854ddb	145	final String target = event.getTarget();
ff71e543 MK	146	String task;
	147	int quark;
	148	try {
	149	switch (eventType) {
	150
	151	case "activate": //$NON-NLS-1$
	152	updateTaskStateSystem(ssb, ts, event, STATE_TASK_ACTIVE);
	153	break;
	154
	155	case "start": //$NON-NLS-1$
	156	case "resume": //$NON-NLS-1$
	157	updateTaskStateSystem(ssb, ts, event, STATE_TASK_RUNNING);
	158
	159	if (source.startsWith(ENTITY_CORE)) {
	160	String core = source;
	161	task = target;
	162
	163	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
	164	ssb.modifyAttribute(ts, STATE_RUNNING.getValue(), quark);
	165
	166	/* Mark this task as active in the ActiveCore attribute */
	167	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
	168	ITmfStateValue value = TmfStateValue.newValueString(core);
	169	ssb.modifyAttribute(ts, value, quark);
	170
	171	/* Mark this task as active in the Cores/* attribute */
	172	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_CORES, core);
	173	/* Until the view can display the string */
	174	value = STATE_RUNNING.getValue();
	175	ssb.modifyAttribute(ts, value, quark);
	176
	177	} else if (source.startsWith(ENTITY_TASK)) {
	178	task = source;
	179	String runnable = target;
	180	String core = getCoreOfTask(ssb, task);
	181
	182	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core, runnable);
	183	ssb.modifyAttribute(ts, STATE_RUNNING.getValue(), quark);
	184	}
	185	break;
	186
	187	case "suspend": //$NON-NLS-1$
	188	/* "suspend" events only happen on Tasks */
	189	if (source.startsWith(ENTITY_TASK)) {
	190	task = source;
	191	String runnable = target;
	192	String core = getCoreOfTask(ssb, task);
	193
	194	/* We'll update both the Core and Runnable attributes */
	195	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
	196	ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark);
	197	quark = ssb.getQuarkRelativeAndAdd(quark, runnable);
d0c7e4ba	198	ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark);
ff71e543 MK	199	}
	200	break;
	201
	202	case "terminate": //$NON-NLS-1$
	203	updateTaskStateSystem(ssb, ts, event, STATE_TASK_TERMINATED);
	204
	205	if (source.startsWith(ENTITY_CORE)) {
	206	String core = source;
	207	task = target;
	208
	209	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
	210	ssb.modifyAttribute(ts, STATE_NOT_RUNNING.getValue(), quark);
	211
	212	/* Remove our "active task on core" bookmark */
	213	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
	214	ITmfStateValue value = TmfStateValue.nullValue();
	215	ssb.modifyAttribute(ts, value, quark);
	216
	217	/* Mark the Cores/* attribute as not running */
	218	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_CORES, core);
	219	ssb.modifyAttribute(ts, STATE_CORE_IDLE.getValue(), quark);
	220
	221	} else if (source.startsWith(ENTITY_TASK)) {
	222	task = source;
	223	String runnable = target;
	224	String core = getCoreOfTask(ssb, task);
	225
	226	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core, runnable);
	227	ssb.modifyAttribute(ts, STATE_NOT_RUNNING.getValue(), quark);
	228	}
	229	break;
	230
	231	case "preempt": //$NON-NLS-1$
	232	case "release": //$NON-NLS-1$
	233	case "release_parking": //$NON-NLS-1$
	234	updateTaskStateSystem(ssb, ts, event, STATE_TASK_READY);
	235	break;
	236	case "wait": //$NON-NLS-1$
	237	updateTaskStateSystem(ssb, ts, event, STATE_TASK_WAITING);
	238	break;
	239	case "park": //$NON-NLS-1$
	240	updateTaskStateSystem(ssb, ts, event, STATE_TASK_PARKING);
	241	break;
	242	case "poll": //$NON-NLS-1$
	243	//$FALL-THROUGH$
	244	case "poll_parking": //$NON-NLS-1$
	245	updateTaskStateSystem(ssb, ts, event, STATE_TASK_POLLING);
	246	break;
	247	case "run": //$NON-NLS-1$
	248	updateTaskStateSystem(ssb, ts, event, STATE_TASK_RUNNING);
	249	break;
	250	default:
	251	break;
	252
	253	}
	254	} catch (AttributeNotFoundException e) {
	255	throw new IllegalStateException(e);
	256	}
	257	}
	258
	259	private static void updateTaskStateSystem(
	260	final ITmfStateSystemBuilder ssb,
	261	final long ts, BtfEvent event,
	262	TmfNamedStateValue stateValue)
263	throws AttributeNotFoundException {
578716e6	264	String name = event.getName();
ff71e543	265	if (name.equals("Task")) { //$NON-NLS-1$
df854ddb	266	String task = event.getTarget();
ff71e543 MK	267	int quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task);
	268	ssb.modifyAttribute(ts, stateValue.getValue(), quark);
	269	}
	270	}
	271
	272	private static String getCoreOfTask(ITmfStateSystemBuilder ssb, String task) {
	273	try {
	274	int quark = ssb.getQuarkAbsolute(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
	275	ITmfStateValue value = ssb.queryOngoingState(quark);
	276	return value.unboxStr();
	277	} catch (AttributeNotFoundException e) {
	278	throw new IllegalStateException(e);
	279	}
	280	}
	281	}