data/xulugridfile/XuluGridSharedFileSystemLoader.java

package appl.parallel.data.xulugridfile;

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

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

/**
 * This is a loader for use with shared file systems like ocfs2 or gfs. It only
 * works in conjunction with the {@link XuluWritableGridFile} and supports
 * loading data from and into this file format. That means reading and writing
 * is done directly into the file. The Xulu GUI won't notice changes if you do not
 * reload the XuluWritableGrid!
 * 
 * @see XuluGridFile
 * @see XuluWritableGridFile
 * @see PartitionDataHandler
 * 
 * @author Dominik Appl
 */
public class XuluGridSharedFileSystemLoader extends AbstractDataHandler{
        
        private String gridFileName;
        private transient XuluWritableGridFile xuluWritableGridFile;
        
        /**
         * constructs a new {@link XuluGridSharedFileSystemLoader}. 
         * 
         * @param rootID
         *            the id of the data
         * @param client
         *            a spmd client which may be used to get metainformation on
         *            client side before transfering 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 XuluGridSharedFileSystemLoader(int rootID, ClientDataServer client, Rectangle partitionBounds, Rectangle unloadBounds) {
                super(rootID, client, partitionBounds, unloadBounds);
                DataPartition partition;
                try {
                        partition = client.getData(rootID);
                        if (partition instanceof XuluWritableGridFile) {
                                XuluWritableGridFile xwg = (XuluWritableGridFile) partition;
                                gridFileName = xwg.getGridFileName();
                        }
                        else throw new UnsupportedOperationException("This Dataloader can only be used XuluGridFiles");
                } catch (RemoteException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        
        
        /**
         * only used by {@link #clone()}
         */
        private XuluGridSharedFileSystemLoader(int rootID, ClientDataServer spmdClient, Rectangle partitionBounds, Rectangle unloadBounds, String gridFileName) {
                super(rootID, null, partitionBounds, unloadBounds);
                this.gridFileName=gridFileName;
        }

        /**
         * Used for deserialization. Do not use for other purposes
         */
        public XuluGridSharedFileSystemLoader() {
                super();
        }

        /* (non-Javadoc)
         * @see appl.data.AbstractDataHandler#newInstance(int, appl.parallel.client.SPMDClient, java.awt.Rectangle, java.awt.Rectangle)
         */
        public PartitionDataHandler newInstance(int rootID, ClientDataServer client, Rectangle partitionBounds, Rectangle unloadBounds) {
                // TODO Auto-generated method stub
                return new XuluGridSharedFileSystemLoader(rootID, client, partitionBounds, unloadBounds);
        }
        
        /* (non-Javadoc)
         * @see appl.data.AbstractDataHandler#getLoadInfo()
         */
        @Override
        public String getLoadInfo() {
                return "Trying to load " + gridFileName;
        }

        /* (non-Javadoc)
         * @see appl.data.AbstractDataHandler#getUnloadInfo()
         */
        @Override
        public String getUnloadInfo() {
                return "Trying to unload " + gridFileName;
        }

        /** loads the data directly from the gridfile 
         * @see appl.parallel.data.AbstractDataHandler#load()
         */
        @Override
        public DataPartition load() throws LoadingException {
                //load from the gridfile
                if(xuluWritableGridFile==null)
                        xuluWritableGridFile = new XuluWritableGridFile(new File(gridFileName));
                data =  xuluWritableGridFile.getPartition(partitionBounds);
                return data;
        }

        /** unloads into the file! not into the Xulu-Client or anything!
         */
        @Override
        public void unload() {
                //unload to the local file
                if(xuluWritableGridFile==null)
                        xuluWritableGridFile = new XuluWritableGridFile(new File(gridFileName));
//               construct return grid only if necessary
                DataPartition returnPartition = null;
                if (unloadBounds.equals(data.getPartitionBounds()))
                        returnPartition = data;
                else
                        returnPartition = data.getPartition(unloadBounds);
                xuluWritableGridFile.setPartition(returnPartition, unloadBounds);
        }
        
