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

/*******************************************************************************
 * Copyright (c) 2014 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.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.event.TmfEvent;
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 TmfStateValue fValue;

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

        public 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, TmfEvent.class, "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) {
        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.getReference();
        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.getType().getName();
        if (name.equals("Task")) { //$NON-NLS-1$
            String task = event.getReference();
            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 MK	1	/*******************************************************************************
	2	* Copyright (c) 2014 Ericsson
	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
7ce90559 AM	18	import org.eclipse.tracecompass.btf.core.event.BtfEvent;
	19	import org.eclipse.tracecompass.btf.core.trace.BtfColumnNames;
	20	import org.eclipse.tracecompass.btf.core.trace.BtfTrace;
e894a508 AM	21	import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
	22	import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
	23	import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
	24	import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
2bdf0193 AM	25	import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
	26	import org.eclipse.tracecompass.tmf.core.event.TmfEvent;
	27	import org.eclipse.tracecompass.tmf.core.statesystem.AbstractTmfStateProvider;
	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;
	69	private final TmfStateValue fValue;
	70
	71	public TmfNamedStateValue(TmfStateValue value, String name) {
	72	fValue = value;
	73	fName = name;
	74	}
	75
	76	public TmfStateValue getValue() {
	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) {
115	super(trace, TmfEvent.class, "Btf State Provider"); //$NON-NLS-1$
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) {
135	BtfEvent event = (BtfEvent) ev;
d0c7e4ba	136	final ITmfStateSystemBuilder ssb = checkNotNull(getStateSystemBuilder());
ff71e543 MK	137
	138	final long ts = event.getTimestamp().getValue();
	139	final String eventType = (String) event.getContent().getField(BtfColumnNames.EVENT.toString()).getValue();
	140	final String source = event.getSource();
	141	final String target = event.getReference();
	142	String task;
	143	int quark;
	144	try {
	145	switch (eventType) {
	146
	147	case "activate": //$NON-NLS-1$
	148	updateTaskStateSystem(ssb, ts, event, STATE_TASK_ACTIVE);
	149	break;
	150
	151	case "start": //$NON-NLS-1$
	152	case "resume": //$NON-NLS-1$
	153	updateTaskStateSystem(ssb, ts, event, STATE_TASK_RUNNING);
	154
	155	if (source.startsWith(ENTITY_CORE)) {
	156	String core = source;
	157	task = target;
	158
	159	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
	160	ssb.modifyAttribute(ts, STATE_RUNNING.getValue(), quark);
	161
	162	/* Mark this task as active in the ActiveCore attribute */
	163	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
	164	ITmfStateValue value = TmfStateValue.newValueString(core);
	165	ssb.modifyAttribute(ts, value, quark);
	166
	167	/* Mark this task as active in the Cores/* attribute */
	168	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_CORES, core);
	169	/* Until the view can display the string */
	170	value = STATE_RUNNING.getValue();
	171	ssb.modifyAttribute(ts, value, quark);
	172
	173	} else if (source.startsWith(ENTITY_TASK)) {
	174	task = source;
	175	String runnable = target;
	176	String core = getCoreOfTask(ssb, task);
	177
	178	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core, runnable);
	179	ssb.modifyAttribute(ts, STATE_RUNNING.getValue(), quark);
	180	}
	181	break;
	182
	183	case "suspend": //$NON-NLS-1$
	184	/* "suspend" events only happen on Tasks */
	185	if (source.startsWith(ENTITY_TASK)) {
	186	task = source;
	187	String runnable = target;
	188	String core = getCoreOfTask(ssb, task);
	189
	190	/* We'll update both the Core and Runnable attributes */
	191	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
	192	ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark);
	193	quark = ssb.getQuarkRelativeAndAdd(quark, runnable);
d0c7e4ba	194	ssb.modifyAttribute(ts, STATE_SUSPENDED.getValue(), quark);
ff71e543 MK	195	}
	196	break;
	197
	198	case "terminate": //$NON-NLS-1$
	199	updateTaskStateSystem(ssb, ts, event, STATE_TASK_TERMINATED);
	200
	201	if (source.startsWith(ENTITY_CORE)) {
	202	String core = source;
	203	task = target;
	204
	205	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core);
	206	ssb.modifyAttribute(ts, STATE_NOT_RUNNING.getValue(), quark);
	207
	208	/* Remove our "active task on core" bookmark */
	209	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
	210	ITmfStateValue value = TmfStateValue.nullValue();
	211	ssb.modifyAttribute(ts, value, quark);
	212
	213	/* Mark the Cores/* attribute as not running */
	214	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_CORES, core);
	215	ssb.modifyAttribute(ts, STATE_CORE_IDLE.getValue(), quark);
	216
	217	} else if (source.startsWith(ENTITY_TASK)) {
	218	task = source;
	219	String runnable = target;
	220	String core = getCoreOfTask(ssb, task);
	221
	222	quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task, core, runnable);
	223	ssb.modifyAttribute(ts, STATE_NOT_RUNNING.getValue(), quark);
	224	}
	225	break;
	226
	227	case "preempt": //$NON-NLS-1$
	228	case "release": //$NON-NLS-1$
	229	case "release_parking": //$NON-NLS-1$
	230	updateTaskStateSystem(ssb, ts, event, STATE_TASK_READY);
	231	break;
	232	case "wait": //$NON-NLS-1$
	233	updateTaskStateSystem(ssb, ts, event, STATE_TASK_WAITING);
	234	break;
	235	case "park": //$NON-NLS-1$
	236	updateTaskStateSystem(ssb, ts, event, STATE_TASK_PARKING);
	237	break;
	238	case "poll": //$NON-NLS-1$
	239	//$FALL-THROUGH$
	240	case "poll_parking": //$NON-NLS-1$
	241	updateTaskStateSystem(ssb, ts, event, STATE_TASK_POLLING);
	242	break;
	243	case "run": //$NON-NLS-1$
	244	updateTaskStateSystem(ssb, ts, event, STATE_TASK_RUNNING);
	245	break;
	246	default:
	247	break;
	248
	249	}
	250	} catch (AttributeNotFoundException e) {
	251	throw new IllegalStateException(e);
	252	}
	253	}
	254
	255	private static void updateTaskStateSystem(
	256	final ITmfStateSystemBuilder ssb,
	257	final long ts, BtfEvent event,
	258	TmfNamedStateValue stateValue)
259	throws AttributeNotFoundException {
260	String name = event.getType().getName();
261	if (name.equals("Task")) { //$NON-NLS-1$
262	String task = event.getReference();
263	int quark = ssb.getQuarkAbsoluteAndAdd(ATTRIBUTE_TASKS, task);
264	ssb.modifyAttribute(ts, stateValue.getValue(), quark);
265	}
266	}
267
268	private static String getCoreOfTask(ITmfStateSystemBuilder ssb, String task) {
269	try {
270	int quark = ssb.getQuarkAbsolute(ATTRIBUTE_TASKS, task, ATTRIBUTE_ACTIVE_CORE);
271	ITmfStateValue value = ssb.queryOngoingState(quark);
272	return value.unboxStr();
273	} catch (AttributeNotFoundException e) {
274	throw new IllegalStateException(e);
275	}
276	}
277	}