parallel/event/TransferEvent.java

/**
 * 
 */
package appl.parallel.event;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * A TransferEvent is event which is associated with the size of a data transfer
 * in bytes. It is measured by serializing the data into byte stream. This is
 * very slow! So use this events carefully. You should check if monitoring for
 * this event type is enabled, before generating it! See {@link CommEventSink}
 * for details.
 * 
 * @author Dominik Appl
 */
public class TransferEvent extends CommEvent {

        int size = 0;

        /**
         * @param src
         *            the source of the event
         * @param target
         *            the target of the event
         * @param type
         *            the type of the event
         * @param toTransferObjects
         *            the objects transfered (Warning: the size will be measured by
         *            serializing the object. This is slow!)
         * @see #getObjectSize(Object)
         */
        public TransferEvent(String src, String target, CommType type,
                        Object... toTransferObjects) {
                super(src, target, type);
                for (Object object : toTransferObjects) {
                        size += getObjectSize(object);
                }
        }

        /**
         * Determines the object size in a very primitive way (serializing to a byte
         * array and returning the byteSize) I do not have to mention here
         * explicitly that this is slow, do I? There is no real alternative, because
         * in java exists. no function like <code>sizeOf</code> in C++
         * 
         * @param object
         *            a {@link Serializable} object
         * @return the size in bytes
         */
        protected int getObjectSize(Object object) {
                if (object == null)
                        return 0;

                byte[] byteArray = null;
                try {
                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
                        ObjectOutputStream oos = new ObjectOutputStream(baos);
                        oos.writeObject(object);
                        oos.close();
                        byteArray = baos.toByteArray();
                        baos.close();
                } catch (IOException e) {
                        e.printStackTrace();
                        return 0;
                }
                return byteArray.length;
        }

        public int getSize() {
                return size;
        }

        public String toString() {
                StringBuffer returnString = new StringBuffer();
                returnString.append(type.toString());
                returnString.append(" Transfer size: ").append(size).append(" bytes");
                if (!src.equals(""))
                        returnString.append(" source: ").append(src);
                if (!target.equals(""))
                        returnString.append(" target: ").append(target);

                return returnString.toString();
        }

}
1	mojays	2	/**
2			*
3			*/
4			package appl.parallel.event;
5
6			import java.io.ByteArrayOutputStream;
7			import java.io.IOException;
8			import java.io.ObjectOutputStream;
9			import java.io.Serializable;
10
11			/**
12			* A TransferEvent is event which is associated with the size of a data transfer
13			* in bytes. It is measured by serializing the data into byte stream. This is
14			* very slow! So use this events carefully. You should check if monitoring for
15			* this event type is enabled, before generating it! See {@link CommEventSink}
16			* for details.
17			*
18			* @author Dominik Appl
19			*/
20			public class TransferEvent extends CommEvent {
21
22			int size = 0;
23
24			/**
25			* @param src
26			* the source of the event
27			* @param target
28			* the target of the event
29			* @param type
30			* the type of the event
31			* @param toTransferObjects
32			* the objects transfered (Warning: the size will be measured by
33			* serializing the object. This is slow!)
34			* @see #getObjectSize(Object)
35			*/
36			public TransferEvent(String src, String target, CommType type,
37			Object... toTransferObjects) {
38			super(src, target, type);
39			for (Object object : toTransferObjects) {
40			size += getObjectSize(object);
41			}
42			}
43
44			/**
45			* Determines the object size in a very primitive way (serializing to a byte
46			* array and returning the byteSize) I do not have to mention here
47			* explicitly that this is slow, do I? There is no real alternative, because
48			* in java exists. no function like <code>sizeOf</code> in C++
49			*
50			* @param object
51			* a {@link Serializable} object
52			* @return the size in bytes
53			*/
54			protected int getObjectSize(Object object) {
55			if (object == null)
56			return 0;
57
58			byte[] byteArray = null;
59			try {
60			ByteArrayOutputStream baos = new ByteArrayOutputStream();
61			ObjectOutputStream oos = new ObjectOutputStream(baos);
62			oos.writeObject(object);
63			oos.close();
64			byteArray = baos.toByteArray();
65			baos.close();
66			} catch (IOException e) {
67			e.printStackTrace();
68			return 0;
69			}
70			return byteArray.length;
71			}
72
73			public int getSize() {
74			return size;
75			}
76
77			public String toString() {
78			StringBuffer returnString = new StringBuffer();
79			returnString.append(type.toString());
80			returnString.append(" Transfer size: ").append(size).append(" bytes");
81			if (!src.equals(""))
82			returnString.append(" source: ").append(src);
83			if (!target.equals(""))
84			returnString.append(" target: ").append(target);
85
86			return returnString.toString();
87			}
88
89			}