parallel/spmd/SPMDServerController.java

package appl.parallel.spmd;

import java.awt.Rectangle;
import java.rmi.RemoteException;
import java.util.HashMap;
import java.util.Vector;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import appl.parallel.ComputingResource;
import appl.parallel.client.DataServer;
import appl.parallel.data.WritableGridArrayPartition;
import appl.parallel.model.AbstractParallelStepModel;
import appl.parallel.server.PartitionDataManager;
import appl.parallel.spmd.split.DataPartition;
import appl.parallel.spmd.split.PartitionInfo;
import appl.parallel.spmd.split.SplitMap;
import appl.parallel.spmd.split.SplittableResource;

/**
 * This class controls all the parallelization action on the server side and is
 * the counterpart to {@link SPMDClientController}. It is accessed by the model
 * developer by retrieving the {@link SPMDServerInterface} from a
 * {@link SPMDTask}.
 * 
 * @author Dominik Appl
 */
public class SPMDServerController implements SPMDServerInterface {

        private Logger LOG = LogManager.getLogger(this.getClass().getName());

        PartitionDataManager dataManager;
        
        private Rectangle localCalculationBounds;

        private final SplitMap referenceSplitMap;

        /**
         * the partition position (used for splitmaps)
         */
        protected final int mapPosition;
        
        /**
         * Creates a new instance 
         * @param dataManager the partition data server responsible for managing the data on the server
         * @param referenceResouceID the id of the reference resource
         */
        public SPMDServerController(PartitionDataManager dataManager,
                        int referenceResouceID) {
                this.dataManager = dataManager;
                // if there are any partitions the referenceID should be != -1
                if (referenceResouceID != -1) {
                        referenceSplitMap = dataManager.getInfo(referenceResouceID)
                                        .getSplitMap();
                        mapPosition = dataManager.getInfo(referenceResouceID)
                                        .getSplitMapPos();
                } else {
                        referenceSplitMap = null;
                        mapPosition = 0;
                }
                //setting the calculation bounds to the default area
                localCalculationBounds=referenceSplitMap.getLocalCalculationBounds(mapPosition);
        }
        
