Add a "Clear Tracing Views" command

[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / viewers / events / TmfEventsCache.java

/*******************************************************************************\r
 * Copyright (c) 2011 Ericsson\r
 *\r
 * All rights reserved. This program and the accompanying materials are\r
 * made available under the terms of the Eclipse Public License v1.0 which\r
 * accompanies this distribution, and is available at\r
 * http://www.eclipse.org/legal/epl-v10.html\r
 *\r
 * Contributors:\r
 *   Patrick Tasse - Initial API and implementation\r
 ******************************************************************************/\r
\r
package org.eclipse.linuxtools.tmf.ui.viewers.events;\r
\r
import java.util.ArrayList;\r
import java.util.Arrays;\r
import java.util.List;\r
\r
import org.eclipse.core.runtime.IProgressMonitor;\r
import org.eclipse.core.runtime.IStatus;\r
import org.eclipse.core.runtime.Status;\r
import org.eclipse.core.runtime.jobs.Job;\r
import org.eclipse.linuxtools.internal.tmf.ui.Activator;\r
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;\r
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;\r
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
\r
/**\r
 * The generic TMF Events table events cache\r
 *\r
 * This can help avoid re-reading the trace when the user scrolls a window,\r
 * for example.\r
 *\r
 * @version 1.0\r
 * @author Patrick Tasse\r
 */\r
public class TmfEventsCache {\r
\r
    /**\r
     * The generic TMF Events table cached event\r
     *\r
     * @version 1.0\r
     * @author Patrick Tasse\r
     */\r
    public static class CachedEvent {\r
        ITmfEvent event;\r
        long rank;\r
\r
        /**\r
         * Constructor for new cached events.\r
         *\r
         * @param iTmfEvent\r
         *            The original trace event\r
         * @param rank\r
         *            The rank of this event in the trace\r
         */\r
        public CachedEvent (ITmfEvent iTmfEvent, long rank) {\r
            this.event = iTmfEvent;\r
            this.rank = rank;\r
        }\r
    }\r
\r
    private final CachedEvent[] fCache;\r
    private int fCacheStartIndex = 0;\r
    private int fCacheEndIndex   = 0;\r
\r
    private ITmfTrace fTrace;\r
    private final TmfEventsTable fTable;\r
    private ITmfFilter fFilter;\r
    private final List<Integer> fFilterIndex = new ArrayList<Integer>(); // contains the event rank at each 'cache size' filtered events\r
\r
    /**\r
     * Constructor for the event cache\r
     *\r
     * @param cacheSize\r
     *            The size of the cache, in number of events\r
     * @param table\r
     *            The Events table this cache will cover\r
     */\r
    public TmfEventsCache(int cacheSize, TmfEventsTable table) {\r
        fCache = new CachedEvent[cacheSize];\r
        fTable = table;\r
    }\r
\r
    /**\r
     * Assign a new trace to this events cache. This clears the current\r
     * contents.\r
     *\r
     * @param trace\r
     *            The trace to assign.\r
     */\r
    public void setTrace(ITmfTrace trace) {\r
        fTrace = trace;\r
        clear();\r
    }\r
\r
    /**\r
     * Clear the current contents of this cache.\r
     */\r
    public synchronized void clear() {\r
        Arrays.fill(fCache, null);\r
        fCacheStartIndex = 0;\r
        fCacheEndIndex = 0;\r
        fFilterIndex.clear();\r
    }\r
\r
    /**\r
     * Apply a filter on this event cache. This clears the current cache\r
     * contents.\r
     *\r
     * @param filter\r
     *            The ITmfFilter to apply.\r
     */\r
    public void applyFilter(ITmfFilter filter) {\r
        fFilter = filter;\r
        clear();\r
    }\r
\r
    /**\r
     * Clear the current filter on this cache. This also clears the current\r
     * cache contents.\r
     */\r
    public void clearFilter() {\r
        fFilter = null;\r
        clear();\r
    }\r
\r
    /**\r
     * Get an event from the cache. This will remove the event from the cache.\r
     *\r
     * FIXME this does not currently remove the event!\r
     *\r
     * @param index\r
     *            The index of this event in the cache\r
     * @return The cached event, or 'null' if there is no event at that index\r
     */\r
    public synchronized CachedEvent getEvent(int index) {\r
        if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {\r
            int i = index - fCacheStartIndex;\r
            return fCache[i];\r
        }\r
        populateCache(index);\r
        return null;\r
    }\r
\r
    /**\r
     * Read an event, but without removing it from the cache.\r
     *\r
     * @param index\r
     *            Index of the event to peek\r
     * @return A reference to the event, or 'null' if there is no event at this\r
     *         index\r
     */\r
    public synchronized CachedEvent peekEvent(int index) {\r
        if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {\r
            int i = index - fCacheStartIndex;\r
            return fCache[i];\r
        }\r
        return null;\r
    }\r
\r
    /**\r
     * Add a trace event to the cache.\r
     *\r
     * @param event\r
     *            The original trace event to be cached\r
     * @param rank\r
     *            The rank of this event in the trace\r
     * @param index\r
     *            The index this event will occupy in the cache\r
     */\r
    public synchronized void storeEvent(ITmfEvent event, long rank, int index) {\r
        if (index == fCacheEndIndex) {\r
            int i = index - fCacheStartIndex;\r
            if (i < fCache.length) {\r
                fCache[i] = new CachedEvent(event.clone(), rank);\r
                fCacheEndIndex++;\r
            }\r
        }\r
        if ((fFilter != null) && ((index % fCache.length) == 0)) {\r
            int i = index / fCache.length;\r
            fFilterIndex.add(i, Integer.valueOf((int) rank));\r
        }\r
    }\r
\r
    /**\r
     * Get the cache index of an event from his rank in the trace. This will\r
     * take in consideration any filter that might be applied.\r
     *\r
     * @param rank\r
     *            The rank of the event in the trace\r
     * @return The position (index) this event should use once cached\r
     */\r
    public int getFilteredEventIndex(final long rank) {\r
        int current;\r
        int startRank;\r
        TmfDataRequest request;\r
        final ITmfFilter filter = fFilter;\r
        synchronized (this) {\r
            int start = 0;\r
            int end = fFilterIndex.size();\r
\r
            if ((fCacheEndIndex - fCacheStartIndex) > 1) {\r
                if (rank < fCache[0].rank) {\r
                    end = (fCacheStartIndex / fCache.length) + 1;\r
                } else if (rank > fCache[fCacheEndIndex - fCacheStartIndex - 1].rank) {\r
                    start = fCacheEndIndex / fCache.length;\r
                } else {\r
                    for (int i = 0; i < (fCacheEndIndex - fCacheStartIndex); i++) {\r
                        if (fCache[i].rank >= rank) {\r
                            return fCacheStartIndex + i;\r
                        }\r
                    }\r
                    return fCacheEndIndex;\r
                }\r
            }\r
\r
            current = (start + end) / 2;\r
            while (current != start) {\r
                if (rank < fFilterIndex.get(current)) {\r
                    end = current;\r
                    current = (start + end) / 2;\r
                } else {\r
                    start = current;\r
                    current = (start + end) / 2;\r
                }\r
            }\r
            startRank = fFilterIndex.size() > 0 ? fFilterIndex.get(current) : 0;\r
        }\r
\r
        final int index = current * fCache.length;\r
\r
        class DataRequest extends TmfDataRequest {\r
            ITmfFilter fFilter;\r
            int fRank;\r
            int fIndex;\r
\r
            DataRequest(Class<? extends ITmfEvent> dataType, ITmfFilter filter, int start, int nbRequested) {\r
                super(dataType, start, nbRequested);\r
                fFilter = filter;\r
                fRank = start;\r
                fIndex = index;\r
            }\r
\r
            @Override\r
            public void handleData(ITmfEvent event) {\r
                super.handleData(event);\r
                if (isCancelled()) {\r
                    return;\r
                }\r
                if (fRank >= rank) {\r
                    cancel();\r
                    return;\r
                }\r
                fRank++;\r
                if (fFilter.matches(event)) {\r
                    fIndex++;\r
                }\r
            }\r
\r
            public int getFilteredIndex() {\r
                return fIndex;\r
            }\r
        }\r
\r
        request = new DataRequest(ITmfEvent.class, filter, startRank, TmfDataRequest.ALL_DATA);\r
        ((ITmfDataProvider) fTrace).sendRequest(request);\r
        try {\r
            request.waitForCompletion();\r
            return ((DataRequest) request).getFilteredIndex();\r
        } catch (InterruptedException e) {\r
            Activator.getDefault().logError("Filter request interrupted!", e); //$NON-NLS-1$\r
        }\r
        return 0;\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Event cache population\r
    // ------------------------------------------------------------------------\r
\r
    // The event fetching job\r
    private Job job;\r
    private synchronized void populateCache(final int index) {\r
\r
        /* Check if the current job will fetch the requested event:\r
         * 1. The job must exist\r
         * 2. It must be running (i.e. not completed)\r
         * 3. The requested index must be within the cache range\r
         *\r
         * If the job meets these conditions, we simply exit.\r
         * Otherwise, we create a new job but we might have to cancel\r
         * an existing job for an obsolete range.\r
         */\r
        if (job != null) {\r
            if (job.getState() != Job.NONE) {\r
                if ((index >= fCacheStartIndex) && (index < (fCacheStartIndex + fCache.length))) {\r
                    return;\r
                }\r
                // The new index is out of the requested range\r
                // Kill the job and start a new one\r
                job.cancel();\r
            }\r
        }\r
\r
        fCacheStartIndex = index;\r
        fCacheEndIndex   = index;\r
\r
        job = new Job("Fetching Events") { //$NON-NLS-1$\r
            private int startIndex = index;\r
            private int skipCount = 0;\r
            @Override\r
            protected IStatus run(final IProgressMonitor monitor) {\r
\r
                int nbRequested;\r
                if (fFilter == null) {\r
                    nbRequested = fCache.length;\r
                } else {\r
                    nbRequested = TmfDataRequest.ALL_DATA;\r
                    int i = index / fCache.length;\r
                    if (i < fFilterIndex.size()) {\r
                        startIndex = fFilterIndex.get(i);\r
                        skipCount = index - (i * fCache.length);\r
                    }\r
                }\r
\r
                TmfDataRequest request = new TmfDataRequest(ITmfEvent.class, startIndex, nbRequested) {\r
                    private int count = 0;\r
                    private long rank = startIndex;\r
                    @Override\r
                    public void handleData(ITmfEvent event) {\r
                        // If the job is canceled, cancel the request so waitForCompletion() will unlock\r
                        if (monitor.isCanceled()) {\r
                            cancel();\r
                            return;\r
                        }\r
                        super.handleData(event);\r
                        if (event != null) {\r
                            if (((fFilter == null) || fFilter.matches(event)) && (skipCount-- <= 0)) {\r
                                synchronized (TmfEventsCache.this) {\r
                                    fCache[count] = new CachedEvent(event.clone(), rank);\r
                                    count++;\r
                                    fCacheEndIndex++;\r
                                }\r
                                if (fFilter != null) {\r
                                    fTable.cacheUpdated(false);\r
                                }\r
                            }\r
                        }\r
                        if (count >= fCache.length) {\r
                            cancel();\r
                        } else if ((fFilter != null) && (count >= (fTable.getTable().getItemCount() - 3))) { // -1 for header row, -2 for top and bottom filter status rows\r
                            cancel();\r
                        }\r
                        rank++;\r
                    }\r
                };\r
\r
                ((ITmfDataProvider) fTrace).sendRequest(request);\r
                try {\r
                    request.waitForCompletion();\r
                } catch (InterruptedException e) {\r
                    Activator.getDefault().logError("Wait for completion interrupted for populateCache ", e); //$NON-NLS-1$\r
                }\r
\r
                fTable.cacheUpdated(true);\r
\r
                // Flag the UI thread that the cache is ready\r
                if (monitor.isCanceled()) {\r
                    return Status.CANCEL_STATUS;\r
                }\r
                return Status.OK_STATUS;\r
            }\r
        };\r
        //job.setSystem(true);\r
        job.setPriority(Job.SHORT);\r
        job.schedule();\r
    }\r
\r
}\r