parallel/data/AbstractDataHandler.java

package appl.parallel.data;

import java.awt.Rectangle;
import java.io.IOException;
import java.io.Serializable;

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

import appl.data.LoadingException;
import appl.parallel.client.ClientDataServer;
import appl.parallel.spmd.split.DataPartition;
import appl.parallel.spmd.split.SplittableResource;

/**
 * This class is used as a base class for loaders. It is especially intended for
 * use with the SPMD-Paradigm, but may be used with other loaders, too. It
 * implements the reusable stuff of the {@link PartitionDataHandler} Interface.
 * Notice that each loader is responsible for exactly one data element. It must
 * be {@link Cloneable}, so that multi-data elements can add another element.
 * 
 * @author Dominik Appl
 */
public abstract class AbstractDataHandler implements PartitionDataHandler {

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

        /**
         * The id of the currently handled {@link SplittableResource}
         */
        protected int rootID;

        /**
         * The partition bounds (the whole bounds) of the current
         * {@link SplittableResource}
         */
        protected Rectangle partitionBounds;

        /**
         * the currently handled data (must be initialized before calling
         * {@link #unload()}
         */
        protected transient DataPartition data;

        /**
         * The unload bounds differ may differ from the partitionBounds. If there is
         * a neighborhood region it is important, that only the core-region (without
         * the neighborhood) is unloaded.
         */
        protected Rectangle unloadBounds;

        /**
         * A {@link ClientDataServer} may be used locally for faster access.
         */
        protected transient ClientDataServer spmdClient;

        /**
         * Constructs a new {@link AbstractDataHandler}. The local IP address at
         * the time of construction is later used on serverside for communication
         * (e.g. unloading).
         * 
         * @param rootID
         *            the id of the data
         * @param client
         *            a {@link ClientDataServer} which may be used to get meta
         *            information on client side before transferring the loader to
         *            its destination
         * @param partitionBounds
         *            the bounds of the partition to be retrieved on server side
         * @param unloadBounds
         *            the bounds of the partition which is to be uploaded to the
         *            client after calculation (may only be the calculation area)
         */
        public AbstractDataHandler(int rootID, ClientDataServer client,
                        Rectangle partitionBounds, Rectangle unloadBounds) {
                this.spmdClient = client;
                this.rootID = rootID;
                this.partitionBounds = partitionBounds;
                this.unloadBounds = unloadBounds;
        }

        /**
         * sets a local {@link ClientDataServer} which MAY be used by the handler
         * for local access
         * 
         * @param localSPMDClient
         */
        public void setSPMDClient(ClientDataServer localSPMDClient) {
                this.spmdClient = localSPMDClient;
        }

        /**
         * (empty constructors are important for deserialization)
         * 
         * @see #AbstractDataHandler(int, ClientDataServer, Rectangle, Rectangle)
         */
        public AbstractDataHandler() {
                this(-1, null, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, 0, 0));
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataLoader#getLoadInfo()
         */
        public abstract String getLoadInfo();

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataLoader#getLoadInfo()
         */
        public abstract String getUnloadInfo();

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataLoader#load()
         */
        public abstract DataPartition load() throws LoadingException;

