parallel/spmd/AdvancedSPMDClientInterface.java

package appl.parallel.spmd;

import java.io.PrintStream;

/**
 * This class extends the {@link SPMDClientInterface} with additional features for performance tuning. You can merge
 * partitions in background (so that the not very cpu-intensive communication can
 * happen during extensive calculations). <br>
 * 
 * @author Dominik Appl
 */
public interface AdvancedSPMDClientInterface extends SPMDClientInterface {

        /**
         * Merges like {@link SPMDClientController#mergePartition(int)}, but in a
         * separate thread, so that communication does not block computation. See
         * also {@link SyncPoint synchronization points}
         * 
         * @param partition
         *            the partition to be merged (must be splittable)
         * @param s
         *            a syncpoint
         */
        public void mergePartition(Object partition, SyncPoint s);

        /**
         * Merges like
         * {@link SPMDClientController#mergeMultiData(MultiDataObject, int)}. But
         * allows also {@link SyncPoint synchronization points}
         * 
         * @param multidata
         *            the multidataobject
         * @param idx
         *            the partition of the {@link MultiDataObject} to be merged
         * @param s
         *            a {@link SyncPoint}
         */
        public void mergeMultiData(MultiDataObject multidata, int idx, SyncPoint s);

        /**
         * Same functionality as {@link #mergePartition(Object, SyncPoint)}, gives
         * a message to the given {@link PrintStream}
         * 
         * @param partition
         *            the partition to merge
         * @param s
         *            a {@link SyncPoint}
         * @param stream
         *            the message is given out to this stream (or null for no
         *            message)
         * @param message
         *            the message to be displayed when finished (or null for no
         *            message)
         * @see #mergeMultiData(MultiDataObject, int, SyncPoint)
         */
        public void mergePartition(Object partition, SyncPoint s,
                        PrintStream stream, String message);

        /**
         * Merges like
         * {@link SPMDClientController#mergeMultiData(MultiDataObject, int)}. But
         * allows also {@link SyncPoint synchronization points}. At the end of the
         * merge a message is given to the provided {@link PrintStream}.
         * 
         * @param multidata
         *            the multidataobject
         * @param idx
         *            the partition of the {@link MultiDataObject} to be merged
         * @param s
         *            a {@link SyncPoint}
         * @param stream
         *            the message is given out to this stream (or null for no
         *            message)
         * @param message
         *            the message to be diplayed when finished (or null for no
         *            message)
         */
        public void mergeMultiData(MultiDataObject multidata, int idx, SyncPoint s,
                        PrintStream stream, String message);

        /**
         * Waits until the Thread with the specified SyncPoint finishes. After that
         * the Thread is removed. A second thread which synchronizes to the same
         * Point will directly continue.
         * 
         * @param s
         *            the {@link SyncPoint}
         * @throws UnsupportedOperationException
         *             if the SyncPoint does not exist and has never existed
         */
        public void synchronizeToSyncPoint(SyncPoint s);

}
1	package appl.parallel.spmd;
2
3	import java.io.PrintStream;
4
5	/**
6	* This class extends the {@link SPMDClientInterface} with additional features for performance tuning. You can merge
7	* partitions in background (so that the not very cpu-intensive communication can
8	* happen during extensive calculations). <br>
9	*
10	* @author Dominik Appl
11	*/
12	public interface AdvancedSPMDClientInterface extends SPMDClientInterface {
13
14	/**
15	* Merges like {@link SPMDClientController#mergePartition(int)}, but in a
16	* separate thread, so that communication does not block computation. See
17	* also {@link SyncPoint synchronization points}
18	*
19	* @param partition
20	* the partition to be merged (must be splittable)
21	* @param s
22	* a syncpoint
23	*/
24	public void mergePartition(Object partition, SyncPoint s);
25
26	/**
27	* Merges like
28	* {@link SPMDClientController#mergeMultiData(MultiDataObject, int)}. But
29	* allows also {@link SyncPoint synchronization points}
30	*
31	* @param multidata
32	* the multidataobject
33	* @param idx
34	* the partition of the {@link MultiDataObject} to be merged
35	* @param s
36	* a {@link SyncPoint}
37	*/
38	public void mergeMultiData(MultiDataObject multidata, int idx, SyncPoint s);
39
40	/**
41	* Same functionality as {@link #mergePartition(Object, SyncPoint)}, gives
42	* a message to the given {@link PrintStream}
43	*
44	* @param partition
45	* the partition to merge
46	* @param s
47	* a {@link SyncPoint}
48	* @param stream
49	* the message is given out to this stream (or null for no
50	* message)
51	* @param message
52	* the message to be displayed when finished (or null for no
53	* message)
54	* @see #mergeMultiData(MultiDataObject, int, SyncPoint)
55	*/
56	public void mergePartition(Object partition, SyncPoint s,
57	PrintStream stream, String message);
58
59	/**
60	* Merges like
61	* {@link SPMDClientController#mergeMultiData(MultiDataObject, int)}. But
62	* allows also {@link SyncPoint synchronization points}. At the end of the
63	* merge a message is given to the provided {@link PrintStream}.
64	*
65	* @param multidata
66	* the multidataobject
67	* @param idx
68	* the partition of the {@link MultiDataObject} to be merged
69	* @param s
70	* a {@link SyncPoint}
71	* @param stream
72	* the message is given out to this stream (or null for no
73	* message)
74	* @param message
75	* the message to be diplayed when finished (or null for no
76	* message)
77	*/
78	public void mergeMultiData(MultiDataObject multidata, int idx, SyncPoint s,
79	PrintStream stream, String message);
80
81	/**
82	* Waits until the Thread with the specified SyncPoint finishes. After that
83	* the Thread is removed. A second thread which synchronizes to the same
84	* Point will directly continue.
85	*
86	* @param s
87	* the {@link SyncPoint}
88	* @throws UnsupportedOperationException
89	* if the SyncPoint does not exist and has never existed
90	*/
91	public void synchronizeToSyncPoint(SyncPoint s);
92
93	}