Examples of com.sun.sgs.app.DataManager

com.sun.sgs.app.DataManager
Provides facilities for managing access to shared, persistent objects. Managed objects are objects that implement the {@link ManagedObject} and{@link Serializable} interfaces. Each managed object is stored separatelyalong with all of the serializable, non-managed objects it refers to. If a managed object refers to another managed object, it must do so through an instance of {@link ManagedReference}, created by the {@link #createReference createReference} method. Attempting to store a reference to a managedobject using a standard reference rather than an instance of ManagedReference will typically result in an {@link ObjectIOException} being thrown when the current transaction commits.
Managed objects that are bound to names, and any managed objects they refer to directly or indirectly, are stored by the DataManager. It is up to the application to determine when managed objects are no longer needed and to remove them explicitly from the DataManager using the {@link #removeObject removeObject} method.
Managed objects are in one of the following states with respect to the data manager:
- Transient - A managed object that has been created directly by the application and has not been supplied in a call to {@link #setBinding setBinding}, {@code createReference}, or {@link #getObjectId getObjectId}. Transient objects are not known to the data manager and are not stored persistently.
  Passing a transient object to {@code setBinding}, {@code createReference}, or {@code getObjectId} creates a new entry for theobject in the data manager. Calling {@code removeObject} or {@link #markForUpdate markForUpdate} on a transient object does not change thestate of the object. If a transient object implements {@link ManagedObjectRemoval}, though, then calling {@code removeObject} willcause its {@link ManagedObjectRemoval#removingObject removingObject}method to be called.
- Persistent - A managed object that has been stored in the data manager by calling {@code setBinding}, {@code createReference}, or {@code getObjectId} in the current transaction, orelse retrieved from the data manager by calling {@link #getBinding getBinding}, {@link #getBindingForUpdate getBindingForUpdate}, {@link ManagedReference#get ManagedReference.get}, or {@link ManagedReference#getForUpdate ManagedReference.getForUpdate}.
  Passing a persistent object to {@code setBinding}, {@code createReference}, {@code markForUpdate}, or {@code getObjectId} does notcreate a new entry for that object in the data manager, but rather reuses the existing one. Calling {@code removeObject} on a persistentobject removes it from the data manager, meaning it will no longer be stored persistently, and changes its state to removed. Note that a managed object made persistent in the current transaction is automatically marked for update, so there is no need to call {@code markForUpdate} for such objects, in particular in theirconstructors.
- Removed - A managed object that has been removed from the data manager by calling {@code removeObject}. Removed objects are no longer stored persistently, although the data manager makes an effort to track which managed objects have been removed.
  Only persistent managed objects can become removed; calling {@code removeObject} on a transient managed object leaves it as a transientobject. Passing a removed managed object to {@code setBinding}, {@code removeObject}, {@code markForUpdate}, {@code createReference}, or {@code getObjectId}, as well as calling {@code ManagedReference.get} or {@code ManagedReference.getForUpdate} on a reference to the removed object,will cause a {@link ObjectNotFoundException} to be thrown, if the systemhas tracked the object's removed state.
- Stale - A managed object that was persistent or removed in another, completed transaction. Stale objects are objects that have become detached from the data manager, and should not be visible to applications that avoid using static fields, but may be encountered under some circumstances. The data manager implementation may or may not track stale objects. If stale objects are not tracked, they will be considered transient.
  Passing a stale object to {@code setBinding}, {@code removeObject}, {@code markForUpdate}, {@code createReference}, or {@code getObjectId}, as well as calling {@code ManagedReference.get} or {@code ManagedReference.getForUpdate} on a reference to the stale object, willcause a {@link TransactionNotActiveException} to be thrown, if thesystem has tracked the object's stale state.
Because storing a managed object in a name binding or creating a managed reference to it causes the object to be stored in data manager, applications should insure that they remove such objects if they end up not referring to them persistently. The {@code removeObject} method does not throwexceptions when called on a transient object, so applications should call {@code removeObject} whenever there is an object that may have becomepersistent and they are sure is no longer used.
Some implementations may need to be notified when managed objects and the objects they refer to are modified, while other implementations may be configurable to detect these modifications automatically. Applications are always permitted to mark objects that have been modified, and doing so may produce performance improvements regardless of whether modifications are detected automatically. @see AppContext#getDataManager @see ManagedObject @see ManagedReference @see Serializable

     * Get the list of all root cells in the world, creating it if it doesn't
     * exist
     * @return a set of root cells
     */
    public Set<CellID> getRootCells() {
        DataManager dm = AppContext.getDataManager();
        Set<CellID> out;
        try {
            out = (Set<CellID>) dm.getBinding(ROOTCELLS_BINDING_NAME);
        } catch (NameNotBoundException nnbe) {
            out = new ScalableHashSet<CellID>();
            dm.setBinding(ROOTCELLS_BINDING_NAME, out);
        }


        return out;
    }

View Full Code Here

    /**
     * Returns a unique cell id and registers the cell with the system
     * @return
     */
    CellID createCellID(CellMO cell) {
        DataManager dm = AppContext.getDataManager();
        CellID cellID;


        if (cell instanceof EnvironmentCellMO) {
            // special case: environment cell is a singleton that has a fixed id
            cellID = CellID.getEnvironmentCellID();
        } else {
            // default case: assign a new cell ID
            CellCounter counter;
            try {
                counter = (CellCounter) dm.getBindingForUpdate(COUNTER_BINDING_NAME);
            } catch (NameNotBoundException nnbe) {
                counter = new CellCounter();
                dm.setBinding(COUNTER_BINDING_NAME, counter);
            }


            cellID = new CellID(counter.nextCellID());
        }


        dm.setBinding(getCellBinding(cellID), cell);
        return cellID;
    }

View Full Code Here


        return out;
    }


    private static CellComponentMap getComponentMap() {
        DataManager dm = AppContext.getDataManager();
        CellComponentMap out;
        try {
            out = (CellComponentMap) dm.getBinding(COMPONENTS_BINDING_NAME);
        } catch (NameNotBoundException nnbe) {
            logger.log(Level.WARNING, COMPONENTS_BINDING_NAME + " not bound",
                       nnbe);
            out = new CellComponentMap();
            dm.setBinding(COMPONENTS_BINDING_NAME, out);
        }


        return out;
    }

View Full Code Here

  /**
   * {@inheritDoc}
   */
  public void clear() {
      TreeNode<E> parent = getParent();
      DataManager dm = AppContext.getDataManager();
      dm.removeObject(getSubList());
      dm.removeObject(this);
      parent.clear();
  }

View Full Code Here

        private ManagedReference<ClientSession> sessionRef;


        private TestProtocolSessionListener(ClientSession session) {
            logger.info("New session for " + session.getName());
            
            DataManager dm = AppContext.getDataManager();
            sessionRef = dm.createReference(session);
        }

View Full Code Here

            public SendTask(WonderlandClientSender sender, 
                            ClientSession session) 
            {
                this.sender = sender;
                
                DataManager dm = AppContext.getDataManager();
                sessionRef = dm.createReference(session);
            }

View Full Code Here

  // If we need more depth, we will use a recursive call to the ensure
  // depth on the leaves.
  int leafBits = Math.min(minDepth - depth, maxDirBits);
  int numLeaves = 1 << leafBits;


  DataManager dm = AppContext.getDataManager();
  dm.markForUpdate(this);
        ManagedReference<ScalableHashMap<K, V>> thisRef =
      dm.createReference(this);


  ScalableHashMap[] leaves = new ScalableHashMap[numLeaves];
  for (int i = 0; i < numLeaves; ++i) {
            ScalableHashMap<K, V> leaf = new ScalableHashMap<K, V>(
    depth + leafBits, minDepth, splitThreshold, 1 << maxDirBits);
      leaves[i] = leaf;
      leaf.parentRef = thisRef;
  }


  // for the linked list for the leaves
        for (int i = 1; i < numLeaves - 1; ++i) {
            ScalableHashMap<K, V> leaf = uncheckedCast(leaves[i]);
            leaf.leftLeafRef = uncheckedCast(
                    dm.createReference(leaves[i - 1]));
            leaf.rightLeafRef = uncheckedCast(
                    dm.createReference(leaves[i + 1]));
  }


  // edge updating - Note that since there are guaranteed to be at least
  // two leaves, these absolute offset calls are safe
        ScalableHashMap<K, V> firstLeaf = uncheckedCast(leaves[0]);
  firstLeaf.leftLeafRef = leftLeafRef;
  if (leftLeafRef != null) {
      ScalableHashMap<K, V> leftLeaf = leftLeafRef.get();
      leftLeaf.rightLeafRef = dm.createReference(firstLeaf);
  }
  firstLeaf.rightLeafRef = uncheckedCast(dm.createReference(leaves[1]));
        ScalableHashMap<K, V> lastLeaf = uncheckedCast(leaves[numLeaves - 1]);
  lastLeaf.leftLeafRef =
                uncheckedCast(dm.createReference(leaves[numLeaves - 2]));
  lastLeaf.rightLeafRef = rightLeafRef;
  if (rightLeafRef != null) {
      ScalableHashMap<K, V> rightLeaf = rightLeafRef.get();
      rightLeaf.leftLeafRef = dm.createReference(lastLeaf);
  }


  // since this node is now a directory, invalidate its leaf-list
  // references
  leftLeafRef = null;
  rightLeafRef = null;


  int entriesPerLeaf = nodeDirectory.length / numLeaves;


  // lastly, fill the directory with the references
  int pos = 0;
  for (ScalableHashMap leaf : leaves) {
      int nextPos = pos + entriesPerLeaf;
      Arrays.fill(nodeDirectory, pos, nextPos, dm.createReference(leaf));
      pos = nextPos;
  }


  /* Make sure the leaves have the minimum required depth. */
  for (ScalableHashMap leaf : leaves) {

View Full Code Here

     */
    private void split() {
  assert isLeafNode() : "Can't split an directory node";
  assert depth < MAX_DEPTH : "Can't split at maximum depth";


  DataManager dataManager = AppContext.getDataManager();
  dataManager.markForUpdate(this);


        ScalableHashMap<K, V> leftChild =
                new ScalableHashMap<K, V>(
                depth + 1, minDepth, splitThreshold, 1 << maxDirBits);
        ScalableHashMap<K, V> rightChild =
                new ScalableHashMap<K, V>(
                depth + 1, minDepth, splitThreshold, 1 << maxDirBits);


  // to add this node to the parent directory, we need to determine the
  // prefix that will lead to this node.  Grabbing a hash code from one
  // of our entries will suffice.
  int prefix = 0x0; // this should never stay at its initial value


  // iterate over all the entries in this table and assign them to either
  // the right child or left child
  int firstRight = table.length / 2;
  for (int i = 0; i < table.length; i++) {
            ScalableHashMap<K, V> child =
                    (i < firstRight) ? leftChild : rightChild;
            PrefixEntry<K, V> prev = null;
      int prevIndex = 0;
            PrefixEntry<K, V> e = getBucket(i);
      while (e != null) {
    prefix = e.hash;
    int index = child.indexFor(e.hash);
                PrefixEntry<K, V> next = e.next;
    /* Chain to the previous node if the index is the same */
    child.addEntry(e, index == prevIndex ? prev : null);
    prev = e;
    prevIndex = index;
    e = next;
      }
  }


  // null out the intermediate node's table
  setDirectoryNode();
  size = 0;


  // create the references to the new children
        ManagedReference<ScalableHashMap<K, V>> leftChildRef =
                dataManager.createReference(leftChild);
        ManagedReference<ScalableHashMap<K, V>> rightChildRef =
                dataManager.createReference(rightChild);


  if (leftLeafRef != null) {
            ScalableHashMap<K, V> leftLeaf = leftLeafRef.get();
      leftLeaf.rightLeafRef = leftChildRef;
      leftChild.leftLeafRef = leftLeafRef;
      leftLeafRef = null;
  }


  if (rightLeafRef != null) {
            ScalableHashMap<K, V> rightLeaf = rightLeafRef.get();
      rightLeaf.leftLeafRef = rightChildRef;
      rightChild.rightLeafRef = rightLeafRef;
      rightLeafRef = null;
  }


  // update the family links
  leftChild.rightLeafRef = rightChildRef;
  rightChild.leftLeafRef = leftChildRef;


  // Decide what to do with this node:


  // This node should form a new directory node in the following cases:
  //
  // 1. This node is the root node.
  //
  // 2. This node has reached the maximum permitted depth relative to its
  //    parent.  Each directory node uses at most maxDirBits of the hash
  //    code to determine the position of a child node in its directory.
  //    If the depth of this node relative to its parent already uses
  //    that number of bits, then an additional level of directory nodes
  //    is needed to reach the desired depth.  Note that a node will
  //    reach its maximum depth only after all of its parents have
  //    already done so.
  //
  // 3. The minimum concurrency requested requires that the parent node
  //    not be modified.  When the trie is constructed, leaves are
  //    created at a minimum depth.  When one of these leaves needs to
  //    split, it should not be added to its parent directory, in order
  //    to provide the requested concurrency.
  if (isRootNode() ||
      depth % maxDirBits == 0 ||
      depth == minDepth) {


      // this leaf node will become a directory node
            ManagedReference<ScalableHashMap<K, V>> thisRef =
    dataManager.createReference(this);
      rightChild.parentRef = thisRef;
      leftChild.parentRef = thisRef;


      setDirectoryNode();
      nodeDirectory = new ManagedReference[1 << getNodeDirBits()];

View Full Code Here

  int index = highBits(prefix, dirBits);


  // the leaf is under this node, so just look it up using the directory
        ScalableHashMap<K, V> leaf = getChildNode(index);


  DataManager dm = AppContext.getDataManager();


  // remove the old leaf node
  dm.removeObject(leaf);
  // mark this node for update since we will be changing its directory
  dm.markForUpdate(this);


  // update the new children nodes to point to this directory node as
  // their parent
        ManagedReference<ScalableHashMap<K, V>> thisRef =
      dm.createReference(this);
  rightChildRef.get().parentRef = thisRef;
  leftChildRef.get().parentRef = thisRef;


  // how many bits in the prefix are significant for looking up the
  // old leaf

View Full Code Here

  private final Stack<Integer> offsets = new Stack<Integer>();


  /** Creates an instance for the specified directory node. */
        private RemoveNodesTask(ScalableHashMap<K, V> node) {
      assert !node.isLeafNode();
      DataManager dm = AppContext.getDataManager();
            ManagedReference<ScalableHashMap<K, V>> lastRef = null;
      for (int i = 0; i < node.nodeDirectory.length; i++) {
                ManagedReference<ScalableHashMap<K, V>> ref =
        uncheckedCast(node.nodeDirectory[i]);
    /* Skip clearing duplicate nodes in the directory */
    if (ref != lastRef) {
                    ScalableHashMap<K, V> child = ref.get();
        /*
         * Clear the parent reference so we don't walk up to the
         * root node, which is being reused.
         */
        dm.markForUpdate(child);
        child.parentRef = null;
        if (lastRef == null) {
      currentNodeRef = ref;
        } else {
      nodeRefs.add(ref);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.sun.sgs.app.DataManager

com.sun.sgs.app.util.ScalableDeque

com.sun.sgs.app.util.ScalableDeque$Element

com.sun.sgs.app.util.ScalableHashMap

com.sun.sgs.app.util.ScalableHashMap$PrefixEntry

com.sun.sgs.app.util.ScalableHashMap$RemoveNodesTask

com.sun.sgs.app.util.ScalableList

com.sun.sgs.app.util.ScalableList$AsynchronousClearTask

com.sun.sgs.app.util.ScalableList$ListNode

com.sun.sgs.app.util.ScalableList$TreeNode

com.sun.sgs.impl.kernel.KernelContext

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.