spmd/split/AbstractSplitMap.java

package appl.parallel.spmd.split;

import java.awt.Rectangle;

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