spmd/split/SplitMap.java

package appl.parallel.spmd.split;

import java.awt.Rectangle;
import java.io.Serializable;
import java.net.InetAddress;

import appl.parallel.spmd.split.SplittableResource;
import appl.parallel.spmd.split.AbstractSplitMap.NeighborhoodBoxingMode;

/**
 * Defines a split map over a {@link SplittableResource}. A split map is a
 * layout of an actual partitioning. Each partition is associated with a number,
 * ranging from 0 to noOfPartitions-1.
 * <br>
 * The partitions are layouted as rectangles, where each rectangle represents a partition
 * or a neighborhood around a partition. Every partition or neighborhood can be queried.
 * IP-Addresses can be associated with partitions to identify the server on which a partition is located.
 * <br>
 * The interface is largely implementation independent. Multiple implementations exist.
 *
 * You can query the SplitMap for neighbors of a partition.
 *
 * @see SplitMap1DHorizontal
 * @see SplitMap1DVertical
 * @see SplitMap2D
 * @see AbstractSplitMap
 *
 * @author Dominik Appl
 */
public interface SplitMap extends Serializable{

        /**
         * returns an Array of neighbors for that position in the splitmap.
         *
         * @param pos position in splitmap
         * @return the array
         *
         */
        int[] getNeighborsForPosition(int pos);


        /**
         * With this setter, you can assign each partition a weight, so that
         * the data you split is not splitted equally, but arcording to
         * these values. A value of weights specifies how big the share of the
         * partition with this position is. The sum of all values
         * should be 1 or near to 1.
         *
         * @param weights
         * @throws UnsupportedOperationException if the number of weights does
         * not match the number of partitions
         */
        public void setWeights(double... weights);

        /**
         * @return a short description of the type of the Splitting
         */
        public String getDescription();

        /**
         * @param pos the partition number
         * @return the bounds of the partiton calculation area in global coordinates
         */
        public Rectangle getPartitionCalculationBounds(int pos);

        /**
         * @param pos the partition number
         * @return the bounds of the partiton neighborhood area in global coordinates
         */
        public Rectangle getPartitionNeighborhoodBounds(int pos);

        /**
         * @param pos the partition number
         * @return  the bounds of the partiton in global coordinates,
         *                      which should be the same as {@link #getPartitionNeighborhoodBounds(int)}
         *
         */
        public Rectangle getPartitionBounds(int pos);


        /**
         * @return {@link #getGlobalBounds()}
         */
        public Rectangle getGlobalCalculationBounds();

        /**
         * @return the bounds of the whole area starting with 0,0 in the topleft corner
         */
        public Rectangle getGlobalBounds();

        /**
         * Gets the whole partition bounds (including available neighborhood)
         * @param pos the partition number
         * @return the bounds of the partition using local coordinates. (0,0) is the topleft corner.
         */
        public Rectangle getLocalBounds(int pos);
        /**
         * @param pos the partition number
         * @return the calculation bounds of the partition using local coordinates.
         */
        public Rectangle getLocalCalculationBounds(int pos);
        /**
         * @param pos the partition number
         * @return the bounds of the partition using local coordinates. (0,0) is the topleft corner.
         */
        public Rectangle getLocalNeighborhoodBounds(int pos);


        /**
         * Sets the given values. Call makeMap() for this changes to take effekt.
         *
         * @param splittable the resource on which the splitmap is calculated
         * @param neighborhoodRange the neighborhoodrange
         * @param noOfPartitions the number of partitions to be generated
         * @param boxingMode the boxing mode
         *
         */
        public void setParameters(SplittableResource splittable, int neighborhoodRange,
                        int noOfPartitions,
                        NeighborhoodBoxingMode boxingMode);

        /**
         * @param IPs a String Array of IPs which are mapped to the partition in the given order.
         *
         */
        public void setIPs(String IPs[]);
        /**
         * @param pos position for this splitmap
         * @return the IP associated with this position
         */
        public String getIP(int pos);

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

        /**
         * Creates the map
         */
        public void makeMap();