        /**
         * This method sets new calculation bounds. This is used to divide the rasters for 
         * parallel computation on one machine (using multiple cpu's or cpu cores)
         * 
         * @param newBounds the new calculation bounds
         */
        public void setLocalCalculationBounds(Rectangle newBounds){
                localCalculationBounds = newBounds;
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getBaseParameter(java.lang.String)
         */
        public Object getBaseParameter(String parameterName) {
                Object returnValue =  dataManager.getBaseParameter(parameterName);
                 if(returnValue==null)
                         LOG.warn("No value for parameter '" + parameterName + "' found or value was null" );
                 return returnValue;
        }

                

        
        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalCalculationBounds(appl.parallel.spmd.split.DataPartition)
         */
        public Rectangle getLocalCalculationBounds(DataPartition partition) {
                return dataManager.getInfo(partition.getRootID()).getSplitMap()
                                .getLocalCalculationBounds(mapPosition);
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalBounds(appl.parallel.spmd.split.DataPartition)
         */
        public Rectangle getLocalBounds(DataPartition partition) {
                PartitionInfo info = dataManager.getInfo(partition.getRootID());
                return info.getSplitMap().getLocalBounds(mapPosition);
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getGlobalBounds(appl.parallel.spmd.split.DataPartition)
         */
        public Rectangle getGlobalBounds(DataPartition partition) {
                PartitionInfo info = dataManager.getInfo(partition.getRootID());
                return info.getSplitMap().getGlobalBounds();
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalCalculationBounds()
         */
        public Rectangle getLocalCalculationBounds() {
                return localCalculationBounds;
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalBounds()
         */
        public Rectangle getLocalBounds() {
                return referenceSplitMap.getLocalBounds(mapPosition);
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getPartition(java.lang.String)
         */
        public DataPartition getPartition(String name) {
                DataPartition partition = dataManager.getData(name);
                if (partition == null)
                        LOG.error("ERROR: The Partition with the name '" + name
                                                        + "' was not found or was null");
                return partition;
        }
        
        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getMultiPartition(java.lang.String)
         */
        public DataPartition[] getMultiPartition(String name) {
                DataPartition[] partitions = dataManager.getMultiData(name);
                if (partitions == null)
                        LOG.error("ERROR: The Partition with the name '" + name
                                                        + "' was not found or was null");
//              if(partitions.length>0)
//                if(partitions[0] instanceof WritableGridArrayPartition.Float){
//                      WritableGridArrayPartition[] wgPartitions = new WritableGridArrayPartition[partitions.length];
//                      System.arraycopy(partitions, 0, wgPartitions, 0, partitions.length);
//                      return (DataPartition[]) wgPartitions;
//                }
                return partitions;
        }
        
        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getMultiData(java.lang.String)
         */
        public MultiDataObject getMultiData(String name){
                MultiDataObject multiDataObject=null;
                try {
                        multiDataObject = dataManager.getMultiDataObject(name);
                        if(multiDataObject==null)
                                LOG.warn("No Multidataobject with name '"  + name + "' found. Returning null!");
                } catch (RemoteException e) {
                        // Should never be be called (local call)
                        e.printStackTrace();
                }
                return multiDataObject;
        }
        
        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getMultiPartition(java.lang.String, int)
         */
        public DataPartition getMultiPartition(String name, int idx) {
                DataPartition partition = dataManager.getMultiData(name,idx);
                if (partition == null)
                        LOG.error("ERROR: The Partition with the name '" + name
                                                        + "' was not found or was null");
                return partition;
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMinX()
         */
        public int getLocalCalcMinX() {
                return (int) getLocalCalculationBounds().getX();
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMinY()
         */
        public int getLocalCalcMinY() {
                return (int) getLocalCalculationBounds().getY();
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMaxX()
         */
        public int getLocalCalcMaxX() {
                return (int) (getLocalCalculationBounds().getX()
                                + getLocalCalculationBounds().getWidth() - 1);
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMaxY()
         */
        public int getLocalCalcMaxY() {
                return (int) (getLocalCalculationBounds().getY()
                                + getLocalCalculationBounds().getHeight() - 1);
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.SPMDServerInterface#destroyData(java.lang.Object)
         */
        public void destroyPartition(String name) {
                dataManager.removeData(name);
        }
        
        public void destroyMultiPartition(String name,int idx)
        {
                MultiDataObject multiData = this.getMultiData(name);
                multiData.deleteElement(idx);
        }

}
1	package appl.parallel.spmd;
2
3	import java.awt.Rectangle;
4	import java.rmi.RemoteException;
5	import java.util.HashMap;
6	import java.util.Vector;
7
8	import org.apache.log4j.LogManager;
9	import org.apache.log4j.Logger;
10
11	import appl.parallel.ComputingResource;
12	import appl.parallel.client.DataServer;
13	import appl.parallel.data.WritableGridArrayPartition;
14	import appl.parallel.model.AbstractParallelStepModel;
15	import appl.parallel.server.PartitionDataManager;
16	import appl.parallel.spmd.split.DataPartition;
17	import appl.parallel.spmd.split.PartitionInfo;
18	import appl.parallel.spmd.split.SplitMap;
19	import appl.parallel.spmd.split.SplittableResource;
20
21	/**
22	* This class controls all the parallelization action on the server side and is
23	* the counterpart to {@link SPMDClientController}. It is accessed by the model
24	* developer by retrieving the {@link SPMDServerInterface} from a
25	* {@link SPMDTask}.
26	*
27	* @author Dominik Appl
28	*/
29	public class SPMDServerController implements SPMDServerInterface {
30
31	private Logger LOG = LogManager.getLogger(this.getClass().getName());
32
33	PartitionDataManager dataManager;
34
35	private Rectangle localCalculationBounds;
36
37	private final SplitMap referenceSplitMap;
38
39	/**
40	* the partition position (used for splitmaps)
41	*/
42	protected final int mapPosition;
43
44	/**
45	* Creates a new instance
46	* @param dataManager the partition data server responsible for managing the data on the server
47	* @param referenceResouceID the id of the reference resource
48	*/
49	public SPMDServerController(PartitionDataManager dataManager,
50	int referenceResouceID) {
51	this.dataManager = dataManager;
52	// if there are any partitions the referenceID should be != -1
53	if (referenceResouceID != -1) {
54	referenceSplitMap = dataManager.getInfo(referenceResouceID)
55	.getSplitMap();
56	mapPosition = dataManager.getInfo(referenceResouceID)
57	.getSplitMapPos();
58	} else {
59	referenceSplitMap = null;
60	mapPosition = 0;
61	}
62	//setting the calculation bounds to the default area
63	localCalculationBounds=referenceSplitMap.getLocalCalculationBounds(mapPosition);
64	}
65
66	/**
67	* This method sets new calculation bounds. This is used to divide the rasters for
68	* parallel computation on one machine (using multiple cpu's or cpu cores)
69	*
70	* @param newBounds the new calculation bounds
71	*/
72	public void setLocalCalculationBounds(Rectangle newBounds){
73	localCalculationBounds = newBounds;
74	}
75
76	/* (non-Javadoc)
77	* @see appl.parallel.spmd.SPMDServerInterface#getBaseParameter(java.lang.String)
78	*/
79	public Object getBaseParameter(String parameterName) {
80	Object returnValue = dataManager.getBaseParameter(parameterName);
81	if(returnValue==null)
82	LOG.warn("No value for parameter '" + parameterName + "' found or value was null" );
83	return returnValue;
84	}
85
86
87
88
89	/* (non-Javadoc)
90	* @see appl.parallel.spmd.SPMDServerInterface#getLocalCalculationBounds(appl.parallel.spmd.split.DataPartition)
91	*/
92	public Rectangle getLocalCalculationBounds(DataPartition partition) {
93	return dataManager.getInfo(partition.getRootID()).getSplitMap()
94	.getLocalCalculationBounds(mapPosition);
95	}
96
97	/* (non-Javadoc)
98	* @see appl.parallel.spmd.SPMDServerInterface#getLocalBounds(appl.parallel.spmd.split.DataPartition)
99	*/
100	public Rectangle getLocalBounds(DataPartition partition) {
101	PartitionInfo info = dataManager.getInfo(partition.getRootID());
102	return info.getSplitMap().getLocalBounds(mapPosition);
103	}
104
105	/* (non-Javadoc)
106	* @see appl.parallel.spmd.SPMDServerInterface#getGlobalBounds(appl.parallel.spmd.split.DataPartition)
107	*/
108	public Rectangle getGlobalBounds(DataPartition partition) {
109	PartitionInfo info = dataManager.getInfo(partition.getRootID());
110	return info.getSplitMap().getGlobalBounds();
111	}
112
113	/* (non-Javadoc)
114	* @see appl.parallel.spmd.SPMDServerInterface#getLocalCalculationBounds()
115	*/
116	public Rectangle getLocalCalculationBounds() {
117	return localCalculationBounds;
118	}
119
120	/* (non-Javadoc)
121	* @see appl.parallel.spmd.SPMDServerInterface#getLocalBounds()
122	*/
123	public Rectangle getLocalBounds() {
124	return referenceSplitMap.getLocalBounds(mapPosition);
125	}
126
127	/* (non-Javadoc)
128	* @see appl.parallel.spmd.SPMDServerInterface#getPartition(java.lang.String)
129	*/
130	public DataPartition getPartition(String name) {
131	DataPartition partition = dataManager.getData(name);
132	if (partition == null)
133	LOG.error("ERROR: The Partition with the name '" + name
134	+ "' was not found or was null");
135	return partition;
136	}
137
138	/* (non-Javadoc)
139	* @see appl.parallel.spmd.SPMDServerInterface#getMultiPartition(java.lang.String)
140	*/
141	public DataPartition[] getMultiPartition(String name) {
142	DataPartition[] partitions = dataManager.getMultiData(name);
143	if (partitions == null)
144	LOG.error("ERROR: The Partition with the name '" + name
145	+ "' was not found or was null");
146	// if(partitions.length>0)
147	// if(partitions[0] instanceof WritableGridArrayPartition.Float){
148	// WritableGridArrayPartition[] wgPartitions = new WritableGridArrayPartition[partitions.length];
149	// System.arraycopy(partitions, 0, wgPartitions, 0, partitions.length);
150	// return (DataPartition[]) wgPartitions;
151	// }
152	return partitions;
153	}
154
155	/* (non-Javadoc)
156	* @see appl.parallel.spmd.SPMDServerInterface#getMultiData(java.lang.String)
157	*/
158	public MultiDataObject getMultiData(String name){
159	MultiDataObject multiDataObject=null;
160	try {
161	multiDataObject = dataManager.getMultiDataObject(name);
162	if(multiDataObject==null)
163	LOG.warn("No Multidataobject with name '" + name + "' found. Returning null!");
164	} catch (RemoteException e) {
165	// Should never be be called (local call)
166	e.printStackTrace();
167	}
168	return multiDataObject;
169	}
170
171	/* (non-Javadoc)
172	* @see appl.parallel.spmd.SPMDServerInterface#getMultiPartition(java.lang.String, int)
173	*/
174	public DataPartition getMultiPartition(String name, int idx) {
175	DataPartition partition = dataManager.getMultiData(name,idx);
176	if (partition == null)
177	LOG.error("ERROR: The Partition with the name '" + name
178	+ "' was not found or was null");
179	return partition;
180	}
181
182	/* (non-Javadoc)
183	* @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMinX()
184	*/
185	public int getLocalCalcMinX() {
186	return (int) getLocalCalculationBounds().getX();
187	}
188
189	/* (non-Javadoc)
190	* @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMinY()
191	*/
192	public int getLocalCalcMinY() {
193	return (int) getLocalCalculationBounds().getY();
194	}
195
196	/* (non-Javadoc)
197	* @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMaxX()
198	*/
199	public int getLocalCalcMaxX() {
200	return (int) (getLocalCalculationBounds().getX()
201	+ getLocalCalculationBounds().getWidth() - 1);
202	}
203
204	/* (non-Javadoc)
205	* @see appl.parallel.spmd.SPMDServerInterface#getLocalCalcMaxY()
206	*/
207	public int getLocalCalcMaxY() {
208	return (int) (getLocalCalculationBounds().getY()
209	+ getLocalCalculationBounds().getHeight() - 1);
210	}
211
212	/* (non-Javadoc)
213	* @see appl.parallel.spmd.SPMDServerInterface#destroyData(java.lang.Object)
214	*/
215	public void destroyPartition(String name) {
216	dataManager.removeData(name);
217	}
218
219	public void destroyMultiPartition(String name,int idx)
220	{
221	MultiDataObject multiData = this.getMultiData(name);
222	multiData.deleteElement(idx);
223	}
224
225	}