plugin/event/SimpleCommEventMonitorEngine.java

package appl.parallel.plugin.event;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Calendar;
import java.util.Comparator;
import java.util.GregorianCalendar;

import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

import appl.ext.XuluConfig;
import appl.parallel.client.RemoteEventHandler;
import appl.parallel.event.TimeEvent;
import appl.parallel.event.TimeMonitor;
import appl.parallel.event.TransferEvent;
import appl.parallel.event.TransferMonitor;

/**
 * Controls the {@link SimpleCommEventMonitorPlugin}
 * 
 * @author Dominik Appl
 */
public class SimpleCommEventMonitorEngine implements TimeMonitor,
                TransferMonitor, ActionListener {

        private XuluConfig config;

        private boolean timeMonitoring;

        private boolean transferMonitoring;

        private SimpleCommEventMonitor monitor;

        private final RemoteEventHandler eventProxy;

        private DefaultTableModel timeEventModel;

        private DefaultTableModel transferEventModel;

        public SimpleCommEventMonitorEngine(RemoteEventHandler eventProxy) {
                this.eventProxy = eventProxy;
                config = XuluConfig.getXuluConfig();

        }

        /**
         * @return the GUI for the monitor
         */
        public SimpleCommEventMonitor getMonitor() {
                if (monitor == null) {
                        monitor = new SimpleCommEventMonitor(this);
                        initGUI();
                }
                return monitor;
        }

        /**
         * inits the {@link SimpleCommEventMonitor}
         */
        public void initGUI() {
                // get Data from XuluConfig:
                timeMonitoring = config
                                .getBooleanProperty("SimpleCommEventMonitor.timemonitoring");
                transferMonitoring = config
                                .getBooleanProperty("SimpleCommEventMonitor.transfermonitoring");
                // registers itself as timeEvent receiver
                if (timeMonitoring)
                        eventProxy.addTimeEventListener(this);
                if (transferMonitoring)
                        eventProxy.addTransferEventListener(this);
                initTimeEventTable();
                initTransferEventTable();
                monitor.timeEventEnabled.setSelected(timeMonitoring);
                monitor.transferEventEnabled.setSelected(transferMonitoring);
        }

        /**
         * 
         */
        private void initTimeEventTable() {
                JTable table = monitor.timeEventTable;

                timeEventModel = new DefaultTableModel(
                                new Object[] { "Receive Time", "Event type", "Event Source",
                                                "Event target", "Exec time (ms)" }, 0);
                TableRowSorter sorter = new TableRowSorter<TableModel>(timeEventModel);
                sorter.setComparator(4, LONG_COMPARATOR);
                table.setModel(timeEventModel);
                table.setRowSorter(sorter);

        }

        private void initTransferEventTable() {
                JTable table = monitor.transferEventTable;
                transferEventModel = new DefaultTableModel(new Object[] {
                                "Receive Time", "Event type", "Event Source", "Event target",
                                "Size (kb)" }, 0);
                TableRowSorter sorter = new TableRowSorter(transferEventModel);
                sorter.setComparator(4, LONG_COMPARATOR);
                table.setModel(transferEventModel);
                table.setRowSorter(sorter);
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.parallel.event.TimeMonitor#receiveTimeEvent(appl.parallel.event.TimeEvent)
         */
        public synchronized void receiveTimeEvent(TimeEvent t) {
                timeEventModel.addRow(new Object[] { getCurrentTimeString(),
                                t.getType(), t.getSrc(), t.getTarget(),
                                (long) (t.getTime() / 1000000) });
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.parallel.event.TransferMonitor#receiveTransferEvent(appl.parallel.event.TransferEvent)
         */
        public void receiveTransferEvent(TransferEvent t) {
                transferEventModel.addRow(new Object[] { getCurrentTimeString(),
                                t.getType(), t.getSrc(), t.getTarget(),
                                (long) (t.getSize() / 1024) });
        }

        public String getCurrentTimeString() {
                Calendar cal = new GregorianCalendar();
                String hour = String.valueOf(cal.get(Calendar.HOUR_OF_DAY));
                while (hour.length() < 2)
                        hour = "0" + hour;
                String min = String.valueOf(cal.get(Calendar.MINUTE));
                while (min.length() < 2)
                        min = "0" + min;
                String sec = String.valueOf(cal.get(Calendar.SECOND));
                while (sec.length() < 2)
                        sec = "0" + sec;
                String ms = String.valueOf(cal.get(Calendar.MILLISECOND));
                while (ms.length() < 3)
                        ms = "0" + ms;
                String time = hour + ":" + min + ":" + sec + ":" + ms;
                return time;
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
         */
        public void actionPerformed(ActionEvent e) {
                Object src = e.getSource();
                if (src == monitor.transferEventEnabled) {
                        eventProxy.removeTransferMonitor(this);
                        if (monitor.transferEventEnabled.isSelected()) {
                                eventProxy.addTransferEventListener(this);
                                config.setBooleanProperty(
                                                "SimpleCommEventMonitor.transfermonitoring", true);
                        } else
                                config.setBooleanProperty(
                                                "SimpleCommEventMonitor.transfermonitoring", false);
                }
                if (src == monitor.timeEventEnabled) {
                        eventProxy.removeTimeMonitor(this);
                        if (monitor.timeEventEnabled.isSelected()) {
                                eventProxy.addTimeEventListener(this);
                                config.setBooleanProperty(
                                                "SimpleCommEventMonitor.timemonitoring", true);
                        } else
                                config.setBooleanProperty(
                                                "SimpleCommEventMonitor.timemonitoring", false);
                }
                if (src == monitor.clearButton) {
                        initTimeEventTable();
                        initTransferEventTable();
                }
        }

        /**
         * stops the execution
         */
        public void stop() {
                eventProxy.removeTimeMonitor(this);
                eventProxy.removeTransferMonitor(this);
        }

        /**
         * The comparator is used for sorting the values in the {@link JTable}
         */
        public static final Comparator LONG_COMPARATOR = new Comparator() {
                public int compare(Object o1, Object o2) {
                        return ((Long) o1).compareTo((Long) o2);
                }
        };

}
1	package appl.parallel.plugin.event;
2
3	import java.awt.event.ActionEvent;
4	import java.awt.event.ActionListener;
5	import java.util.Calendar;
6	import java.util.Comparator;
7	import java.util.GregorianCalendar;
8
9	import javax.swing.JTable;
10	import javax.swing.table.DefaultTableModel;
11	import javax.swing.table.TableModel;
12	import javax.swing.table.TableRowSorter;
13
14	import appl.ext.XuluConfig;
15	import appl.parallel.client.RemoteEventHandler;
16	import appl.parallel.event.TimeEvent;
17	import appl.parallel.event.TimeMonitor;
18	import appl.parallel.event.TransferEvent;
19	import appl.parallel.event.TransferMonitor;
20
21	/**
22	* Controls the {@link SimpleCommEventMonitorPlugin}
23	*
24	* @author Dominik Appl
25	*/
26	public class SimpleCommEventMonitorEngine implements TimeMonitor,
27	TransferMonitor, ActionListener {
28
29	private XuluConfig config;
30
31	private boolean timeMonitoring;
32
33	private boolean transferMonitoring;
34
35	private SimpleCommEventMonitor monitor;
36
37	private final RemoteEventHandler eventProxy;
38
39	private DefaultTableModel timeEventModel;
40
41	private DefaultTableModel transferEventModel;
42
43	public SimpleCommEventMonitorEngine(RemoteEventHandler eventProxy) {
44	this.eventProxy = eventProxy;
45	config = XuluConfig.getXuluConfig();
46
47	}
48
49	/**
50	* @return the GUI for the monitor
51	*/
52	public SimpleCommEventMonitor getMonitor() {
53	if (monitor == null) {
54	monitor = new SimpleCommEventMonitor(this);
55	initGUI();
56	}
57	return monitor;
58	}
59
60	/**
61	* inits the {@link SimpleCommEventMonitor}
62	*/
63	public void initGUI() {
64	// get Data from XuluConfig:
65	timeMonitoring = config
66	.getBooleanProperty("SimpleCommEventMonitor.timemonitoring");
67	transferMonitoring = config
68	.getBooleanProperty("SimpleCommEventMonitor.transfermonitoring");
69	// registers itself as timeEvent receiver
70	if (timeMonitoring)
71	eventProxy.addTimeEventListener(this);
72	if (transferMonitoring)
73	eventProxy.addTransferEventListener(this);
74	initTimeEventTable();
75	initTransferEventTable();
76	monitor.timeEventEnabled.setSelected(timeMonitoring);
77	monitor.transferEventEnabled.setSelected(transferMonitoring);
78	}
79
80	/**
81	*
82	*/
83	private void initTimeEventTable() {
84	JTable table = monitor.timeEventTable;
85
86	timeEventModel = new DefaultTableModel(
87	new Object[] { "Receive Time", "Event type", "Event Source",
88	"Event target", "Exec time (ms)" }, 0);
89	TableRowSorter sorter = new TableRowSorter<TableModel>(timeEventModel);
90	sorter.setComparator(4, LONG_COMPARATOR);
91	table.setModel(timeEventModel);
92	table.setRowSorter(sorter);
93
94	}
95
96	private void initTransferEventTable() {
97	JTable table = monitor.transferEventTable;
98	transferEventModel = new DefaultTableModel(new Object[] {
99	"Receive Time", "Event type", "Event Source", "Event target",
100	"Size (kb)" }, 0);
101	TableRowSorter sorter = new TableRowSorter(transferEventModel);
102	sorter.setComparator(4, LONG_COMPARATOR);
103	table.setModel(transferEventModel);
104	table.setRowSorter(sorter);
105	}
106
107	/*
108	* (non-Javadoc)
109	*
110	* @see appl.parallel.event.TimeMonitor#receiveTimeEvent(appl.parallel.event.TimeEvent)
111	*/
112	public synchronized void receiveTimeEvent(TimeEvent t) {
113	timeEventModel.addRow(new Object[] { getCurrentTimeString(),
114	t.getType(), t.getSrc(), t.getTarget(),
115	(long) (t.getTime() / 1000000) });
116	}
117
118	/*
119	* (non-Javadoc)
120	*
121	* @see appl.parallel.event.TransferMonitor#receiveTransferEvent(appl.parallel.event.TransferEvent)
122	*/
123	public void receiveTransferEvent(TransferEvent t) {
124	transferEventModel.addRow(new Object[] { getCurrentTimeString(),
125	t.getType(), t.getSrc(), t.getTarget(),
126	(long) (t.getSize() / 1024) });
127	}
128
129	public String getCurrentTimeString() {
130	Calendar cal = new GregorianCalendar();
131	String hour = String.valueOf(cal.get(Calendar.HOUR_OF_DAY));
132	while (hour.length() < 2)
133	hour = "0" + hour;
134	String min = String.valueOf(cal.get(Calendar.MINUTE));
135	while (min.length() < 2)
136	min = "0" + min;
137	String sec = String.valueOf(cal.get(Calendar.SECOND));
138	while (sec.length() < 2)
139	sec = "0" + sec;
140	String ms = String.valueOf(cal.get(Calendar.MILLISECOND));
141	while (ms.length() < 3)
142	ms = "0" + ms;
143	String time = hour + ":" + min + ":" + sec + ":" + ms;
144	return time;
145	}
146
147	/*
148	* (non-Javadoc)
149	*
150	* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
151	*/
152	public void actionPerformed(ActionEvent e) {
153	Object src = e.getSource();
154	if (src == monitor.transferEventEnabled) {
155	eventProxy.removeTransferMonitor(this);
156	if (monitor.transferEventEnabled.isSelected()) {
157	eventProxy.addTransferEventListener(this);
158	config.setBooleanProperty(
159	"SimpleCommEventMonitor.transfermonitoring", true);
160	} else
161	config.setBooleanProperty(
162	"SimpleCommEventMonitor.transfermonitoring", false);
163	}
164	if (src == monitor.timeEventEnabled) {
165	eventProxy.removeTimeMonitor(this);
166	if (monitor.timeEventEnabled.isSelected()) {
167	eventProxy.addTimeEventListener(this);
168	config.setBooleanProperty(
169	"SimpleCommEventMonitor.timemonitoring", true);
170	} else
171	config.setBooleanProperty(
172	"SimpleCommEventMonitor.timemonitoring", false);
173	}
174	if (src == monitor.clearButton) {
175	initTimeEventTable();
176	initTransferEventTable();
177	}
178	}
179
180	/**
181	* stops the execution
182	*/
183	public void stop() {
184	eventProxy.removeTimeMonitor(this);
185	eventProxy.removeTransferMonitor(this);
186	}
187
188	/**
189	* The comparator is used for sorting the values in the {@link JTable}
190	*/
191	public static final Comparator LONG_COMPARATOR = new Comparator() {
192	public int compare(Object o1, Object o2) {
193	return ((Long) o1).compareTo((Long) o2);
194	}
195	};
196
197	}