        public PartitionDataHandler clone() {
                return new XuluGridSharedFileSystemLoader(rootID, spmdClient, this.partitionBounds,
                                this.unloadBounds, this.gridFileName);
        }
}
1	package appl.parallel.data.xulugridfile;
2
3	import java.awt.Rectangle;
4	import java.io.File;
5	import java.rmi.RemoteException;
6
7	import appl.data.LoadingException;
8	import appl.parallel.client.ClientDataServer;
9	import appl.parallel.data.AbstractDataHandler;
10	import appl.parallel.data.PartitionDataHandler;
11	import appl.parallel.spmd.split.DataPartition;
12
13	/**
14	* This is a loader for use with shared file systems like ocfs2 or gfs. It only
15	* works in conjunction with the {@link XuluWritableGridFile} and supports
16	* loading data from and into this file format. That means reading and writing
17	* is done directly into the file. The Xulu GUI won't notice changes if you do not
18	* reload the XuluWritableGrid!
19	*
20	* @see XuluGridFile
21	* @see XuluWritableGridFile
22	* @see PartitionDataHandler
23	*
24	* @author Dominik Appl
25	*/
26	public class XuluGridSharedFileSystemLoader extends AbstractDataHandler{
27
28	private String gridFileName;
29	private transient XuluWritableGridFile xuluWritableGridFile;
30
31	/**
32	* constructs a new {@link XuluGridSharedFileSystemLoader}.
33	*
34	* @param rootID
35	* the id of the data
36	* @param client
37	* a spmd client which may be used to get metainformation on
38	* client side before transfering the loader to its destination
39	* @param partitionBounds
40	* the bounds of the partition to be retrieved on server side
41	* @param unloadBounds
42	* the bounds of the partition which is to be uploaded to the
43	* client after calculation (may only be the calculation area)
44	*/
45	public XuluGridSharedFileSystemLoader(int rootID, ClientDataServer client, Rectangle partitionBounds, Rectangle unloadBounds) {
46	super(rootID, client, partitionBounds, unloadBounds);
47	DataPartition partition;
48	try {
49	partition = client.getData(rootID);
50	if (partition instanceof XuluWritableGridFile) {
51	XuluWritableGridFile xwg = (XuluWritableGridFile) partition;
52	gridFileName = xwg.getGridFileName();
53	}
54	else throw new UnsupportedOperationException("This Dataloader can only be used XuluGridFiles");
55	} catch (RemoteException e) {
56	// TODO Auto-generated catch block
57	e.printStackTrace();
58	}
59	}
60
61
62	/**
63	* only used by {@link #clone()}
64	*/
65	private XuluGridSharedFileSystemLoader(int rootID, ClientDataServer spmdClient, Rectangle partitionBounds, Rectangle unloadBounds, String gridFileName) {
66	super(rootID, null, partitionBounds, unloadBounds);
67	this.gridFileName=gridFileName;
68	}
69
70	/**
71	* Used for deserialization. Do not use for other purposes
72	*/
73	public XuluGridSharedFileSystemLoader() {
74	super();
75	}
76
77	/* (non-Javadoc)
78	* @see appl.data.AbstractDataHandler#newInstance(int, appl.parallel.client.SPMDClient, java.awt.Rectangle, java.awt.Rectangle)
79	*/
80	public PartitionDataHandler newInstance(int rootID, ClientDataServer client, Rectangle partitionBounds, Rectangle unloadBounds) {
81	// TODO Auto-generated method stub
82	return new XuluGridSharedFileSystemLoader(rootID, client, partitionBounds, unloadBounds);
83	}
84
85	/* (non-Javadoc)
86	* @see appl.data.AbstractDataHandler#getLoadInfo()
87	*/
88	@Override
89	public String getLoadInfo() {
90	return "Trying to load " + gridFileName;
91	}
92
93	/* (non-Javadoc)
94	* @see appl.data.AbstractDataHandler#getUnloadInfo()
95	*/
96	@Override
97	public String getUnloadInfo() {
98	return "Trying to unload " + gridFileName;
99	}
100
101	/** loads the data directly from the gridfile
102	* @see appl.parallel.data.AbstractDataHandler#load()
103	*/
104	@Override
105	public DataPartition load() throws LoadingException {
106	//load from the gridfile
107	if(xuluWritableGridFile==null)
108	xuluWritableGridFile = new XuluWritableGridFile(new File(gridFileName));
109	data = xuluWritableGridFile.getPartition(partitionBounds);
110	return data;
111	}
112
113	/** unloads into the file! not into the Xulu-Client or anything!
114	*/
115	@Override
116	public void unload() {
117	//unload to the local file
118	if(xuluWritableGridFile==null)
119	xuluWritableGridFile = new XuluWritableGridFile(new File(gridFileName));
120	// construct return grid only if necessary
121	DataPartition returnPartition = null;
122	if (unloadBounds.equals(data.getPartitionBounds()))
123	returnPartition = data;
124	else
125	returnPartition = data.getPartition(unloadBounds);
126	xuluWritableGridFile.setPartition(returnPartition, unloadBounds);
127	}
128
129	public PartitionDataHandler clone() {
130	return new XuluGridSharedFileSystemLoader(rootID, spmdClient, this.partitionBounds,
131	this.unloadBounds, this.gridFileName);
132	}
133	}