org.eclipse.tracecompass.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/backends/partial/PartialStateSystem.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2014 Ericsson
   3  * All rights reserved. This program and the accompanying materials are
   4  * made available under the terms of the Eclipse Public License v1.0 which
   5  * accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *   Alexandre Montplaisir - Initial API and implementation
  10  *******************************************************************************/
  11
  12 package org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.partial;
  13
  14 import java.util.List;
  15 import java.util.concurrent.CountDownLatch;
  16 import java.util.concurrent.locks.Lock;
  17 import java.util.concurrent.locks.ReentrantLock;
  18
  19 import org.eclipse.linuxtools.internal.statesystem.core.AttributeTree;
  20 import org.eclipse.linuxtools.internal.statesystem.core.StateSystem;
  21 import org.eclipse.linuxtools.statesystem.core.ITmfStateSystem;
  22 import org.eclipse.linuxtools.statesystem.core.backend.NullBackend;
  23 import org.eclipse.linuxtools.statesystem.core.exceptions.AttributeNotFoundException;
  24 import org.eclipse.linuxtools.statesystem.core.interval.ITmfStateInterval;
  25
  26 /**
  27  * State system interface-like extension to use with partial state histories.
  28  *
  29  * It mainly exposes the {@link #replaceOngoingState} method, which allows
  30  * seeking the state system to a different point by updating its "ongoing" state
  31  * values.
  32  *
  33  * @author Alexandre Montplaisir
  34  */
  35 @SuppressWarnings("restriction") /* We're using AttributeTree directly */
  36 public class PartialStateSystem extends StateSystem {
  37
  38     private static final String ERR_MSG = "Partial state system should not modify the attribute tree!"; //$NON-NLS-1$
  39
  40     private final CountDownLatch ssAssignedLatch = new CountDownLatch(1);
  41     private final Lock queryLock = new ReentrantLock();
  42
  43     /**
  44      * Reference to the real upstream state system. This is used so we can read
  45      * its attribute tree.
  46      */
  47     private StateSystem realStateSystem = null;
  48
  49     /**
  50      * Constructor
  51      */
  52     public PartialStateSystem() {
  53         /*
  54          * We use a Null back end here : we only use this state system for its
  55          * "ongoing" values, so no need to save the changes that are inserted.
  56          */
  57         super("partial", new NullBackend()); //$NON-NLS-1$
  58     }
  59
  60     /**
  61      * Assign the upstream state system to this one.
  62      *
  63      * @param ss
  64      *            The real state system
  65      */
  66     public void assignUpstream(StateSystem ss) {
  67         realStateSystem = ss;
  68         ssAssignedLatch.countDown();
  69     }
  70
  71     ITmfStateSystem getUpstreamSS() {
  72         return realStateSystem;
  73     }
  74
  75     // ------------------------------------------------------------------------
  76     // Publicized non-API methods
  77     // ------------------------------------------------------------------------
  78
  79     @Override
  80     public void replaceOngoingState(List<ITmfStateInterval> ongoingIntervals) {
  81         super.replaceOngoingState(ongoingIntervals);
  82     }
  83
  84     @Override
  85     public synchronized void dispose() {
  86         super.dispose();
  87     }
  88
  89     // ------------------------------------------------------------------------
  90     // Methods regarding the query lock
  91     // ------------------------------------------------------------------------
  92
  93     /**
  94      * Take this inner state system's lock before doing a query.
  95      *
  96      * When doing queries, you should take the lock, then run
  97      * {@link #replaceOngoingState}, then send events to its state provider
  98      * input to cause state changes, and then call {@link #queryOngoingState} to
  99      * get the states at the new "current time".
 100      *
 101      * Only after all that it would be safe to release the lock.
 102      */
 103     public void takeQueryLock() {
 104         try {
 105             queryLock.lockInterruptibly();
 106         } catch (InterruptedException e) {
 107             e.printStackTrace();
 108         }
 109     }
 110
 111     /**
 112      * Release the query lock, when you are done with your query.
 113      */
 114     public void releaseQueryLock() {
 115         queryLock.unlock();
 116     }
 117
 118     @Override
 119     public AttributeTree getAttributeTree() {
 120         waitUntilReady();
 121         return realStateSystem.getAttributeTree();
 122     }
 123
 124     /*
 125      * Override these methods to make sure we don't try to overwrite the
 126      * "real" upstream attribute tree.
 127      */
 128
 129     @Override
 130     public void addEmptyAttribute() {
 131         throw new RuntimeException(ERR_MSG);
 132     }
 133
 134     @Override
 135     public int getQuarkAbsoluteAndAdd(String... attribute) {
 136         waitUntilReady();
 137         try {
 138             return realStateSystem.getQuarkAbsolute(attribute);
 139         } catch (AttributeNotFoundException e) {
 140             throw new RuntimeException(ERR_MSG);
 141         }
 142     }
 143
 144     @Override
 145     public int getQuarkRelativeAndAdd(int startingNodeQuark, String... subPath) {
 146         waitUntilReady();
 147         try {
 148             return realStateSystem.getQuarkRelative(startingNodeQuark, subPath);
 149         } catch (AttributeNotFoundException e) {
 150             throw new RuntimeException(ERR_MSG);
 151         }
 152     }
 153
 154     private void waitUntilReady() {
 155         try {
 156             ssAssignedLatch.await();
 157         } catch (InterruptedException e) {
 158             e.printStackTrace();
 159         }
 160     }
 161
 162 }