Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/HSDB.java @ 210:05712c37c828
6676016: ParallelOldGC leaks memory
Summary: ensure that GCTask threads release resource and handle memory
Reviewed-by: jmasa, chrisphi
author | jcoomes |
---|---|
date | Wed, 18 Jun 2008 18:36:47 -0700 |
parents | 5bba3366a9a2 |
children | d1605aabd0a1 |
rev | line source |
---|---|
0 | 1 /* |
2 * Copyright 2000-2006 Sun Microsystems, Inc. All Rights Reserved. | |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
21 * have any questions. | |
22 * | |
23 */ | |
24 | |
25 package sun.jvm.hotspot; | |
26 | |
27 import java.io.*; | |
28 import java.awt.*; | |
29 import java.awt.event.*; | |
30 import java.math.*; | |
31 import javax.swing.*; | |
32 import javax.swing.tree.*; | |
33 import java.util.*; | |
34 | |
35 import sun.jvm.hotspot.code.*; | |
36 import sun.jvm.hotspot.compiler.*; | |
37 import sun.jvm.hotspot.debugger.*; | |
38 import sun.jvm.hotspot.gc_implementation.parallelScavenge.*; | |
39 import sun.jvm.hotspot.gc_interface.*; | |
40 import sun.jvm.hotspot.interpreter.*; | |
41 import sun.jvm.hotspot.memory.*; | |
42 import sun.jvm.hotspot.oops.*; | |
43 import sun.jvm.hotspot.runtime.*; | |
44 import sun.jvm.hotspot.ui.*; | |
45 import sun.jvm.hotspot.ui.tree.*; | |
46 import sun.jvm.hotspot.ui.classbrowser.*; | |
47 import sun.jvm.hotspot.utilities.*; | |
48 | |
49 /** The top-level HotSpot Debugger. FIXME: make this an embeddable | |
50 component! (Among other things, figure out what to do with the | |
51 menu bar...) */ | |
52 | |
53 public class HSDB implements ObjectHistogramPanel.Listener, SAListener { | |
54 public static void main(String[] args) { | |
55 new HSDB(args).run(); | |
56 } | |
57 | |
58 //-------------------------------------------------------------------------------- | |
59 // Internals only below this point | |
60 // | |
61 private HotSpotAgent agent; | |
62 private JDesktopPane desktop; | |
63 private boolean attached; | |
64 /** List <JMenuItem> */ | |
65 private java.util.List attachMenuItems; | |
66 /** List <JMenuItem> */ | |
67 private java.util.List detachMenuItems; | |
68 private JMenu toolsMenu; | |
69 private JMenuItem showDbgConsoleMenuItem; | |
70 private JMenuItem computeRevPtrsMenuItem; | |
71 private JInternalFrame attachWaitDialog; | |
72 private JInternalFrame threadsFrame; | |
73 private JInternalFrame consoleFrame; | |
74 private WorkerThread workerThread; | |
75 // These had to be made data members because they are referenced in inner classes. | |
76 private String pidText; | |
77 private int pid; | |
78 private String execPath; | |
79 private String coreFilename; | |
80 | |
81 private void doUsage() { | |
82 System.out.println("Usage: java HSDB [[pid] | [path-to-java-executable [path-to-corefile]] | help ]"); | |
83 System.out.println(" pid: attach to the process whose id is 'pid'"); | |
84 System.out.println(" path-to-java-executable: Debug a core file produced by this program"); | |
85 System.out.println(" path-to-corefile: Debug this corefile. The default is 'core'"); | |
86 System.out.println(" If no arguments are specified, you can select what to do from the GUI.\n"); | |
87 HotSpotAgent.showUsage(); | |
88 } | |
89 | |
90 private HSDB(String[] args) { | |
91 switch (args.length) { | |
92 case (0): | |
93 break; | |
94 | |
95 case (1): | |
96 if (args[0].equals("help") || args[0].equals("-help")) { | |
97 doUsage(); | |
98 System.exit(0); | |
99 } | |
100 // If all numbers, it is a PID to attach to | |
101 // Else, it is a pathname to a .../bin/java for a core file. | |
102 try { | |
103 int unused = Integer.parseInt(args[0]); | |
104 // If we get here, we have a PID and not a core file name | |
105 pidText = args[0]; | |
106 } catch (NumberFormatException e) { | |
107 execPath = args[0]; | |
108 coreFilename = "core"; | |
109 } | |
110 break; | |
111 | |
112 case (2): | |
113 execPath = args[0]; | |
114 coreFilename = args[1]; | |
115 break; | |
116 | |
117 default: | |
118 System.out.println("HSDB Error: Too many options specified"); | |
119 doUsage(); | |
120 System.exit(1); | |
121 } | |
122 } | |
123 | |
124 private void run() { | |
125 // At this point, if pidText != null we are supposed to attach to it. | |
126 // Else, if execPath != null, it is the path of a jdk/bin/java | |
127 // and coreFilename is the pathname of a core file we are | |
128 // supposed to attach to. | |
129 | |
130 agent = new HotSpotAgent(); | |
131 workerThread = new WorkerThread(); | |
132 attachMenuItems = new java.util.ArrayList(); | |
133 detachMenuItems = new java.util.ArrayList(); | |
134 | |
135 JFrame frame = new JFrame("HSDB - HotSpot Debugger"); | |
136 frame.setSize(800, 600); | |
137 frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); | |
138 | |
139 JMenuBar menuBar = new JMenuBar(); | |
140 | |
141 // | |
142 // File menu | |
143 // | |
144 | |
145 JMenu menu = new JMenu("File"); | |
146 menu.setMnemonic(KeyEvent.VK_F); | |
147 JMenuItem item; | |
148 item = createMenuItem("Attach to HotSpot process...", | |
149 new ActionListener() { | |
150 public void actionPerformed(ActionEvent e) { | |
151 showAttachDialog(); | |
152 } | |
153 }); | |
154 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, ActionEvent.ALT_MASK)); | |
155 item.setMnemonic(KeyEvent.VK_A); | |
156 menu.add(item); | |
157 attachMenuItems.add(item); | |
158 | |
159 item = createMenuItem("Open HotSpot core file...", | |
160 new ActionListener() { | |
161 public void actionPerformed(ActionEvent e) { | |
162 showOpenCoreFileDialog(); | |
163 } | |
164 }); | |
165 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.ALT_MASK)); | |
166 item.setMnemonic(KeyEvent.VK_O); | |
167 menu.add(item); | |
168 attachMenuItems.add(item); | |
169 | |
170 item = createMenuItem("Connect to debug server...", | |
171 new ActionListener() { | |
172 public void actionPerformed(ActionEvent e) { | |
173 showConnectDialog(); | |
174 } | |
175 }); | |
176 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.ALT_MASK)); | |
177 item.setMnemonic(KeyEvent.VK_S); | |
178 menu.add(item); | |
179 attachMenuItems.add(item); | |
180 | |
181 item = createMenuItem("Detach", | |
182 new ActionListener() { | |
183 public void actionPerformed(ActionEvent e) { | |
184 detach(); | |
185 } | |
186 }); | |
187 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D, ActionEvent.ALT_MASK)); | |
188 item.setMnemonic(KeyEvent.VK_S); | |
189 menu.add(item); | |
190 detachMenuItems.add(item); | |
191 | |
192 // Disable detach menu items at first | |
193 setMenuItemsEnabled(detachMenuItems, false); | |
194 | |
195 menu.addSeparator(); | |
196 | |
197 item = createMenuItem("Exit", | |
198 new ActionListener() { | |
199 public void actionPerformed(ActionEvent e) { | |
200 System.exit(0); | |
201 } | |
202 }); | |
203 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, ActionEvent.ALT_MASK)); | |
204 item.setMnemonic(KeyEvent.VK_X); | |
205 menu.add(item); | |
206 menuBar.add(menu); | |
207 | |
208 // | |
209 // Tools menu | |
210 // | |
211 | |
212 toolsMenu = new JMenu("Tools"); | |
213 toolsMenu.setMnemonic(KeyEvent.VK_T); | |
214 | |
215 item = createMenuItem("Class Browser", | |
216 new ActionListener() { | |
217 public void actionPerformed(ActionEvent e) { | |
218 showClassBrowser(); | |
219 } | |
220 }); | |
221 item.setMnemonic(KeyEvent.VK_B); | |
222 | |
223 toolsMenu.add(item); | |
224 | |
225 item = createMenuItem("Code Viewer", | |
226 new ActionListener() { | |
227 public void actionPerformed(ActionEvent e) { | |
228 showCodeViewer(); | |
229 } | |
230 }); | |
231 item.setMnemonic(KeyEvent.VK_C); | |
232 | |
233 toolsMenu.add(item); | |
234 | |
235 | |
236 item = createMenuItem("Compute Reverse Ptrs", | |
237 new ActionListener() { | |
238 public void actionPerformed(ActionEvent e) { | |
239 fireComputeReversePtrs(); | |
240 } | |
241 }); | |
242 computeRevPtrsMenuItem = item; | |
243 item.setMnemonic(KeyEvent.VK_M); | |
244 toolsMenu.add(item); | |
245 | |
246 item = createMenuItem("Deadlock Detection", | |
247 new ActionListener() { | |
248 public void actionPerformed(ActionEvent e) { | |
249 showDeadlockDetectionPanel(); | |
250 } | |
251 }); | |
252 item.setMnemonic(KeyEvent.VK_D); | |
253 toolsMenu.add(item); | |
254 | |
255 item = createMenuItem("Find Object by Query", | |
256 new ActionListener() { | |
257 public void actionPerformed(ActionEvent e) { | |
258 showFindByQueryPanel(); | |
259 } | |
260 }); | |
261 item.setMnemonic(KeyEvent.VK_Q); | |
262 toolsMenu.add(item); | |
263 | |
264 | |
265 item = createMenuItem("Find Pointer", | |
266 new ActionListener() { | |
267 public void actionPerformed(ActionEvent e) { | |
268 showFindPanel(); | |
269 } | |
270 }); | |
271 item.setMnemonic(KeyEvent.VK_P); | |
272 toolsMenu.add(item); | |
273 | |
274 item = createMenuItem("Find Value In Heap", | |
275 new ActionListener() { | |
276 public void actionPerformed(ActionEvent e) { | |
277 showFindInHeapPanel(); | |
278 } | |
279 }); | |
280 item.setMnemonic(KeyEvent.VK_V); | |
281 toolsMenu.add(item); | |
282 | |
283 item = createMenuItem("Find Value In Code Cache", | |
284 new ActionListener() { | |
285 public void actionPerformed(ActionEvent e) { | |
286 showFindInCodeCachePanel(); | |
287 } | |
288 }); | |
289 item.setMnemonic(KeyEvent.VK_A); | |
290 toolsMenu.add(item); | |
291 | |
292 item = createMenuItem("Heap Parameters", | |
293 new ActionListener() { | |
294 public void actionPerformed(ActionEvent e) { | |
295 showHeapParametersPanel(); | |
296 } | |
297 }); | |
298 item.setMnemonic(KeyEvent.VK_H); | |
299 toolsMenu.add(item); | |
300 | |
301 item = createMenuItem("Inspector", | |
302 new ActionListener() { | |
303 public void actionPerformed(ActionEvent e) { | |
304 showInspector(null); | |
305 } | |
306 }); | |
307 item.setMnemonic(KeyEvent.VK_R); | |
308 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, ActionEvent.ALT_MASK)); | |
309 toolsMenu.add(item); | |
310 | |
311 item = createMenuItem("Memory Viewer", | |
312 new ActionListener() { | |
313 public void actionPerformed(ActionEvent e) { | |
314 showMemoryViewer(); | |
315 } | |
316 }); | |
317 item.setMnemonic(KeyEvent.VK_M); | |
318 toolsMenu.add(item); | |
319 | |
320 item = createMenuItem("Monitor Cache Dump", | |
321 new ActionListener() { | |
322 public void actionPerformed(ActionEvent e) { | |
323 showMonitorCacheDumpPanel(); | |
324 } | |
325 }); | |
326 item.setMnemonic(KeyEvent.VK_D); | |
327 toolsMenu.add(item); | |
328 | |
329 item = createMenuItem("Object Histogram", | |
330 new ActionListener() { | |
331 public void actionPerformed(ActionEvent e) { | |
332 showObjectHistogram(); | |
333 } | |
334 }); | |
335 item.setMnemonic(KeyEvent.VK_O); | |
336 toolsMenu.add(item); | |
337 | |
338 item = createMenuItem("Show System Properties", | |
339 new ActionListener() { | |
340 public void actionPerformed(ActionEvent e) { | |
341 showSystemProperties(); | |
342 } | |
343 }); | |
344 item.setMnemonic(KeyEvent.VK_S); | |
345 toolsMenu.add(item); | |
346 | |
347 item = createMenuItem("Show VM Version", | |
348 new ActionListener() { | |
349 public void actionPerformed(ActionEvent e) { | |
350 showVMVersion(); | |
351 } | |
352 }); | |
353 item.setMnemonic(KeyEvent.VK_M); | |
354 toolsMenu.add(item); | |
355 | |
356 item = createMenuItem("Show -XX flags", | |
357 new ActionListener() { | |
358 public void actionPerformed(ActionEvent e) { | |
359 showCommandLineFlags(); | |
360 } | |
361 }); | |
362 item.setMnemonic(KeyEvent.VK_X); | |
363 toolsMenu.add(item); | |
364 | |
365 toolsMenu.setEnabled(false); | |
366 menuBar.add(toolsMenu); | |
367 | |
368 // | |
369 // Windows menu | |
370 // | |
371 | |
372 JMenu windowsMenu = new JMenu("Windows"); | |
373 windowsMenu.setMnemonic(KeyEvent.VK_W); | |
374 item = createMenuItem("Console", | |
375 new ActionListener() { | |
376 public void actionPerformed(ActionEvent e) { | |
377 showConsole(); | |
378 } | |
379 }); | |
380 item.setMnemonic(KeyEvent.VK_C); | |
381 windowsMenu.add(item); | |
382 showDbgConsoleMenuItem = createMenuItem("Debugger Console", | |
383 new ActionListener() { | |
384 public void actionPerformed(ActionEvent e) { | |
385 showDebuggerConsole(); | |
386 } | |
387 }); | |
388 showDbgConsoleMenuItem.setMnemonic(KeyEvent.VK_D); | |
389 windowsMenu.add(showDbgConsoleMenuItem); | |
390 showDbgConsoleMenuItem.setEnabled(false); | |
391 | |
392 menuBar.add(windowsMenu); | |
393 | |
394 | |
395 frame.setJMenuBar(menuBar); | |
396 | |
397 desktop = new JDesktopPane(); | |
398 frame.getContentPane().add(desktop); | |
399 GraphicsUtilities.reshapeToAspectRatio(frame, 4.0f/3.0f, 0.75f, Toolkit.getDefaultToolkit().getScreenSize()); | |
400 GraphicsUtilities.centerInContainer(frame, Toolkit.getDefaultToolkit().getScreenSize()); | |
152
c70a245cad3a
6670684: 4/5 SA command universe did not print out CMS space information
dcubed
parents:
0
diff
changeset
|
401 frame.setVisible(true); |
0 | 402 |
403 Runtime.getRuntime().addShutdownHook(new java.lang.Thread() { | |
404 public void run() { | |
405 detachDebugger(); | |
406 } | |
407 }); | |
408 | |
409 if (pidText != null) { | |
410 attach(pidText); | |
411 } else if (execPath != null) { | |
412 attach(execPath, coreFilename); | |
413 } | |
414 } | |
415 | |
416 // FIXME: merge showAttachDialog, showOpenCoreFileDialog, showConnectDialog | |
417 private void showAttachDialog() { | |
418 // FIXME: create filtered text field which only accepts numbers | |
419 setMenuItemsEnabled(attachMenuItems, false); | |
420 final JInternalFrame attachDialog = new JInternalFrame("Attach to HotSpot process"); | |
421 attachDialog.getContentPane().setLayout(new BorderLayout()); | |
422 | |
423 JPanel panel = new JPanel(); | |
424 panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS)); | |
425 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
426 attachDialog.setBackground(panel.getBackground()); | |
427 | |
428 panel.add(new JLabel("Enter process ID:")); | |
429 final JTextField pidTextField = new JTextField(10); | |
430 ActionListener attacher = new ActionListener() { | |
431 public void actionPerformed(ActionEvent e) { | |
432 attachDialog.setVisible(false); | |
433 desktop.remove(attachDialog); | |
434 workerThread.invokeLater(new Runnable() { | |
435 public void run() { | |
436 attach(pidTextField.getText()); | |
437 } | |
438 }); | |
439 } | |
440 }; | |
441 | |
442 pidTextField.addActionListener(attacher); | |
443 panel.add(pidTextField); | |
444 attachDialog.getContentPane().add(panel, BorderLayout.NORTH); | |
445 | |
446 Box vbox = Box.createVerticalBox(); | |
447 panel = new JPanel(); | |
448 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
449 panel.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8)); | |
450 JTextArea ta = new JTextArea( | |
451 "Enter the process ID of a currently-running HotSpot process. On " + | |
452 "Solaris and most Unix operating systems, this can be determined by " + | |
453 "typing \"ps -u <your username> | grep java\"; the process ID is the " + | |
454 "first number which appears on the resulting line. On Windows, the " + | |
455 "process ID is present in the Task Manager, which can be brought up " + | |
456 "while logged on to the desktop by pressing Ctrl-Alt-Delete."); | |
457 ta.setLineWrap(true); | |
458 ta.setWrapStyleWord(true); | |
459 ta.setEditable(false); | |
460 ta.setBackground(panel.getBackground()); | |
461 panel.add(ta); | |
462 vbox.add(panel); | |
463 | |
464 Box hbox = Box.createHorizontalBox(); | |
465 hbox.add(Box.createGlue()); | |
466 JButton button = new JButton("OK"); | |
467 button.addActionListener(attacher); | |
468 hbox.add(button); | |
469 hbox.add(Box.createHorizontalStrut(20)); | |
470 button = new JButton("Cancel"); | |
471 button.addActionListener(new ActionListener() { | |
472 public void actionPerformed(ActionEvent e) { | |
473 attachDialog.setVisible(false); | |
474 desktop.remove(attachDialog); | |
475 setMenuItemsEnabled(attachMenuItems, true); | |
476 } | |
477 }); | |
478 hbox.add(button); | |
479 hbox.add(Box.createGlue()); | |
480 panel = new JPanel(); | |
481 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
482 panel.add(hbox); | |
483 vbox.add(panel); | |
484 | |
485 attachDialog.getContentPane().add(vbox, BorderLayout.SOUTH); | |
486 | |
487 desktop.add(attachDialog); | |
488 attachDialog.setSize(400, 300); | |
489 GraphicsUtilities.centerInContainer(attachDialog); | |
490 attachDialog.show(); | |
491 pidTextField.requestFocus(); | |
492 } | |
493 | |
494 // FIXME: merge showAttachDialog, showOpenCoreFileDialog, showConnectDialog | |
495 private void showOpenCoreFileDialog() { | |
496 setMenuItemsEnabled(attachMenuItems, false); | |
497 final JInternalFrame dialog = new JInternalFrame("Open Core File"); | |
498 dialog.getContentPane().setLayout(new BorderLayout()); | |
499 | |
500 JPanel panel = new JPanel(); | |
501 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
502 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
503 dialog.setBackground(panel.getBackground()); | |
504 | |
505 Box hbox = Box.createHorizontalBox(); | |
506 Box vbox = Box.createVerticalBox(); | |
507 vbox.add(new JLabel("Path to core file:")); | |
508 vbox.add(new JLabel("Path to Java executable:")); | |
509 hbox.add(vbox); | |
510 | |
511 vbox = Box.createVerticalBox(); | |
512 final JTextField corePathField = new JTextField(40); | |
513 final JTextField execPathField = new JTextField(40); | |
514 vbox.add(corePathField); | |
515 vbox.add(execPathField); | |
516 hbox.add(vbox); | |
517 | |
518 final JButton browseCorePath = new JButton("Browse .."); | |
519 final JButton browseExecPath = new JButton("Browse .."); | |
520 browseCorePath.addActionListener(new ActionListener() { | |
521 public void actionPerformed(ActionEvent e) { | |
522 JFileChooser fileChooser = new JFileChooser(new File(".")); | |
523 int retVal = fileChooser.showOpenDialog(dialog); | |
524 if (retVal == JFileChooser.APPROVE_OPTION) { | |
525 corePathField.setText(fileChooser.getSelectedFile().getPath()); | |
526 } | |
527 } | |
528 }); | |
529 browseExecPath.addActionListener(new ActionListener() { | |
530 public void actionPerformed(ActionEvent e) { | |
531 JFileChooser fileChooser = new JFileChooser(new File(".")); | |
532 int retVal = fileChooser.showOpenDialog(dialog); | |
533 if (retVal == JFileChooser.APPROVE_OPTION) { | |
534 execPathField.setText(fileChooser.getSelectedFile().getPath()); | |
535 } | |
536 } | |
537 }); | |
538 vbox = Box.createVerticalBox(); | |
539 vbox.add(browseCorePath); | |
540 vbox.add(browseExecPath); | |
541 hbox.add(vbox); | |
542 | |
543 panel.add(hbox); | |
544 dialog.getContentPane().add(panel, BorderLayout.NORTH); | |
545 | |
546 ActionListener attacher = new ActionListener() { | |
547 public void actionPerformed(ActionEvent e) { | |
548 dialog.setVisible(false); | |
549 desktop.remove(dialog); | |
550 workerThread.invokeLater(new Runnable() { | |
551 public void run() { | |
552 attach(execPathField.getText(), corePathField.getText()); | |
553 } | |
554 }); | |
555 } | |
556 }; | |
557 corePathField.addActionListener(attacher); | |
558 execPathField.addActionListener(attacher); | |
559 | |
560 vbox = Box.createVerticalBox(); | |
561 panel = new JPanel(); | |
562 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
563 panel.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8)); | |
564 JTextArea ta = new JTextArea( | |
565 "Enter the full path names to the core file from a HotSpot process " + | |
566 "and the Java executable from which it came. The latter is typically " + | |
567 "located in the JDK/JRE directory under the directory " + | |
568 "jre/bin/<arch>/native_threads."); | |
569 ta.setLineWrap(true); | |
570 ta.setWrapStyleWord(true); | |
571 ta.setEditable(false); | |
572 ta.setBackground(panel.getBackground()); | |
573 panel.add(ta); | |
574 vbox.add(panel); | |
575 | |
576 hbox = Box.createHorizontalBox(); | |
577 hbox.add(Box.createGlue()); | |
578 JButton button = new JButton("OK"); | |
579 button.addActionListener(attacher); | |
580 hbox.add(button); | |
581 hbox.add(Box.createHorizontalStrut(20)); | |
582 button = new JButton("Cancel"); | |
583 button.addActionListener(new ActionListener() { | |
584 public void actionPerformed(ActionEvent e) { | |
585 dialog.setVisible(false); | |
586 desktop.remove(dialog); | |
587 setMenuItemsEnabled(attachMenuItems, true); | |
588 } | |
589 }); | |
590 hbox.add(button); | |
591 hbox.add(Box.createGlue()); | |
592 panel = new JPanel(); | |
593 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
594 panel.add(hbox); | |
595 vbox.add(panel); | |
596 | |
597 dialog.getContentPane().add(vbox, BorderLayout.SOUTH); | |
598 | |
599 desktop.add(dialog); | |
600 dialog.setSize(500, 300); | |
601 GraphicsUtilities.centerInContainer(dialog); | |
602 dialog.show(); | |
603 corePathField.requestFocus(); | |
604 } | |
605 | |
606 // FIXME: merge showAttachDialog, showOpenCoreFileDialog, showConnectDialog | |
607 private void showConnectDialog() { | |
608 // FIXME: create filtered text field which only accepts numbers | |
609 setMenuItemsEnabled(attachMenuItems, false); | |
610 final JInternalFrame dialog = new JInternalFrame("Connect to HotSpot Debug Server"); | |
611 dialog.getContentPane().setLayout(new BorderLayout()); | |
612 | |
613 JPanel panel = new JPanel(); | |
614 panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS)); | |
615 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
616 dialog.setBackground(panel.getBackground()); | |
617 | |
618 panel.add(new JLabel("Enter machine name:")); | |
619 final JTextField pidTextField = new JTextField(40); | |
620 ActionListener attacher = new ActionListener() { | |
621 public void actionPerformed(ActionEvent e) { | |
622 dialog.setVisible(false); | |
623 desktop.remove(dialog); | |
624 workerThread.invokeLater(new Runnable() { | |
625 public void run() { | |
626 connect(pidTextField.getText()); | |
627 } | |
628 }); | |
629 } | |
630 }; | |
631 | |
632 pidTextField.addActionListener(attacher); | |
633 panel.add(pidTextField); | |
634 dialog.getContentPane().add(panel, BorderLayout.NORTH); | |
635 | |
636 Box vbox = Box.createVerticalBox(); | |
637 panel = new JPanel(); | |
638 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
639 panel.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8)); | |
640 JTextArea ta = new JTextArea( | |
641 "Enter the name of a machine on which the HotSpot \"Debug Server\" is " + | |
642 "running and is attached to a process or core file."); | |
643 ta.setLineWrap(true); | |
644 ta.setWrapStyleWord(true); | |
645 ta.setEditable(false); | |
646 ta.setBackground(panel.getBackground()); | |
647 panel.add(ta); | |
648 vbox.add(panel); | |
649 | |
650 Box hbox = Box.createHorizontalBox(); | |
651 hbox.add(Box.createGlue()); | |
652 JButton button = new JButton("OK"); | |
653 button.addActionListener(attacher); | |
654 hbox.add(button); | |
655 hbox.add(Box.createHorizontalStrut(20)); | |
656 button = new JButton("Cancel"); | |
657 button.addActionListener(new ActionListener() { | |
658 public void actionPerformed(ActionEvent e) { | |
659 dialog.setVisible(false); | |
660 desktop.remove(dialog); | |
661 setMenuItemsEnabled(attachMenuItems, true); | |
662 } | |
663 }); | |
664 hbox.add(button); | |
665 hbox.add(Box.createGlue()); | |
666 panel = new JPanel(); | |
667 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
668 panel.add(hbox); | |
669 vbox.add(panel); | |
670 | |
671 dialog.getContentPane().add(vbox, BorderLayout.SOUTH); | |
672 | |
673 desktop.add(dialog); | |
674 dialog.setSize(400, 300); | |
675 GraphicsUtilities.centerInContainer(dialog); | |
676 dialog.show(); | |
677 pidTextField.requestFocus(); | |
678 } | |
679 | |
680 public void showThreadOopInspector(JavaThread thread) { | |
681 showInspector(new OopTreeNodeAdapter(thread.getThreadObj(), null)); | |
682 } | |
683 | |
684 public void showInspector(SimpleTreeNode adapter) { | |
685 showPanel("Inspector", new Inspector(adapter), 1.0f, 0.65f); | |
686 } | |
687 | |
688 public void showLiveness(Oop oop, LivenessPathList liveness) { | |
689 ByteArrayOutputStream bos = new ByteArrayOutputStream(); | |
690 PrintStream tty = new PrintStream(bos); | |
691 int numPaths = liveness.size(); | |
692 for (int i = 0; i < numPaths; i++) { | |
693 tty.println("Path " + (i + 1) + " of " + numPaths + ":"); | |
694 liveness.get(i).printOn(tty); | |
695 } | |
696 JTextArea ta = new JTextArea(bos.toString()); | |
697 ta.setLineWrap(true); | |
698 ta.setWrapStyleWord(true); | |
699 ta.setEditable(false); | |
700 | |
701 JPanel panel = new JPanel(); | |
702 panel.setLayout(new BorderLayout()); | |
703 | |
704 JScrollPane scroller = new JScrollPane(); | |
705 scroller.getViewport().add(ta); | |
706 | |
707 panel.add(scroller, BorderLayout.CENTER); | |
708 | |
709 bos = new ByteArrayOutputStream(); | |
710 tty = new PrintStream(bos); | |
711 tty.print("Liveness result for "); | |
712 Oop.printOopValueOn(oop, tty); | |
713 | |
714 JInternalFrame frame = new JInternalFrame(bos.toString()); | |
715 frame.setResizable(true); | |
716 frame.setClosable(true); | |
717 frame.setIconifiable(true); | |
718 frame.getContentPane().setLayout(new BorderLayout()); | |
719 frame.getContentPane().add(panel, BorderLayout.CENTER); | |
720 frame.pack(); | |
721 desktop.add(frame); | |
722 GraphicsUtilities.reshapeToAspectRatio(frame, 0.5f / 0.2f, 0.5f, frame.getParent().getSize()); | |
723 frame.show(); | |
724 } | |
725 | |
726 private void fireComputeReversePtrs() { | |
727 // Possible this might have been computed elsewhere | |
728 if (VM.getVM().getRevPtrs() != null) { | |
729 computeRevPtrsMenuItem.setEnabled(false); | |
730 return; | |
731 } | |
732 | |
733 workerThread.invokeLater(new Runnable() { | |
734 public void run() { | |
735 HeapProgress progress = new HeapProgress("Reverse Pointers Analysis"); | |
736 try { | |
737 ReversePtrsAnalysis analysis = new ReversePtrsAnalysis(); | |
738 analysis.setHeapProgressThunk(progress); | |
739 analysis.run(); | |
740 computeRevPtrsMenuItem.setEnabled(false); | |
741 } catch (OutOfMemoryError e) { | |
742 final String errMsg = formatMessage(e.toString(), 80); | |
743 SwingUtilities.invokeLater(new Runnable() { | |
744 public void run() { | |
745 JOptionPane.showInternalMessageDialog(desktop, | |
746 "Error computing reverse pointers:" + errMsg, | |
747 "Error", | |
748 JOptionPane.WARNING_MESSAGE); | |
749 } | |
750 }); | |
751 } finally { | |
752 // make sure the progress bar goes away | |
753 progress.heapIterationComplete(); | |
754 } | |
755 } | |
756 }); | |
757 } | |
758 | |
759 // Simple struct containing signal information | |
760 class SignalInfo { | |
761 public int sigNum; | |
762 public String sigName; | |
763 } | |
764 | |
765 // Need to have mutable vframe as well as visible memory panel | |
766 abstract class StackWalker implements Runnable { | |
767 protected JavaVFrame vf; | |
768 protected AnnotatedMemoryPanel annoPanel; | |
769 | |
770 StackWalker(JavaVFrame vf, AnnotatedMemoryPanel annoPanel) { | |
771 this.vf = vf; | |
772 this.annoPanel = annoPanel; | |
773 } | |
774 } | |
775 | |
776 public void showThreadStackMemory(final JavaThread thread) { | |
777 // dumpStack(thread); | |
778 JavaVFrame vframe = getLastJavaVFrame(thread); | |
779 if (vframe == null) { | |
780 JOptionPane.showInternalMessageDialog(desktop, | |
781 "Thread \"" + thread.getThreadName() + | |
782 "\" has no Java frames on its stack", | |
783 "Show Stack Memory", | |
784 JOptionPane.INFORMATION_MESSAGE); | |
785 return; | |
786 } | |
787 | |
788 JInternalFrame stackFrame = new JInternalFrame("Stack Memory for " + thread.getThreadName()); | |
789 stackFrame.getContentPane().setLayout(new BorderLayout()); | |
790 stackFrame.setResizable(true); | |
791 stackFrame.setClosable(true); | |
792 stackFrame.setIconifiable(true); | |
793 final long addressSize = agent.getTypeDataBase().getAddressSize(); | |
794 boolean is64Bit = (addressSize == 8); | |
795 // This is somewhat of a hack to guess a thread's stack limits since the | |
796 // JavaThread doesn't support this functionality. However it is nice in that | |
797 // it locks us into the active region of the thread's stack and not its | |
798 // theoretical limits. | |
799 // | |
800 sun.jvm.hotspot.runtime.Frame tmpFrame = thread.getCurrentFrameGuess(); | |
801 Address sp = tmpFrame.getSP(); | |
802 Address starting = sp; | |
803 Address maxSP = starting; | |
804 Address minSP = starting; | |
805 RegisterMap tmpMap = thread.newRegisterMap(false); | |
806 while ((tmpFrame != null) && (!tmpFrame.isFirstFrame())) { | |
807 tmpFrame = tmpFrame.sender(tmpMap); | |
808 if (tmpFrame != null) { | |
809 sp = tmpFrame.getSP(); | |
810 if (sp != null) { | |
811 maxSP = AddressOps.max(maxSP, sp); | |
812 minSP = AddressOps.min(minSP, sp); | |
813 } | |
814 } | |
815 | |
816 } | |
817 // It is useful to be able to see say +/- 8K on the current stack range | |
818 AnnotatedMemoryPanel annoMemPanel = new AnnotatedMemoryPanel(agent.getDebugger(), is64Bit, starting, | |
819 minSP.addOffsetTo(-8192), | |
820 maxSP.addOffsetTo( 8192)); | |
821 | |
822 stackFrame.getContentPane().add(annoMemPanel, BorderLayout.CENTER); | |
823 desktop.add(stackFrame); | |
824 GraphicsUtilities.reshapeToAspectRatio(stackFrame, 4.0f / 3.0f, 0.85f, stackFrame.getParent().getSize()); | |
825 stackFrame.show(); | |
826 | |
827 // Stackmap computation for interpreted frames is expensive; do | |
828 // all stackwalking work in another thread for better GUI | |
829 // responsiveness | |
830 workerThread.invokeLater(new StackWalker(vframe, annoMemPanel) { | |
831 public void run() { | |
832 Address startAddr = null; | |
833 | |
834 // As this is a debugger, we want to provide potential crash | |
835 // information to the user, i.e., by marking signal handler frames | |
836 // on the stack. Since this system is currently targeted at | |
837 // annotating the Java frames (interpreted or compiled) on the | |
838 // stack and not, for example, "external" frames (note the current | |
839 // absence of a PC-to-symbol lookup mechanism at the Debugger | |
840 // level), we want to mark any Java frames which were interrupted | |
841 // by a signal. We do this by making two passes over the stack, | |
842 // one which finds signal handler frames and puts the parent | |
843 // frames in a table and one which finds Java frames and if they | |
844 // are in the table indicates that they were interrupted by a signal. | |
845 | |
846 Map interruptedFrameMap = new HashMap(); | |
847 { | |
848 sun.jvm.hotspot.runtime.Frame tmpFrame = thread.getCurrentFrameGuess(); | |
849 RegisterMap tmpMap = thread.newRegisterMap(false); | |
850 while ((tmpFrame != null) && (!tmpFrame.isFirstFrame())) { | |
851 if (tmpFrame.isSignalHandlerFrameDbg()) { | |
852 // Add some information to the map that we can extract later | |
853 sun.jvm.hotspot.runtime.Frame interruptedFrame = tmpFrame.sender(tmpMap); | |
854 SignalInfo info = new SignalInfo(); | |
855 info.sigNum = tmpFrame.getSignalNumberDbg(); | |
856 info.sigName = tmpFrame.getSignalNameDbg(); | |
857 interruptedFrameMap.put(interruptedFrame, info); | |
858 } | |
859 tmpFrame = tmpFrame.sender(tmpMap); | |
860 } | |
861 } | |
862 | |
863 while (vf != null) { | |
864 String anno = null; | |
865 JavaVFrame curVFrame = vf; | |
866 sun.jvm.hotspot.runtime.Frame curFrame = curVFrame.getFrame(); | |
867 Method interpreterFrameMethod = null; | |
868 | |
869 if (curVFrame.isInterpretedFrame()) { | |
870 anno = "Interpreted frame"; | |
871 } else { | |
872 anno = "Compiled frame"; | |
873 if (curVFrame.isDeoptimized()) { | |
874 anno += " (deoptimized)"; | |
875 } | |
876 } | |
877 if (curVFrame.mayBeImpreciseDbg()) { | |
878 anno += "; information may be imprecise"; | |
879 } | |
880 | |
881 if (curVFrame.isInterpretedFrame()) { | |
882 // Find the codelet | |
883 InterpreterCodelet codelet = VM.getVM().getInterpreter().getCodeletContaining(curFrame.getPC()); | |
884 String description = null; | |
885 if (codelet != null) { | |
886 description = codelet.getDescription(); | |
887 } | |
888 if (description == null) { | |
889 anno += "\n(Unknown interpreter codelet)"; | |
890 } else { | |
891 anno += "\nExecuting in codelet \"" + description + "\" at PC = " + curFrame.getPC(); | |
892 } | |
893 } else if (curVFrame.isCompiledFrame()) { | |
894 anno += "\nExecuting at PC = " + curFrame.getPC(); | |
895 } | |
896 | |
897 if (startAddr == null) { | |
898 startAddr = curFrame.getSP(); | |
899 } | |
900 | |
901 // FIXME: some compiled frames with empty oop map sets have been | |
902 // found (for example, Vector's inner Enumeration class, method | |
903 // "hasMoreElements"). Not sure yet why these cases are showing | |
904 // up -- should be possible (though unlikely) for safepoint code | |
905 // to patch the return instruction of these methods and then | |
906 // later attempt to get an oop map for that instruction. For | |
907 // now, we warn if we find such a method. | |
908 boolean shouldSkipOopMaps = false; | |
909 if (curVFrame.isCompiledFrame()) { | |
910 CodeBlob cb = VM.getVM().getCodeCache().findBlob(curFrame.getPC()); | |
911 OopMapSet maps = cb.getOopMaps(); | |
912 if ((maps == null) || (maps.getSize() == 0)) { | |
913 shouldSkipOopMaps = true; | |
914 } | |
915 } | |
916 | |
917 // Add signal information to annotation if necessary | |
918 SignalInfo sigInfo = (SignalInfo) interruptedFrameMap.get(curFrame); | |
919 if (sigInfo != null) { | |
920 // This frame took a signal and we need to report it. | |
921 anno = (anno + "\n*** INTERRUPTED BY SIGNAL " + Integer.toString(sigInfo.sigNum) + | |
922 " (" + sigInfo.sigName + ")"); | |
923 } | |
924 | |
925 JavaVFrame nextVFrame = curVFrame; | |
926 sun.jvm.hotspot.runtime.Frame nextFrame = curFrame; | |
927 do { | |
928 curVFrame = nextVFrame; | |
929 curFrame = nextFrame; | |
930 | |
931 try { | |
932 Method method = curVFrame.getMethod(); | |
933 if (interpreterFrameMethod == null && curVFrame.isInterpretedFrame()) { | |
934 interpreterFrameMethod = method; | |
935 } | |
936 int bci = curVFrame.getBCI(); | |
937 String lineNumberAnno = ""; | |
938 if (method.hasLineNumberTable()) { | |
939 if ((bci == DebugInformationRecorder.SYNCHRONIZATION_ENTRY_BCI) || | |
940 (bci >= 0 && bci < method.getCodeSize())) { | |
941 lineNumberAnno = ", line " + method.getLineNumberFromBCI(bci); | |
942 } else { | |
943 lineNumberAnno = " (INVALID BCI)"; | |
944 } | |
945 } | |
946 anno += "\n" + method.getMethodHolder().getName().asString() + "." + | |
947 method.getName().asString() + method.getSignature().asString() + | |
948 "\n@bci " + bci + lineNumberAnno; | |
949 } catch (Exception e) { | |
950 anno += "\n(ERROR while iterating vframes for frame " + curFrame + ")"; | |
951 } | |
952 | |
953 nextVFrame = curVFrame.javaSender(); | |
954 if (nextVFrame != null) { | |
955 nextFrame = nextVFrame.getFrame(); | |
956 } | |
957 } while (nextVFrame != null && nextFrame.equals(curFrame)); | |
958 | |
959 if (shouldSkipOopMaps) { | |
960 anno = anno + "\nNOTE: null or empty OopMapSet found for this CodeBlob"; | |
961 } | |
962 | |
963 if (curFrame.getFP() != null) { | |
964 annoPanel.addAnnotation(new Annotation(curFrame.getSP(), | |
965 curFrame.getFP(), | |
966 anno)); | |
967 } else { | |
968 if (VM.getVM().getCPU().equals("x86") || VM.getVM().getCPU().equals("amd64")) { | |
969 // For C2, which has null frame pointers on x86/amd64 | |
970 CodeBlob cb = VM.getVM().getCodeCache().findBlob(curFrame.getPC()); | |
971 Address sp = curFrame.getSP(); | |
972 if (Assert.ASSERTS_ENABLED) { | |
973 Assert.that(cb.getFrameSize() > 0, "CodeBlob must have non-zero frame size"); | |
974 } | |
975 annoPanel.addAnnotation(new Annotation(sp, | |
976 sp.addOffsetTo(cb.getFrameSize()), | |
977 anno)); | |
978 } else { | |
979 Assert.that(VM.getVM().getCPU().equals("ia64"), "only ia64 should reach here"); | |
980 } | |
981 } | |
982 | |
983 // Add interpreter frame annotations | |
984 if (curFrame.isInterpretedFrame()) { | |
985 annoPanel.addAnnotation(new Annotation(curFrame.addressOfInterpreterFrameExpressionStack(), | |
986 curFrame.addressOfInterpreterFrameTOS(), | |
987 "Interpreter expression stack")); | |
988 if (interpreterFrameMethod != null) { | |
989 // The offset is just to get the right stack slots highlighted in the output | |
990 int offset = 1; | |
991 annoPanel.addAnnotation(new Annotation(curFrame.addressOfInterpreterFrameLocal(offset), | |
992 curFrame.addressOfInterpreterFrameLocal((int) interpreterFrameMethod.getMaxLocals() + offset), | |
993 "Interpreter locals area for frame with SP = " + curFrame.getSP())); | |
994 } | |
995 String methodAnno = "Interpreter frame methodOop"; | |
996 if (interpreterFrameMethod == null) { | |
997 methodAnno += " (BAD OOP)"; | |
998 } | |
999 Address a = curFrame.addressOfInterpreterFrameMethod(); | |
1000 annoPanel.addAnnotation(new Annotation(a, a.addOffsetTo(addressSize), methodAnno)); | |
1001 a = curFrame.addressOfInterpreterFrameCPCache(); | |
1002 annoPanel.addAnnotation(new Annotation(a, a.addOffsetTo(addressSize), "Interpreter constant pool cache")); | |
1003 } | |
1004 | |
1005 RegisterMap rm = (RegisterMap) vf.getRegisterMap().clone(); | |
1006 if (!shouldSkipOopMaps) { | |
1007 try { | |
1008 curFrame.oopsDo(new AddressVisitor() { | |
1009 public void visitAddress(Address addr) { | |
1010 if (Assert.ASSERTS_ENABLED) { | |
1011 Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1) == null, | |
1012 "Address " + addr + "should have been aligned"); | |
1013 } | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1014 OopHandle handle = addr.getOopHandleAt(0); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1015 addAnnotation(addr, handle); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1016 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1017 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1018 public void visitCompOopAddress(Address addr) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1019 if (Assert.ASSERTS_ENABLED) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1020 Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1) == null, |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1021 "Address " + addr + "should have been aligned"); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1022 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1023 OopHandle handle = addr.getCompOopHandleAt(0); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1024 addAnnotation(addr, handle); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1025 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1026 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1027 public void addAnnotation(Address addr, OopHandle handle) { |
0 | 1028 // Check contents |
1029 String anno = "null oop"; | |
1030 if (handle != null) { | |
1031 // Find location | |
1032 CollectedHeap collHeap = VM.getVM().getUniverse().heap(); | |
1033 boolean bad = true; | |
1034 anno = "BAD OOP"; | |
1035 if (collHeap instanceof GenCollectedHeap) { | |
1036 GenCollectedHeap heap = (GenCollectedHeap) collHeap; | |
1037 for (int i = 0; i < heap.nGens(); i++) { | |
1038 if (heap.getGen(i).isIn(handle)) { | |
1039 if (i == 0) { | |
1040 anno = "NewGen "; | |
1041 } else if (i == 1) { | |
1042 anno = "OldGen "; | |
1043 } else { | |
1044 anno = "Gen " + i + " "; | |
1045 } | |
1046 bad = false; | |
1047 break; | |
1048 } | |
1049 } | |
1050 | |
1051 if (bad) { | |
1052 // Try perm gen | |
1053 if (heap.permGen().isIn(handle)) { | |
1054 anno = "PermGen "; | |
1055 bad = false; | |
1056 } | |
1057 } | |
1058 } else if (collHeap instanceof ParallelScavengeHeap) { | |
1059 ParallelScavengeHeap heap = (ParallelScavengeHeap) collHeap; | |
1060 if (heap.youngGen().isIn(handle)) { | |
1061 anno = "PSYoungGen "; | |
1062 bad = false; | |
1063 } else if (heap.oldGen().isIn(handle)) { | |
1064 anno = "PSOldGen "; | |
1065 bad = false; | |
1066 } else if (heap.permGen().isIn(handle)) { | |
1067 anno = "PSPermGen "; | |
1068 bad = false; | |
1069 } | |
1070 } else { | |
1071 // Optimistically assume the oop isn't bad | |
1072 anno = "[Unknown generation] "; | |
1073 bad = false; | |
1074 } | |
1075 | |
1076 if (!bad) { | |
1077 try { | |
1078 Oop oop = VM.getVM().getObjectHeap().newOop(handle); | |
1079 if (oop instanceof Instance) { | |
1080 // Java-level objects always have workable names | |
1081 anno = anno + oop.getKlass().getName().asString(); | |
1082 } else { | |
1083 ByteArrayOutputStream bos = new ByteArrayOutputStream(); | |
1084 Oop.printOopValueOn(oop, new PrintStream(bos)); | |
1085 anno = anno + bos.toString(); | |
1086 } | |
1087 } | |
1088 catch (AddressException e) { | |
1089 anno += "CORRUPT OOP"; | |
1090 } | |
1091 catch (NullPointerException e) { | |
1092 anno += "CORRUPT OOP (null pointer)"; | |
1093 } | |
1094 } | |
1095 } | |
1096 | |
1097 annoPanel.addAnnotation(new Annotation(addr, addr.addOffsetTo(addressSize), anno)); | |
1098 } | |
1099 }, rm); | |
1100 } catch (Exception e) { | |
1101 System.err.println("Error while performing oopsDo for frame " + curFrame); | |
1102 e.printStackTrace(); | |
1103 } | |
1104 } | |
1105 | |
1106 vf = nextVFrame; | |
1107 } | |
1108 | |
1109 // This used to paint as we walked the frames. This caused the display to be refreshed | |
1110 // enough to be annoying on remote displays. It also would cause the annotations to | |
1111 // be displayed in varying order which caused some annotations to overwrite others | |
1112 // depending on the races between painting and adding annotations. This latter problem | |
1113 // still exists to some degree but moving this code here definitely seems to reduce it | |
1114 annoPanel.makeVisible(startAddr); | |
1115 annoPanel.repaint(); | |
1116 } | |
1117 }); | |
1118 } | |
1119 | |
1120 /** NOTE we are in a different thread here than either the main | |
1121 thread or the Swing/AWT event handler thread, so we must be very | |
1122 careful when creating or removing widgets */ | |
1123 private void attach(String pidText) { | |
1124 try { | |
1125 this.pidText = pidText; | |
1126 pid = Integer.parseInt(pidText); | |
1127 } | |
1128 catch (NumberFormatException e) { | |
1129 SwingUtilities.invokeLater(new Runnable() { | |
1130 public void run() { | |
1131 setMenuItemsEnabled(attachMenuItems, true); | |
1132 JOptionPane.showInternalMessageDialog(desktop, | |
1133 "Unable to parse process ID \"" + HSDB.this.pidText + "\".\nPlease enter a number.", | |
1134 "Parse error", | |
1135 JOptionPane.WARNING_MESSAGE); | |
1136 } | |
1137 }); | |
1138 return; | |
1139 } | |
1140 | |
1141 // Try to attach to this process | |
1142 Runnable remover = new Runnable() { | |
1143 public void run() { | |
1144 attachWaitDialog.setVisible(false); | |
1145 desktop.remove(attachWaitDialog); | |
1146 attachWaitDialog = null; | |
1147 } | |
1148 }; | |
1149 | |
1150 try { | |
1151 SwingUtilities.invokeLater(new Runnable() { | |
1152 public void run() { | |
1153 JOptionPane pane = new JOptionPane("Attaching to process " + pid + ", please wait...", JOptionPane.INFORMATION_MESSAGE); | |
1154 pane.setOptions(new Object[] {}); | |
1155 attachWaitDialog = pane.createInternalFrame(desktop, "Attaching to Process"); | |
1156 attachWaitDialog.show(); | |
1157 } | |
1158 }); | |
1159 | |
1160 // FIXME: display exec'd debugger's output messages during this | |
1161 // lengthy call | |
1162 agent.attach(pid); | |
1163 if (agent.getDebugger().hasConsole()) { | |
1164 showDbgConsoleMenuItem.setEnabled(true); | |
1165 } | |
1166 attached = true; | |
1167 SwingUtilities.invokeLater(remover); | |
1168 } | |
1169 catch (DebuggerException e) { | |
1170 SwingUtilities.invokeLater(remover); | |
1171 final String errMsg = formatMessage(e.getMessage(), 80); | |
1172 SwingUtilities.invokeLater(new Runnable() { | |
1173 public void run() { | |
1174 setMenuItemsEnabled(attachMenuItems, true); | |
1175 JOptionPane.showInternalMessageDialog(desktop, | |
1176 "Unable to connect to process ID " + pid + ":\n\n" + errMsg, | |
1177 "Unable to Connect", | |
1178 JOptionPane.WARNING_MESSAGE); | |
1179 } | |
1180 }); | |
1181 agent.detach(); | |
1182 return; | |
1183 } | |
1184 | |
1185 // OK, the VM should be available. Create the Threads dialog. | |
1186 showThreadsDialog(); | |
1187 } | |
1188 | |
1189 /** NOTE we are in a different thread here than either the main | |
1190 thread or the Swing/AWT event handler thread, so we must be very | |
1191 careful when creating or removing widgets */ | |
1192 private void attach(final String executablePath, final String corePath) { | |
1193 // Try to open this core file | |
1194 Runnable remover = new Runnable() { | |
1195 public void run() { | |
1196 attachWaitDialog.setVisible(false); | |
1197 desktop.remove(attachWaitDialog); | |
1198 attachWaitDialog = null; | |
1199 } | |
1200 }; | |
1201 | |
1202 try { | |
1203 SwingUtilities.invokeLater(new Runnable() { | |
1204 public void run() { | |
1205 JOptionPane pane = new JOptionPane("Opening core file, please wait...", JOptionPane.INFORMATION_MESSAGE); | |
1206 pane.setOptions(new Object[] {}); | |
1207 attachWaitDialog = pane.createInternalFrame(desktop, "Opening Core File"); | |
1208 attachWaitDialog.show(); | |
1209 } | |
1210 }); | |
1211 | |
1212 // FIXME: display exec'd debugger's output messages during this | |
1213 // lengthy call | |
1214 agent.attach(executablePath, corePath); | |
1215 if (agent.getDebugger().hasConsole()) { | |
1216 showDbgConsoleMenuItem.setEnabled(true); | |
1217 } | |
1218 attached = true; | |
1219 SwingUtilities.invokeLater(remover); | |
1220 } | |
1221 catch (DebuggerException e) { | |
1222 SwingUtilities.invokeLater(remover); | |
1223 final String errMsg = formatMessage(e.getMessage(), 80); | |
1224 SwingUtilities.invokeLater(new Runnable() { | |
1225 public void run() { | |
1226 setMenuItemsEnabled(attachMenuItems, true); | |
1227 JOptionPane.showInternalMessageDialog(desktop, | |
1228 "Unable to open core file\n" + corePath + ":\n\n" + errMsg, | |
1229 "Unable to Open Core File", | |
1230 JOptionPane.WARNING_MESSAGE); | |
1231 } | |
1232 }); | |
1233 agent.detach(); | |
1234 return; | |
1235 } | |
1236 | |
1237 // OK, the VM should be available. Create the Threads dialog. | |
1238 showThreadsDialog(); | |
1239 } | |
1240 | |
1241 /** NOTE we are in a different thread here than either the main | |
1242 thread or the Swing/AWT event handler thread, so we must be very | |
1243 careful when creating or removing widgets */ | |
1244 private void connect(final String remoteMachineName) { | |
1245 // Try to open this core file | |
1246 Runnable remover = new Runnable() { | |
1247 public void run() { | |
1248 attachWaitDialog.setVisible(false); | |
1249 desktop.remove(attachWaitDialog); | |
1250 attachWaitDialog = null; | |
1251 } | |
1252 }; | |
1253 | |
1254 try { | |
1255 SwingUtilities.invokeLater(new Runnable() { | |
1256 public void run() { | |
1257 JOptionPane pane = new JOptionPane("Connecting to debug server, please wait...", JOptionPane.INFORMATION_MESSAGE); | |
1258 pane.setOptions(new Object[] {}); | |
1259 attachWaitDialog = pane.createInternalFrame(desktop, "Connecting to Debug Server"); | |
1260 attachWaitDialog.show(); | |
1261 } | |
1262 }); | |
1263 | |
1264 agent.attach(remoteMachineName); | |
1265 if (agent.getDebugger().hasConsole()) { | |
1266 showDbgConsoleMenuItem.setEnabled(true); | |
1267 } | |
1268 attached = true; | |
1269 SwingUtilities.invokeLater(remover); | |
1270 } | |
1271 catch (DebuggerException e) { | |
1272 SwingUtilities.invokeLater(remover); | |
1273 final String errMsg = formatMessage(e.getMessage(), 80); | |
1274 SwingUtilities.invokeLater(new Runnable() { | |
1275 public void run() { | |
1276 setMenuItemsEnabled(attachMenuItems, true); | |
1277 JOptionPane.showInternalMessageDialog(desktop, | |
1278 "Unable to connect to machine \"" + remoteMachineName + "\":\n\n" + errMsg, | |
1279 "Unable to Connect", | |
1280 JOptionPane.WARNING_MESSAGE); | |
1281 } | |
1282 }); | |
1283 agent.detach(); | |
1284 return; | |
1285 } | |
1286 | |
1287 // OK, the VM should be available. Create the Threads dialog. | |
1288 showThreadsDialog(); | |
1289 } | |
1290 | |
1291 private void detachDebugger() { | |
1292 if (!attached) { | |
1293 return; | |
1294 } | |
1295 agent.detach(); | |
1296 attached = false; | |
1297 } | |
1298 | |
1299 private void detach() { | |
1300 detachDebugger(); | |
1301 attachWaitDialog = null; | |
1302 threadsFrame = null; | |
1303 consoleFrame = null; | |
1304 setMenuItemsEnabled(attachMenuItems, true); | |
1305 setMenuItemsEnabled(detachMenuItems, false); | |
1306 toolsMenu.setEnabled(false); | |
1307 showDbgConsoleMenuItem.setEnabled(false); | |
1308 // FIXME: is this sufficient, or will I have to do anything else | |
1309 // to the components to kill them off? What about WorkerThreads? | |
1310 desktop.removeAll(); | |
1311 desktop.invalidate(); | |
1312 desktop.validate(); | |
1313 desktop.repaint(); | |
1314 } | |
1315 | |
1316 /** NOTE that this is called from another thread than the main or | |
1317 Swing thread and we have to be careful about synchronization */ | |
1318 private void showThreadsDialog() { | |
1319 SwingUtilities.invokeLater(new Runnable() { | |
1320 public void run() { | |
1321 threadsFrame = new JInternalFrame("Java Threads"); | |
1322 threadsFrame.setResizable(true); | |
1323 threadsFrame.setIconifiable(true); | |
1324 JavaThreadsPanel threadsPanel = new JavaThreadsPanel(); | |
1325 threadsPanel.addPanelListener(HSDB.this); | |
1326 threadsFrame.getContentPane().add(threadsPanel); | |
1327 threadsFrame.setSize(500, 300); | |
1328 threadsFrame.pack(); | |
1329 desktop.add(threadsFrame); | |
1330 GraphicsUtilities.moveToInContainer(threadsFrame, 0.75f, 0.25f, 0, 20); | |
1331 threadsFrame.show(); | |
1332 setMenuItemsEnabled(attachMenuItems, false); | |
1333 setMenuItemsEnabled(detachMenuItems, true); | |
1334 toolsMenu.setEnabled(true); | |
1335 VM.registerVMInitializedObserver(new Observer() { | |
1336 public void update(Observable o, Object data) { | |
1337 computeRevPtrsMenuItem.setEnabled(true); | |
1338 } | |
1339 }); | |
1340 } | |
1341 }); | |
1342 } | |
1343 | |
1344 private void showObjectHistogram() { | |
1345 sun.jvm.hotspot.oops.ObjectHistogram histo = new sun.jvm.hotspot.oops.ObjectHistogram(); | |
1346 ObjectHistogramCleanupThunk cleanup = | |
1347 new ObjectHistogramCleanupThunk(histo); | |
1348 doHeapIteration("Object Histogram", | |
1349 "Generating histogram...", | |
1350 histo, | |
1351 cleanup); | |
1352 } | |
1353 | |
1354 class ObjectHistogramCleanupThunk implements CleanupThunk { | |
1355 sun.jvm.hotspot.oops.ObjectHistogram histo; | |
1356 | |
1357 ObjectHistogramCleanupThunk(sun.jvm.hotspot.oops.ObjectHistogram histo) { | |
1358 this.histo = histo; | |
1359 } | |
1360 | |
1361 public void heapIterationComplete() { | |
1362 SwingUtilities.invokeLater(new Runnable() { | |
1363 public void run() { | |
1364 JInternalFrame histoFrame = new JInternalFrame("Object Histogram"); | |
1365 histoFrame.setResizable(true); | |
1366 histoFrame.setClosable(true); | |
1367 histoFrame.setIconifiable(true); | |
1368 histoFrame.getContentPane().setLayout(new BorderLayout()); | |
1369 ObjectHistogramPanel panel = new ObjectHistogramPanel(histo); | |
1370 panel.addPanelListener(HSDB.this); | |
1371 histoFrame.getContentPane().add(panel); | |
1372 desktop.add(histoFrame); | |
1373 GraphicsUtilities.reshapeToAspectRatio(histoFrame, 4.0f / 3.0f, 0.6f, | |
1374 histoFrame.getParent().getSize()); | |
1375 GraphicsUtilities.centerInContainer(histoFrame); | |
1376 histoFrame.show(); | |
1377 } | |
1378 }); | |
1379 } | |
1380 } | |
1381 | |
1382 public void showObjectsOfType(Klass type) { | |
1383 FindObjectByType finder = new FindObjectByType(type); | |
1384 FindObjectByTypeCleanupThunk cleanup = | |
1385 new FindObjectByTypeCleanupThunk(finder); | |
1386 ByteArrayOutputStream bos = new ByteArrayOutputStream(); | |
1387 type.printValueOn(new PrintStream(bos)); | |
1388 String typeName = bos.toString(); | |
1389 doHeapIteration("Show Objects Of Type", | |
1390 "Finding instances of \"" + typeName + "\"", | |
1391 finder, | |
1392 cleanup); | |
1393 } | |
1394 | |
1395 class FindObjectByTypeCleanupThunk implements CleanupThunk { | |
1396 FindObjectByType finder; | |
1397 | |
1398 FindObjectByTypeCleanupThunk(FindObjectByType finder) { | |
1399 this.finder = finder; | |
1400 } | |
1401 | |
1402 public void heapIterationComplete() { | |
1403 SwingUtilities.invokeLater(new Runnable() { | |
1404 public void run() { | |
1405 JInternalFrame finderFrame = new JInternalFrame("Show Objects of Type"); | |
1406 finderFrame.getContentPane().setLayout(new BorderLayout()); | |
1407 finderFrame.setResizable(true); | |
1408 finderFrame.setClosable(true); | |
1409 finderFrame.setIconifiable(true); | |
1410 ObjectListPanel panel = new ObjectListPanel(finder.getResults(), | |
1411 new HeapProgress("Reverse Pointers Analysis")); | |
1412 panel.addPanelListener(HSDB.this); | |
1413 finderFrame.getContentPane().add(panel); | |
1414 desktop.add(finderFrame); | |
1415 GraphicsUtilities.reshapeToAspectRatio(finderFrame, 4.0f / 3.0f, 0.6f, | |
1416 finderFrame.getParent().getSize()); | |
1417 GraphicsUtilities.centerInContainer(finderFrame); | |
1418 finderFrame.show(); | |
1419 } | |
1420 }); | |
1421 } | |
1422 } | |
1423 | |
1424 private void showDebuggerConsole() { | |
1425 if (consoleFrame == null) { | |
1426 consoleFrame = new JInternalFrame("Debugger Console"); | |
1427 consoleFrame.setResizable(true); | |
1428 consoleFrame.setClosable(true); | |
1429 consoleFrame.setIconifiable(true); | |
1430 consoleFrame.getContentPane().setLayout(new BorderLayout()); | |
1431 consoleFrame.getContentPane().add(new DebuggerConsolePanel(agent.getDebugger()), BorderLayout.CENTER); | |
1432 GraphicsUtilities.reshapeToAspectRatio(consoleFrame, 5.0f, 0.9f, desktop.getSize()); | |
1433 } | |
1434 if (consoleFrame.getParent() == null) { | |
1435 desktop.add(consoleFrame); | |
1436 } | |
1437 consoleFrame.setVisible(true); | |
1438 consoleFrame.show(); | |
1439 consoleFrame.getContentPane().getComponent(0).requestFocus(); | |
1440 } | |
1441 | |
1442 private void showConsole() { | |
1443 CommandProcessor.DebuggerInterface di = new CommandProcessor.DebuggerInterface() { | |
1444 public HotSpotAgent getAgent() { | |
1445 return agent; | |
1446 } | |
1447 public boolean isAttached() { | |
1448 return attached; | |
1449 } | |
1450 public void attach(String pid) { | |
1451 attach(pid); | |
1452 } | |
1453 public void attach(String java, String core) { | |
1454 } | |
1455 public void detach() { | |
1456 detachDebugger(); | |
1457 } | |
1458 public void reattach() { | |
1459 if (attached) { | |
1460 detachDebugger(); | |
1461 } | |
1462 if (pidText != null) { | |
1463 attach(pidText); | |
1464 } else { | |
1465 attach(execPath, coreFilename); | |
1466 } | |
1467 } | |
1468 }; | |
1469 | |
1470 showPanel("Command Line", new CommandProcessorPanel(new CommandProcessor(di, null, null, null))); | |
1471 } | |
1472 | |
1473 private void showFindByQueryPanel() { | |
1474 showPanel("Find Object by Query", new FindByQueryPanel()); | |
1475 } | |
1476 | |
1477 private void showFindPanel() { | |
1478 showPanel("Find Pointer", new FindPanel()); | |
1479 } | |
1480 | |
1481 private void showFindInHeapPanel() { | |
1482 showPanel("Find Address In Heap", new FindInHeapPanel()); | |
1483 } | |
1484 | |
1485 private void showFindInCodeCachePanel() { | |
1486 showPanel("Find Address In Code Cache", new FindInCodeCachePanel()); | |
1487 } | |
1488 | |
1489 private void showHeapParametersPanel() { | |
1490 showPanel("Heap Parameters", new HeapParametersPanel()); | |
1491 } | |
1492 | |
1493 public void showThreadInfo(final JavaThread thread) { | |
1494 showPanel("Info for " + thread.getThreadName(), new ThreadInfoPanel(thread)); | |
1495 } | |
1496 | |
1497 public void showJavaStackTrace(final JavaThread thread) { | |
1498 JavaStackTracePanel jstp = new JavaStackTracePanel(); | |
1499 showPanel("Java stack trace for " + thread.getThreadName(), jstp); | |
1500 jstp.setJavaThread(thread); | |
1501 } | |
1502 | |
1503 private void showDeadlockDetectionPanel() { | |
1504 showPanel("Deadlock Detection", new DeadlockDetectionPanel()); | |
1505 } | |
1506 | |
1507 private void showMonitorCacheDumpPanel() { | |
1508 showPanel("Monitor Cache Dump", new MonitorCacheDumpPanel()); | |
1509 } | |
1510 | |
1511 public void showClassBrowser() { | |
1512 final JInternalFrame progressFrame = new JInternalFrame("Class Browser"); | |
1513 progressFrame.setResizable(true); | |
1514 progressFrame.setClosable(true); | |
1515 progressFrame.setIconifiable(true); | |
1516 progressFrame.getContentPane().setLayout(new BorderLayout()); | |
1517 final ProgressBarPanel bar = new ProgressBarPanel("Generating class list .."); | |
1518 bar.setIndeterminate(true); | |
1519 progressFrame.getContentPane().add(bar, BorderLayout.CENTER); | |
1520 desktop.add(progressFrame); | |
1521 progressFrame.pack(); | |
1522 GraphicsUtilities.centerInContainer(progressFrame); | |
1523 progressFrame.show(); | |
1524 | |
1525 workerThread.invokeLater(new Runnable() { | |
1526 public void run() { | |
1527 HTMLGenerator htmlGen = new HTMLGenerator(); | |
1528 InstanceKlass[] klasses = SystemDictionaryHelper.getAllInstanceKlasses(); | |
1529 final String htmlText = htmlGen.genHTMLForKlassNames(klasses); | |
1530 SwingUtilities.invokeLater(new Runnable() { | |
1531 public void run() { | |
1532 JInternalFrame cbFrame = new JInternalFrame("Class Browser"); | |
1533 cbFrame.getContentPane().setLayout(new BorderLayout()); | |
1534 cbFrame.setResizable(true); | |
1535 cbFrame.setClosable(true); | |
1536 cbFrame.setIconifiable(true); | |
1537 ClassBrowserPanel cbPanel = new ClassBrowserPanel(); | |
1538 cbFrame.getContentPane().add(cbPanel, BorderLayout.CENTER); | |
1539 desktop.remove(progressFrame); | |
1540 desktop.repaint(); | |
1541 desktop.add(cbFrame); | |
1542 GraphicsUtilities.reshapeToAspectRatio(cbFrame, 1.25f, 0.85f, | |
1543 cbFrame.getParent().getSize()); | |
1544 cbFrame.show(); | |
1545 cbPanel.setClassesText(htmlText); | |
1546 } | |
1547 }); | |
1548 } | |
1549 }); | |
1550 } | |
1551 | |
1552 public void showCodeViewer() { | |
1553 showPanel("Code Viewer", new CodeViewerPanel(), 1.25f, 0.85f); | |
1554 } | |
1555 | |
1556 public void showCodeViewer(final Address address) { | |
1557 final CodeViewerPanel panel = new CodeViewerPanel(); | |
1558 showPanel("Code Viewer", panel, 1.25f, 0.85f); | |
1559 SwingUtilities.invokeLater(new Runnable() { | |
1560 public void run() { | |
1561 panel.viewAddress(address); | |
1562 } | |
1563 }); | |
1564 | |
1565 } | |
1566 | |
1567 public void showMemoryViewer() { | |
1568 showPanel("Memory Viewer", new MemoryViewer(agent.getDebugger(), agent.getTypeDataBase().getAddressSize() == 8)); | |
1569 } | |
1570 | |
1571 public void showCommandLineFlags() { | |
1572 showPanel("Command Line Flags", new VMFlagsPanel()); | |
1573 } | |
1574 | |
1575 public void showVMVersion() { | |
1576 showPanel("VM Version Info", new VMVersionInfoPanel()); | |
1577 } | |
1578 | |
1579 public void showSystemProperties() { | |
1580 showPanel("System Properties", new SysPropsPanel()); | |
1581 } | |
1582 | |
1583 private void showPanel(String name, JPanel panel) { | |
1584 showPanel(name, panel, 5.0f / 3.0f, 0.4f); | |
1585 } | |
1586 | |
1587 private void showPanel(String name, JPanel panel, float aspectRatio, float fillRatio) { | |
1588 JInternalFrame frame = new JInternalFrame(name); | |
1589 frame.getContentPane().setLayout(new BorderLayout()); | |
1590 frame.setResizable(true); | |
1591 frame.setClosable(true); | |
1592 frame.setIconifiable(true); | |
1593 frame.setMaximizable(true); | |
1594 frame.getContentPane().add(panel, BorderLayout.CENTER); | |
1595 desktop.add(frame); | |
1596 GraphicsUtilities.reshapeToAspectRatio(frame, aspectRatio, fillRatio, frame.getParent().getSize()); | |
1597 GraphicsUtilities.randomLocation(frame); | |
1598 frame.show(); | |
1599 if (panel instanceof SAPanel) { | |
1600 ((SAPanel)panel).addPanelListener(this); | |
1601 } | |
1602 } | |
1603 | |
1604 //-------------------------------------------------------------------------------- | |
1605 // Framework for heap iteration with progress bar | |
1606 // | |
1607 | |
1608 interface CleanupThunk { | |
1609 public void heapIterationComplete(); | |
1610 } | |
1611 | |
1612 class HeapProgress implements HeapProgressThunk { | |
1613 private JInternalFrame frame; | |
1614 private ProgressBarPanel bar; | |
1615 private String windowTitle; | |
1616 private String progressBarTitle; | |
1617 private CleanupThunk cleanup; | |
1618 | |
1619 HeapProgress(String windowTitle) { | |
1620 this(windowTitle, "Percentage of heap visited", null); | |
1621 } | |
1622 | |
1623 HeapProgress(String windowTitle, String progressBarTitle) { | |
1624 this(windowTitle, progressBarTitle, null); | |
1625 } | |
1626 | |
1627 HeapProgress(String windowTitle, String progressBarTitle, CleanupThunk cleanup) { | |
1628 this.windowTitle = windowTitle; | |
1629 this.progressBarTitle = progressBarTitle; | |
1630 this.cleanup = cleanup; | |
1631 } | |
1632 | |
1633 public void heapIterationFractionUpdate(final double fractionOfHeapVisited) { | |
1634 if (frame == null) { | |
1635 SwingUtilities.invokeLater(new Runnable() { | |
1636 public void run() { | |
1637 frame = new JInternalFrame(windowTitle); | |
1638 frame.setResizable(true); | |
1639 frame.setIconifiable(true); | |
1640 frame.getContentPane().setLayout(new BorderLayout()); | |
1641 bar = new ProgressBarPanel(progressBarTitle); | |
1642 frame.getContentPane().add(bar, BorderLayout.CENTER); | |
1643 desktop.add(frame); | |
1644 frame.pack(); | |
1645 GraphicsUtilities.constrainToSize(frame, frame.getParent().getSize()); | |
1646 GraphicsUtilities.centerInContainer(frame); | |
1647 frame.show(); | |
1648 } | |
1649 }); | |
1650 } | |
1651 | |
1652 SwingUtilities.invokeLater(new Runnable() { | |
1653 public void run() { | |
1654 bar.setValue(fractionOfHeapVisited); | |
1655 } | |
1656 }); | |
1657 } | |
1658 | |
1659 public void heapIterationComplete() { | |
1660 SwingUtilities.invokeLater(new Runnable() { | |
1661 public void run() { | |
1662 desktop.remove(frame); | |
1663 desktop.repaint(); | |
1664 if (VM.getVM().getRevPtrs() != null) { | |
1665 // Ended up computing reverse pointers as a side-effect | |
1666 computeRevPtrsMenuItem.setEnabled(false); | |
1667 } | |
1668 } | |
1669 }); | |
1670 | |
1671 if (cleanup != null) { | |
1672 cleanup.heapIterationComplete(); | |
1673 } | |
1674 } | |
1675 } | |
1676 | |
1677 class VisitHeap implements Runnable { | |
1678 HeapVisitor visitor; | |
1679 | |
1680 VisitHeap(HeapVisitor visitor) { | |
1681 this.visitor = visitor; | |
1682 } | |
1683 | |
1684 public void run() { | |
1685 VM.getVM().getObjectHeap().iterate(visitor); | |
1686 } | |
1687 } | |
1688 | |
1689 private void doHeapIteration(String frameTitle, | |
1690 String progressBarText, | |
1691 HeapVisitor visitor, | |
1692 CleanupThunk cleanup) { | |
1693 sun.jvm.hotspot.oops.ObjectHistogram histo = new sun.jvm.hotspot.oops.ObjectHistogram(); | |
1694 HeapProgress progress = new HeapProgress(frameTitle, | |
1695 progressBarText, | |
1696 cleanup); | |
1697 HeapVisitor progVisitor = new ProgressiveHeapVisitor(visitor, progress); | |
1698 workerThread.invokeLater(new VisitHeap(progVisitor)); | |
1699 } | |
1700 | |
1701 //-------------------------------------------------------------------------------- | |
1702 // Stack trace helper | |
1703 // | |
1704 | |
1705 private static JavaVFrame getLastJavaVFrame(JavaThread cur) { | |
1706 RegisterMap regMap = cur.newRegisterMap(true); | |
1707 sun.jvm.hotspot.runtime.Frame f = cur.getCurrentFrameGuess(); | |
1708 if (f == null) return null; | |
1709 boolean imprecise = true; | |
1710 if (f.isInterpretedFrame() && !f.isInterpretedFrameValid()) { | |
1711 System.err.println("Correcting for invalid interpreter frame"); | |
1712 f = f.sender(regMap); | |
1713 imprecise = false; | |
1714 } | |
1715 VFrame vf = VFrame.newVFrame(f, regMap, cur, true, imprecise); | |
1716 if (vf == null) { | |
1717 System.err.println(" (Unable to create vframe for topmost frame guess)"); | |
1718 return null; | |
1719 } | |
1720 if (vf.isJavaFrame()) { | |
1721 return (JavaVFrame) vf; | |
1722 } | |
1723 return (JavaVFrame) vf.javaSender(); | |
1724 } | |
1725 | |
1726 // Internal routine for debugging | |
1727 private static void dumpStack(JavaThread cur) { | |
1728 RegisterMap regMap = cur.newRegisterMap(true); | |
1729 sun.jvm.hotspot.runtime.Frame f = cur.getCurrentFrameGuess(); | |
1730 PrintStream tty = System.err; | |
1731 while (f != null) { | |
1732 tty.print("Found "); | |
1733 if (f.isInterpretedFrame()) { tty.print("interpreted"); } | |
1734 else if (f.isCompiledFrame()) { tty.print("compiled"); } | |
1735 else if (f.isEntryFrame()) { tty.print("entry"); } | |
1736 else if (f.isNativeFrame()) { tty.print("native"); } | |
1737 else if (f.isGlueFrame()) { tty.print("glue"); } | |
1738 else { tty.print("external"); } | |
1739 tty.print(" frame with PC = " + f.getPC() + ", SP = " + f.getSP() + ", FP = " + f.getFP()); | |
1740 if (f.isSignalHandlerFrameDbg()) { | |
1741 tty.print(" (SIGNAL HANDLER)"); | |
1742 } | |
1743 tty.println(); | |
1744 | |
1745 if (!f.isFirstFrame()) { | |
1746 f = f.sender(regMap); | |
1747 } else { | |
1748 f = null; | |
1749 } | |
1750 } | |
1751 } | |
1752 | |
1753 //-------------------------------------------------------------------------------- | |
1754 // Component utilities | |
1755 // | |
1756 | |
1757 private static JMenuItem createMenuItem(String name, ActionListener l) { | |
1758 JMenuItem item = new JMenuItem(name); | |
1759 item.addActionListener(l); | |
1760 return item; | |
1761 } | |
1762 | |
1763 /** Punctuates the given string with \n's where necessary to not | |
1764 exceed the given number of characters per line. Strips | |
1765 extraneous whitespace. */ | |
1766 private String formatMessage(String message, int charsPerLine) { | |
1767 StringBuffer buf = new StringBuffer(message.length()); | |
1768 StringTokenizer tokenizer = new StringTokenizer(message); | |
1769 int curLineLength = 0; | |
1770 while (tokenizer.hasMoreTokens()) { | |
1771 String tok = tokenizer.nextToken(); | |
1772 if (curLineLength + tok.length() > charsPerLine) { | |
1773 buf.append('\n'); | |
1774 curLineLength = 0; | |
1775 } else { | |
1776 if (curLineLength != 0) { | |
1777 buf.append(' '); | |
1778 ++curLineLength; | |
1779 } | |
1780 } | |
1781 buf.append(tok); | |
1782 curLineLength += tok.length(); | |
1783 } | |
1784 return buf.toString(); | |
1785 } | |
1786 | |
1787 private void setMenuItemsEnabled(java.util.List items, boolean enabled) { | |
1788 for (Iterator iter = items.iterator(); iter.hasNext(); ) { | |
1789 ((JMenuItem) iter.next()).setEnabled(enabled); | |
1790 } | |
1791 } | |
1792 } |