        /**
         * @return the number of partitions
         */
        public int getCount();
}
1	mojays	2	package appl.parallel.spmd.split;
2
3			import java.awt.Rectangle;
4			import java.io.Serializable;
5			import java.net.InetAddress;
6
7			import appl.parallel.spmd.split.SplittableResource;
8			import appl.parallel.spmd.split.AbstractSplitMap.NeighborhoodBoxingMode;
9
10			/**
11			* Defines a split map over a {@link SplittableResource}. A split map is a
12			* layout of an actual partitioning. Each partition is associated with a number,
13			* ranging from 0 to noOfPartitions-1.
14			* <br>
15			* The partitions are layouted as rectangles, where each rectangle represents a partition
16			* or a neighborhood around a partition. Every partition or neighborhood can be queried.
17			* IP-Addresses can be associated with partitions to identify the server on which a partition is located.
18			* <br>
19			* The interface is largely implementation independent. Multiple implementations exist.
20			*
21			* You can query the SplitMap for neighbors of a partition.
22			*
23			* @see SplitMap1DHorizontal
24			* @see SplitMap1DVertical
25			* @see SplitMap2D
26			* @see AbstractSplitMap
27			*
28			* @author Dominik Appl
29			*/
30			public interface SplitMap extends Serializable{
31
32			/**
33			* returns an Array of neighbors for that position in the splitmap.
34			*
35			* @param pos position in splitmap
36			* @return the array
37			*
38			*/
39			int[] getNeighborsForPosition(int pos);
40
41
42			/**
43			* With this setter, you can assign each partition a weight, so that
44			* the data you split is not splitted equally, but arcording to
45			* these values. A value of weights specifies how big the share of the
46			* partition with this position is. The sum of all values
47			* should be 1 or near to 1.
48			*
49			* @param weights
50			* @throws UnsupportedOperationException if the number of weights does
51			* not match the number of partitions
52			*/
53			public void setWeights(double... weights);
54
55			/**
56			* @return a short description of the type of the Splitting
57			*/
58			public String getDescription();
59
60			/**
61			* @param pos the partition number
62			* @return the bounds of the partiton calculation area in global coordinates
63			*/
64			public Rectangle getPartitionCalculationBounds(int pos);
65
66			/**
67			* @param pos the partition number
68			* @return the bounds of the partiton neighborhood area in global coordinates
69			*/
70			public Rectangle getPartitionNeighborhoodBounds(int pos);
71
72			/**
73			* @param pos the partition number
74			* @return the bounds of the partiton in global coordinates,
75			* which should be the same as {@link #getPartitionNeighborhoodBounds(int)}
76			*
77			*/
78			public Rectangle getPartitionBounds(int pos);
79
80
81			/**
82			* @return {@link #getGlobalBounds()}
83			*/
84			public Rectangle getGlobalCalculationBounds();
85
86			/**
87			* @return the bounds of the whole area starting with 0,0 in the topleft corner
88			*/
89			public Rectangle getGlobalBounds();
90
91			/**
92			* Gets the whole partition bounds (including available neighborhood)
93			* @param pos the partition number
94			* @return the bounds of the partition using local coordinates. (0,0) is the topleft corner.
95			*/
96			public Rectangle getLocalBounds(int pos);
97			/**
98			* @param pos the partition number
99			* @return the calculation bounds of the partition using local coordinates.
100			*/
101			public Rectangle getLocalCalculationBounds(int pos);
102			/**
103			* @param pos the partition number
104			* @return the bounds of the partition using local coordinates. (0,0) is the topleft corner.
105			*/
106			public Rectangle getLocalNeighborhoodBounds(int pos);
107
108
109			/**
110			* Sets the given values. Call makeMap() for this changes to take effekt.
111			*
112			* @param splittable the resource on which the splitmap is calculated
113			* @param neighborhoodRange the neighborhoodrange
114			* @param noOfPartitions the number of partitions to be generated
115			* @param boxingMode the boxing mode
116			*
117			*/
118			public void setParameters(SplittableResource splittable, int neighborhoodRange,
119			int noOfPartitions,
120			NeighborhoodBoxingMode boxingMode);
121
122			/**
123			* @param IPs a String Array of IPs which are mapped to the partition in the given order.
124			*
125			*/
126			public void setIPs(String IPs[]);
127			/**
128			* @param pos position for this splitmap
129			* @return the IP associated with this position
130			*/
131			public String getIP(int pos);
132
133			/**
134			* @return the neighborhoodRange
135			*/
136			public int getNeighborhoodRange();
137
138			/**
139			* Creates the map
140			*/
141			public void makeMap();
142
143			/**
144			* @return the number of partitions
145			*/
146			public int getCount();
147			}