spmd/split/AbstractSplitMap.java

package appl.parallel.spmd.split;

import java.awt.Rectangle;
import java.awt.geom.Rectangle2D;

/**
 * This class can be used for the implementation of {@link SplitMap}s. It already
 * provides most of the functions. Normally subclasses only have to implement the methods
 * {@link SplitMap#makeMap()} and {@link SplitMap#getNeighborsForPosition(int)}.
 *
 * @see SplitMap
 *
 * @author Dominik Appl
 */
public abstract class AbstractSplitMap implements SplitMap {

        public enum NeighborhoodBoxingMode {
                inBoxing, outBoxing
        }

        protected NeighborhoodBoxingMode boxingMode;
        protected int noOfPartitions;
        protected int globalHeight;
        protected int globalWidth;

        /**
         * a value of weights determines how big the share of the
         * partition with this position is. The sum of all values
         * should be 1 or near to 1.
         */
        protected double[] weights;
        protected int neighborhoodRange;

        /** the Rectangle of the whole Grid **/
        protected Rectangle globalBounds;
        /** the calculation area of each partition */
        protected Rectangle[] partitionCalculationBounds;
        /** the bounds of the neighborhood data of the partition */
        protected Rectangle[] partitionNeighborhoodBounds;
    protected String[] IPs;

        public AbstractSplitMap(SplittableResource splittable, int neighborhoodRange,
                        int noOfPartitions,
                        NeighborhoodBoxingMode boxingMode) {
                this(splittable.getSplitWidth(),splittable.getSplitHeight(),neighborhoodRange, noOfPartitions, boxingMode);

        }

        public AbstractSplitMap() {
                this.globalWidth = 1;
                this.globalHeight = 1;
                this.neighborhoodRange = 0;
                this.noOfPartitions = 1;
                this.boxingMode = NeighborhoodBoxingMode.inBoxing;
                init();
                makeMap();
        }

         /**
         * @param width
         * @param height
         * @param neighborhoodRange
         * @param noOfPartitions
         * @param boxingMode
         */
        public AbstractSplitMap(int width, int height, int neighborhoodRange, int noOfPartitions, NeighborhoodBoxingMode boxingMode) {
                this.globalWidth = width;
                this.globalHeight = height;
                this.neighborhoodRange = neighborhoodRange;
                this.noOfPartitions = noOfPartitions;
                this.boxingMode = boxingMode;
                init();
                makeMap();
        }

        /* non java-doc
         * @see appl.parallel.spmd.split.SplitMap#setParameters(SplittableResource, int, int, appl.parallel.spmd.split.AbstractSplitMap.NeighborhoodBoxingMode)
         */
        public void setParameters(SplittableResource splittable, int neighborhoodRange, int noOfPartitions, NeighborhoodBoxingMode boxingMode) {
                this.globalWidth = splittable.getSplitWidth();
                this.globalHeight = splittable.getSplitHeight();
                this.neighborhoodRange = neighborhoodRange;
                this.noOfPartitions = noOfPartitions;
                this.boxingMode = boxingMode;
                init();
        }

        /**
         * Initializes the bounds of the partitions
         */
        protected void init() {
                if (noOfPartitions < 1)
                        throw new UnsupportedOperationException(
                                        "Number of Partions must be > 0");

                //Initialize the weight for equal split (should not matter if not excactly 100%)
                weights = new double[noOfPartitions];
                for (int i = 0; i < noOfPartitions; i++)
                        weights[i] = (1.0 / noOfPartitions);
                globalBounds = new Rectangle(0, 0, globalWidth, globalHeight);
                partitionCalculationBounds = new Rectangle[noOfPartitions];
                partitionNeighborhoodBounds = new Rectangle[noOfPartitions];

        }


