parallel/spmd/SPMDServerController.java

package appl.parallel.spmd;

import java.awt.Rectangle;
import java.rmi.RemoteException;

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

import appl.parallel.server.PartitionDataManager;
import appl.parallel.spmd.split.DataPartition;
import appl.parallel.spmd.split.PartitionInfo;
import appl.parallel.spmd.split.SplitMap;

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