org/objectweb/proactive/calcium/Task.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.calcium;

import java.io.Serializable;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;

import org.apache.log4j.Logger;
import org.objectweb.proactive.calcium.interfaces.Instruction;
import org.objectweb.proactive.calcium.statistics.StatsImpl;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;

public class Task<T> implements Serializable, Comparable<Task>{
        static Logger logger = ProActiveLogger.getLogger(Loggers.SKELETONS);
        
        public static int DEFAULT_PRIORITY=0;
        static private int DEFAULT_STREAM_ID,DEFAULT_ROOT_PARENT_ID=-1;

        
        //Rebirth preserved parameters
        private int familyId; //Id of the root task
        private int parentId;
        private T object;
        private int id;
        private int priority; //higher number, higher priority
        private boolean isTainted;
        private boolean isDummy;
        private StatsImpl stats;
        private int streamId;
        
        //The program stack. Higher indexed elements are served first (LIFO).
        private Vector<Instruction<T>> stack;
        
        /*
         * Children (sub task) state queues (not preserved by Rebirth)
         */
        private Vector<Task<T>> childrenReady;
        private Hashtable<Task<?>,Task<T>> childrenWaiting;
        private Vector<Task<T>> childrenFinished;
        private Exception exception;
        
                
        public Task(){
                
        }
        
        private Task(T object, int id, int priority, int parentId,  int familyId, int streamId) {
                this.object = object;
                this.id = id;
                this.priority = priority;
                this.parentId= parentId;
                this.familyId=familyId;
                this.streamId=streamId;
                
                isDummy=false;
                stats = new StatsImpl();
                stack=new Vector<Instruction<T>>();
                
                childrenReady=new Vector<Task<T>>();
                childrenWaiting=new Hashtable<Task<?>,Task<T>>();
                childrenFinished=new Vector<Task<T>>();
                exception=null;
        }
                
        public Task(T object){
                this(object, (int)(Math.random()*Integer.MAX_VALUE), DEFAULT_PRIORITY, 
                                DEFAULT_ROOT_PARENT_ID, DEFAULT_ROOT_PARENT_ID, DEFAULT_STREAM_ID);
                this.familyId=this.id; //Root task, head of the family
        }
        
        public Task<T> reBirth(T object){
                Task<T> newMe = new Task<T>(object,id, priority,parentId, familyId,streamId);
                newMe.setStack(this.stack);
                
                newMe.isDummy=this.isDummy;
                newMe.isTainted=this.isTainted;
                
                newMe.stats=this.stats;
                
                return newMe;
        }
        
        public int compareTo(Task task){
                return task.priority - this.priority;
        }
        
        @Override
        public int hashCode(){
                return id;
        }
        
        
        public boolean equals(Task<T> task){
                return this.hashCode()==task.hashCode();
                
        }
        
        @Override
        public boolean equals(Object o){
                return this.hashCode() == o.hashCode();
        }
        
        public Vector<Instruction<T>> getStack(){
                return getVector(stack);
        }
        
        public void setStack(Vector<Instruction<T>> v){         
                setVector(stack, v);
        }
        
        private <E> Vector<E> getVector(Vector<E> vector){
                
                Iterator<E> it = vector.iterator();
                
                Vector<E> v = new Vector<E>();
                while(it.hasNext()){
                        v.add(it.next());
                }
                return v;       
        }
        
        private <E> void setVector(Vector<E> oldVector, Vector<E> newVector){
                oldVector.clear();
                
                Iterator<E> it = newVector.iterator();
                while(it.hasNext()){
                        oldVector.add(it.next());
                }
        }

        public int getParentId() {
                return parentId;
        }

        private void setParent(int parentId) {
                this.parentId = parentId;
        }

        private void setFamily(int familyId) {
                this.familyId=familyId;
        }
        
        public boolean hasInstruction(){
                return !stack.isEmpty();
        }
        
        public boolean hasReadyChildTask(){
                return !childrenReady.isEmpty();
        }
        
        public Instruction<T> popInstruction(){
                
                Instruction<T> c = stack.remove(stack.size()-1);

                return c;
        }
        
        public Instruction<T> peekInstruction(){
                
                return stack.get(stack.size()-1);
        }
        
        public void pushInstruction(Instruction<T> inst){
                stack.add(inst);
        }
                
        public T getObject(){
                return object;  
        }
        
        public void setObject(T object){
                this.object=object;
        }

        public int getId() {
                return id;
        }

        public int getPriority() {
                return priority;
        }
        
        public void setPriority(int newPriority) {
                this.priority=newPriority;
        }
        
        public synchronized Task<T> getReadyChild(){
                
                if(childrenReady.isEmpty()) return null;
                
                Task<T> task=this.childrenReady.remove(0);
                this.childrenWaiting.put(task, task);
                return task;
        }
        
        public synchronized void addReadyChild(Task<T> child){
                child.setPriority(getPriority()+1);
                child.setParent(getId());
                child.setFamily(getFamilyId());
                this.childrenReady.add(child);
        }

        @SuppressWarnings("unchecked")
        public synchronized boolean setFinishedChild(Task<?> task){
                
                if(!task.isFinished()){
                        logger.error("Task id="+task+" claims to be unfinished.");
                        return false;
                }
                
                if(task.getParentId()!=this.getId()) {
                        logger.error("Setting other task's child as my child: child.id="+" task.parent.id="+task.parentId);
                        return false; //not my child
                }
                
                if(!this.childrenWaiting.containsKey(task)){
                        logger.error("Parent id="+this.id+" not waiting for child: task.id="+task.id);
                        return false;
                }
                
                childrenWaiting.remove(task);
                childrenFinished.add((Task<T>)task);
                
                stats.addChildStats(task.getStats());
                
                return true;
        }
        
        public synchronized boolean isFinished(){
                return isReady() &&  !hasInstruction();
        }
        
        public synchronized boolean isReady(){
                return childrenReady.isEmpty() &&
                   childrenWaiting.isEmpty();
        }
        
        
        public synchronized boolean hasFinishedChild(){
                return !this.childrenFinished.isEmpty();
        }
        
        public synchronized Task<T> getFinishedChild(){
                
                if(childrenFinished.isEmpty()){
                        logger.error("No finished child available");
                        return null;
                }
                
                return childrenFinished.remove(0);
        }
        
        public boolean isRootTask(){
                return this.familyId==this.id;
        }
        
        @Override
        public String toString(){
                return this.familyId+"/"+parentId+"."+this.id;
        }

        public boolean isDummy() {
                return isDummy;
        }

        public void setDummy() {
                isDummy=true;
        }

        public Exception getException() {
                return exception;
        }

        public void setException(Exception exception) {
                this.exception = exception;
        }
        
        public boolean hasException(){
                return this.exception !=null;
        }

        public int getFamilyId() {
                return familyId;
        }

        public boolean isTainted() {
                return isTainted;
        }

        public void setTainted(boolean isTainted) {
                this.isTainted = isTainted;
        }
        
        public void markFinishTime(){
                stats.markFinishTime();
        }
        
        public StatsImpl getStats(){
                return stats;
        }

        public int getStreamId() {
                return streamId;
        }

        public void setStreamId(int streamId) {
                this.streamId = streamId;
        }
}

---