        public void setWeights(double... weights) {
                if (weights.length != noOfPartitions)
                        throw new UnsupportedOperationException("The number of weights ("
                                        + weights.length
                                        + ") does not match the number of partitions ("
                                        + noOfPartitions + ")");
                //check if the weights are valid
                for (double weight : weights) {
                        if(weight <=0 || weight > 1)
                                throw new UnsupportedOperationException("A weight was '" + weight + "' but must be between 0 and 1");
                }
                this.weights = weights;
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getDescription()
         */
        public abstract String getDescription();

        /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getNeighborsForPosition(int)
         */
        public abstract int[] getNeighborsForPosition(int pos);

        /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#makeMap()
         */
        public abstract void makeMap();


        /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getGlobalCalculationBounds()
         */
        public Rectangle getGlobalCalculationBounds() {
                return globalBounds;
        }


        /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getLocalCalculationArea(int)
         */
        public Rectangle getLocalCalculationBounds(int pos){
                Rectangle localBounds = (Rectangle) partitionCalculationBounds[pos].clone();
                //move relative to the partition bounds
                double xdiff=partitionCalculationBounds[pos].getX()-partitionNeighborhoodBounds[pos].getX();
                double ydiff=partitionCalculationBounds[pos].getY()-partitionNeighborhoodBounds[pos].getY();
                //set to the local coordinates
                localBounds.setLocation((int) xdiff, (int) ydiff);
                return localBounds;
        }


        /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getLocalNeighborhoodArea(int)
         */
        public Rectangle getLocalNeighborhoodBounds(int pos) {
                Rectangle localBounds = (Rectangle) partitionNeighborhoodBounds[pos]
                                .clone();
                //move to (0,0)
                localBounds.setLocation(0, 0);
                return localBounds;
        }

        /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getPartitionCalculationArea(int)
         */
        public Rectangle getPartitionCalculationBounds(int pos) {
                return partitionCalculationBounds[pos];
        }

        public Rectangle getPartitionNeighborhoodBounds(int pos) {
                return partitionNeighborhoodBounds[pos];
        }


         /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getGlobalBounds()
         */
        public Rectangle getGlobalBounds() {
                return globalBounds;
        }

    /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getPartitionBounds(int)
         */
        public Rectangle getPartitionBounds(int pos) {
                return partitionNeighborhoodBounds[pos];
        }

        public Rectangle getLocalBounds(int pos)
        {
                return getLocalNeighborhoodBounds(pos);
        }


    /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#getIP(int)
         */
        public String getIP(int pos) {
          if(IPs==null)
                  return null;
          if(IPs.length!=noOfPartitions)
                  return null;
          return IPs[pos];
        }

    /* (non-Javadoc)
         * @see appl.parallel.spmd.split.SplitMap#setIPs(java.lang.String[])
         */
        public void setIPs(String[] IPs) {
       this.IPs = IPs;
        }

    /**
         * @return the neighborhoodRange
         */
        public int getNeighborhoodRange() {
                return neighborhoodRange;
        }

        public int getCount(){
                return noOfPartitions;
        }
}
1	package appl.parallel.spmd.split;
2
3	import java.awt.Rectangle;
4	import java.awt.geom.Rectangle2D;
5
6	/**
7	* This class can be used for the implementation of {@link SplitMap}s. It already
8	* provides most of the functions. Normally subclasses only have to implement the methods
9	* {@link SplitMap#makeMap()} and {@link SplitMap#getNeighborsForPosition(int)}.
10	*
11	* @see SplitMap
12	*
13	* @author Dominik Appl
14	*/
15	public abstract class AbstractSplitMap implements SplitMap {
16
17	public enum NeighborhoodBoxingMode {
18	inBoxing, outBoxing
19	}
20
21	protected NeighborhoodBoxingMode boxingMode;
22	protected int noOfPartitions;
23	protected int globalHeight;
24	protected int globalWidth;
25
26	/**
27	* a value of weights determines how big the share of the
28	* partition with this position is. The sum of all values
29	* should be 1 or near to 1.
30	*/
31	protected double[] weights;
32	protected int neighborhoodRange;
33
34	/ the Rectangle of the whole Grid /
35	protected Rectangle globalBounds;
36	/** the calculation area of each partition */
37	protected Rectangle[] partitionCalculationBounds;
38	/** the bounds of the neighborhood data of the partition */
39	protected Rectangle[] partitionNeighborhoodBounds;
40	protected String[] IPs;
41
42	public AbstractSplitMap(SplittableResource splittable, int neighborhoodRange,
43	int noOfPartitions,
44	NeighborhoodBoxingMode boxingMode) {
45	this(splittable.getSplitWidth(),splittable.getSplitHeight(),neighborhoodRange, noOfPartitions, boxingMode);
46
47	}
48
49	public AbstractSplitMap() {
50	this.globalWidth = 1;
51	this.globalHeight = 1;
52	this.neighborhoodRange = 0;
53	this.noOfPartitions = 1;
54	this.boxingMode = NeighborhoodBoxingMode.inBoxing;
55	init();
56	makeMap();
57	}
58
59	/**
60	* @param width
61	* @param height
62	* @param neighborhoodRange
63	* @param noOfPartitions
64	* @param boxingMode
65	*/
66	public AbstractSplitMap(int width, int height, int neighborhoodRange, int noOfPartitions, NeighborhoodBoxingMode boxingMode) {
67	this.globalWidth = width;
68	this.globalHeight = height;
69	this.neighborhoodRange = neighborhoodRange;
70	this.noOfPartitions = noOfPartitions;
71	this.boxingMode = boxingMode;
72	init();
73	makeMap();
74	}
75
76	/* non java-doc
77	* @see appl.parallel.spmd.split.SplitMap#setParameters(SplittableResource, int, int, appl.parallel.spmd.split.AbstractSplitMap.NeighborhoodBoxingMode)
78	*/
79	public void setParameters(SplittableResource splittable, int neighborhoodRange, int noOfPartitions, NeighborhoodBoxingMode boxingMode) {
80	this.globalWidth = splittable.getSplitWidth();
81	this.globalHeight = splittable.getSplitHeight();
82	this.neighborhoodRange = neighborhoodRange;
83	this.noOfPartitions = noOfPartitions;
84	this.boxingMode = boxingMode;
85	init();
86	}
87
88	/**
89	* Initializes the bounds of the partitions
90	*/
91	protected void init() {
92	if (noOfPartitions < 1)
93	throw new UnsupportedOperationException(
94	"Number of Partions must be > 0");
95
96	//Initialize the weight for equal split (should not matter if not excactly 100%)
97	weights = new double[noOfPartitions];
98	for (int i = 0; i < noOfPartitions; i++)
99	weights[i] = (1.0 / noOfPartitions);
100	globalBounds = new Rectangle(0, 0, globalWidth, globalHeight);
101	partitionCalculationBounds = new Rectangle[noOfPartitions];
102	partitionNeighborhoodBounds = new Rectangle[noOfPartitions];
103
104	}
105
106
107
108	public void setWeights(double... weights) {
109	if (weights.length != noOfPartitions)
110	throw new UnsupportedOperationException("The number of weights ("
111	+ weights.length
112	+ ") does not match the number of partitions ("
113	+ noOfPartitions + ")");
114	//check if the weights are valid
115	for (double weight : weights) {
116	if(weight <=0 \|\| weight > 1)
117	throw new UnsupportedOperationException("A weight was '" + weight + "' but must be between 0 and 1");
118	}
119	this.weights = weights;
120	}
121
122	/* (non-Javadoc)
123	* @see appl.parallel.spmd.split.SplitMap#getDescription()
124	*/
125	public abstract String getDescription();
126
127	/* (non-Javadoc)
128	* @see appl.parallel.spmd.split.SplitMap#getNeighborsForPosition(int)
129	*/
130	public abstract int[] getNeighborsForPosition(int pos);
131
132	/* (non-Javadoc)
133	* @see appl.parallel.spmd.split.SplitMap#makeMap()
134	*/
135	public abstract void makeMap();
136
137
138	/* (non-Javadoc)
139	* @see appl.parallel.spmd.split.SplitMap#getGlobalCalculationBounds()
140	*/
141	public Rectangle getGlobalCalculationBounds() {
142	return globalBounds;
143	}
144
145
146
147	/* (non-Javadoc)
148	* @see appl.parallel.spmd.split.SplitMap#getLocalCalculationArea(int)
149	*/
150	public Rectangle getLocalCalculationBounds(int pos){
151	Rectangle localBounds = (Rectangle) partitionCalculationBounds[pos].clone();
152	//move relative to the partition bounds
153	double xdiff=partitionCalculationBounds[pos].getX()-partitionNeighborhoodBounds[pos].getX();
154	double ydiff=partitionCalculationBounds[pos].getY()-partitionNeighborhoodBounds[pos].getY();
155	//set to the local coordinates
156	localBounds.setLocation((int) xdiff, (int) ydiff);
157	return localBounds;
158	}
159
160
161	/* (non-Javadoc)
162	* @see appl.parallel.spmd.split.SplitMap#getLocalNeighborhoodArea(int)
163	*/
164	public Rectangle getLocalNeighborhoodBounds(int pos) {
165	Rectangle localBounds = (Rectangle) partitionNeighborhoodBounds[pos]
166	.clone();
167	//move to (0,0)
168	localBounds.setLocation(0, 0);
169	return localBounds;
170	}
171
172	/* (non-Javadoc)
173	* @see appl.parallel.spmd.split.SplitMap#getPartitionCalculationArea(int)
174	*/
175	public Rectangle getPartitionCalculationBounds(int pos) {
176	return partitionCalculationBounds[pos];
177	}
178
179	public Rectangle getPartitionNeighborhoodBounds(int pos) {
180	return partitionNeighborhoodBounds[pos];
181	}
182
183
184	/* (non-Javadoc)
185	* @see appl.parallel.spmd.split.SplitMap#getGlobalBounds()
186	*/
187	public Rectangle getGlobalBounds() {
188	return globalBounds;
189	}
190
191	/* (non-Javadoc)
192	* @see appl.parallel.spmd.split.SplitMap#getPartitionBounds(int)
193	*/
194	public Rectangle getPartitionBounds(int pos) {
195	return partitionNeighborhoodBounds[pos];
196	}
197
198	public Rectangle getLocalBounds(int pos)
199	{
200	return getLocalNeighborhoodBounds(pos);
201	}
202
203
204	/* (non-Javadoc)
205	* @see appl.parallel.spmd.split.SplitMap#getIP(int)
206	*/
207	public String getIP(int pos) {
208	if(IPs==null)
209	return null;
210	if(IPs.length!=noOfPartitions)
211	return null;
212	return IPs[pos];
213	}
214
215	/* (non-Javadoc)
216	* @see appl.parallel.spmd.split.SplitMap#setIPs(java.lang.String[])
217	*/
218	public void setIPs(String[] IPs) {
219	this.IPs = IPs;
220	}
221
222	/**
223	* @return the neighborhoodRange
224	*/
225	public int getNeighborhoodRange() {
226	return neighborhoodRange;
227	}
228
229	public int getCount(){
230	return noOfPartitions;
231	}
232	}