        /**
         * Initializes the {@link Logger} after deserialization (used by
         * {@link java.io.Serializable})
         * 
         * @throws IOException
         * @see Serializable
         */
        private synchronized void readObject(java.io.ObjectInputStream s)
                        throws IOException, ClassNotFoundException {
                // reading standard fields
                s.defaultReadObject();
                // initialize Logger
                LOG = LogManager.getLogger(this.getClass().getName());
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.PartitionDataHandler#setUnloadPartition(java.awt.Rectangle)
         */
        public void setUnloadBounds(Rectangle unloadBounds) {
                this.unloadBounds = unloadBounds;
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.PartitionDataHandler#setBasePartition(appl.parallel.spmd.split.DataPartition)
         */
        public void setBasePartition(DataPartition data) {
                this.data = data;
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataUnloader#unload()
         */
        public abstract void unload();

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.PartitionDataHandler#setRootID(int)
         */
        public void setRootID(int rootID) {
                this.rootID = rootID;
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#clone()
         */
        public PartitionDataHandler clone() {
                return newInstance(rootID, spmdClient, this.unloadBounds,
                                this.partitionBounds);
        }

}
1	package appl.parallel.data;
2
3	import java.awt.Rectangle;
4	import java.io.IOException;
5	import java.io.Serializable;
6
7	import org.apache.log4j.LogManager;
8	import org.apache.log4j.Logger;
9
10	import appl.data.LoadingException;
11	import appl.parallel.client.ClientDataServer;
12	import appl.parallel.spmd.split.DataPartition;
13	import appl.parallel.spmd.split.SplittableResource;
14
15	/**
16	* This class is used as a base class for loaders. It is especially intended for
17	* use with the SPMD-Paradigm, but may be used with other loaders, too. It
18	* implements the reusable stuff of the {@link PartitionDataHandler} Interface.
19	* Notice that each loader is responsible for exactly one data element. It must
20	* be {@link Cloneable}, so that multi-data elements can add another element.
21	*
22	* @author Dominik Appl
23	*/
24	public abstract class AbstractDataHandler implements PartitionDataHandler {
25
26	protected transient Logger LOG = LogManager.getLogger(this.getClass()
27	.getName());
28
29	/**
30	* The id of the currently handled {@link SplittableResource}
31	*/
32	protected int rootID;
33
34	/**
35	* The partition bounds (the whole bounds) of the current
36	* {@link SplittableResource}
37	*/
38	protected Rectangle partitionBounds;
39
40	/**
41	* the currently handled data (must be initialized before calling
42	* {@link #unload()}
43	*/
44	protected transient DataPartition data;
45
46	/**
47	* The unload bounds differ may differ from the partitionBounds. If there is
48	* a neighborhood region it is important, that only the core-region (without
49	* the neighborhood) is unloaded.
50	*/
51	protected Rectangle unloadBounds;
52
53	/**
54	* A {@link ClientDataServer} may be used locally for faster access.
55	*/
56	protected transient ClientDataServer spmdClient;
57
58	/**
59	* Constructs a new {@link AbstractDataHandler}. The local IP address at
60	* the time of construction is later used on serverside for communication
61	* (e.g. unloading).
62	*
63	* @param rootID
64	* the id of the data
65	* @param client
66	* a {@link ClientDataServer} which may be used to get meta
67	* information on client side before transferring the loader to
68	* its destination
69	* @param partitionBounds
70	* the bounds of the partition to be retrieved on server side
71	* @param unloadBounds
72	* the bounds of the partition which is to be uploaded to the
73	* client after calculation (may only be the calculation area)
74	*/
75	public AbstractDataHandler(int rootID, ClientDataServer client,
76	Rectangle partitionBounds, Rectangle unloadBounds) {
77	this.spmdClient = client;
78	this.rootID = rootID;
79	this.partitionBounds = partitionBounds;
80	this.unloadBounds = unloadBounds;
81	}
82
83	/**
84	* sets a local {@link ClientDataServer} which MAY be used by the handler
85	* for local access
86	*
87	* @param localSPMDClient
88	*/
89	public void setSPMDClient(ClientDataServer localSPMDClient) {
90	this.spmdClient = localSPMDClient;
91	}
92
93	/**
94	* (empty constructors are important for deserialization)
95	*
96	* @see #AbstractDataHandler(int, ClientDataServer, Rectangle, Rectangle)
97	*/
98	public AbstractDataHandler() {
99	this(-1, null, new Rectangle(0, 0, 0, 0), new Rectangle(0, 0, 0, 0));
100	}
101
102	/*
103	* (non-Javadoc)
104	*
105	* @see appl.data.DataLoader#getLoadInfo()
106	*/
107	public abstract String getLoadInfo();
108
109	/*
110	* (non-Javadoc)
111	*
112	* @see appl.data.DataLoader#getLoadInfo()
113	*/
114	public abstract String getUnloadInfo();
115
116	/*
117	* (non-Javadoc)
118	*
119	* @see appl.data.DataLoader#load()
120	*/
121	public abstract DataPartition load() throws LoadingException;
122
123	/**
124	* Initializes the {@link Logger} after deserialization (used by
125	* {@link java.io.Serializable})
126	*
127	* @throws IOException
128	* @see Serializable
129	*/
130	private synchronized void readObject(java.io.ObjectInputStream s)
131	throws IOException, ClassNotFoundException {
132	// reading standard fields
133	s.defaultReadObject();
134	// initialize Logger
135	LOG = LogManager.getLogger(this.getClass().getName());
136	}
137
138	/*
139	* (non-Javadoc)
140	*
141	* @see appl.data.PartitionDataHandler#setUnloadPartition(java.awt.Rectangle)
142	*/
143	public void setUnloadBounds(Rectangle unloadBounds) {
144	this.unloadBounds = unloadBounds;
145	}
146
147	/*
148	* (non-Javadoc)
149	*
150	* @see appl.data.PartitionDataHandler#setBasePartition(appl.parallel.spmd.split.DataPartition)
151	*/
152	public void setBasePartition(DataPartition data) {
153	this.data = data;
154	}
155
156	/*
157	* (non-Javadoc)
158	*
159	* @see appl.data.DataUnloader#unload()
160	*/
161	public abstract void unload();
162
163	/*
164	* (non-Javadoc)
165	*
166	* @see appl.data.PartitionDataHandler#setRootID(int)
167	*/
168	public void setRootID(int rootID) {
169	this.rootID = rootID;
170	}
171
172	/*
173	* (non-Javadoc)
174	*
175	* @see java.lang.Object#clone()
176	*/
177	public PartitionDataHandler clone() {
178	return newInstance(rootID, spmdClient, this.unloadBounds,
179	this.partitionBounds);
180	}
181
182	}