hotspot/src/share/vm/services/heapDumper.cpp
author thurka
Sat, 11 Sep 2010 08:18:31 +0200
changeset 6445 64694b1e56e7
parent 5547 f4b087cbb361
child 7397 5b173b4ca846
permissions -rw-r--r--
6765718: Indicate which thread throwing OOME when generating the heap dump at OOME Summary: Emit a fake frame that makes it look like the thread is in the OutOfMemoryError zero-parameter constructor Reviewed-by: dcubed
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
     2
 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4571
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4571
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4571
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
# include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
# include "incls/_heapDumper.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
 * HPROF binary format - description copied from:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
 *   src/share/demo/jvmti/hprof/hprof_io.c
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
 *  header    "JAVA PROFILE 1.0.1" or "JAVA PROFILE 1.0.2"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
 *            (0-terminated)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
 *  u4        size of identifiers. Identifiers are used to represent
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
 *            UTF8 strings, objects, stack traces, etc. They usually
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
 *            have the same size as host pointers. For example, on
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
 *            Solaris and Win32, the size is 4.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
 * u4         high word
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
 * u4         low word    number of milliseconds since 0:00 GMT, 1/1/70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
 * [record]*  a sequence of records.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
 * Record format:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
 * u1         a TAG denoting the type of the record
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
 * u4         number of *microseconds* since the time stamp in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
 *            header. (wraps around in a little more than an hour)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
 * u4         number of bytes *remaining* in the record. Note that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
 *            this number excludes the tag and the length field itself.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
 * [u1]*      BODY of the record (a sequence of bytes)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
 * The following TAGs are supported:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
 * TAG           BODY       notes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
 *----------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
 * HPROF_UTF8               a UTF8-encoded name
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
 *               id         name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
 *               [u1]*      UTF8 characters (no trailing zero)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
 * HPROF_LOAD_CLASS         a newly loaded class
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
 *                u4        class serial number (> 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
 *                id        class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
 *                u4        stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
 *                id        class name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
 * HPROF_UNLOAD_CLASS       an unloading class
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
 *                u4        class serial_number
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
 * HPROF_FRAME              a Java stack frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
 *                id        stack frame ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
 *                id        method name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
 *                id        method signature ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
 *                id        source file name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
 *                u4        class serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
 *                i4        line number. >0: normal
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
 *                                       -1: unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
 *                                       -2: compiled method
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
 *                                       -3: native method
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
 * HPROF_TRACE              a Java stack trace
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
 *               u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
 *               u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
 *               u4         number of frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
 *               [id]*      stack frame IDs
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
 * HPROF_ALLOC_SITES        a set of heap allocation sites, obtained after GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
 *               u2         flags 0x0001: incremental vs. complete
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
 *                                0x0002: sorted by allocation vs. live
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
 *                                0x0004: whether to force a GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
 *               u4         cutoff ratio
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
 *               u4         total live bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
 *               u4         total live instances
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
 *               u8         total bytes allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
 *               u8         total instances allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
 *               u4         number of sites that follow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
 *               [u1        is_array: 0:  normal object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
 *                                    2:  object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
 *                                    4:  boolean array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
 *                                    5:  char array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
 *                                    6:  float array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
 *                                    7:  double array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
 *                                    8:  byte array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
 *                                    9:  short array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
 *                                    10: int array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
 *                                    11: long array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
 *                u4        class serial number (may be zero during startup)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
 *                u4        stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
 *                u4        number of bytes alive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
 *                u4        number of instances alive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
 *                u4        number of bytes allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
 *                u4]*      number of instance allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
 * HPROF_START_THREAD       a newly started thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
 *               u4         thread serial number (> 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
 *               id         thread object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
 *               u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
 *               id         thread name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
 *               id         thread group name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
 *               id         thread group parent name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
 * HPROF_END_THREAD         a terminating thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
 *               u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
 * HPROF_HEAP_SUMMARY       heap summary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
 *               u4         total live bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
 *               u4         total live instances
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
 *               u8         total bytes allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
 *               u8         total instances allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
 * HPROF_HEAP_DUMP          denote a heap dump
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
 *               [heap dump sub-records]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
 *                          There are four kinds of heap dump sub-records:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
 *               u1         sub-record type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
 *               HPROF_GC_ROOT_UNKNOWN         unknown root
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
 *               HPROF_GC_ROOT_THREAD_OBJ      thread object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
 *                          id         thread object ID  (may be 0 for a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
 *                                     thread newly attached through JNI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
 *                          u4         thread sequence number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
 *                          u4         stack trace sequence number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
 *               HPROF_GC_ROOT_JNI_GLOBAL      JNI global ref root
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
 *                          id         JNI global ref ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
 *               HPROF_GC_ROOT_JNI_LOCAL       JNI local ref
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
 *                          u4         frame # in stack trace (-1 for empty)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
 *               HPROF_GC_ROOT_JAVA_FRAME      Java stack frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
 *                          u4         frame # in stack trace (-1 for empty)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
 *               HPROF_GC_ROOT_NATIVE_STACK    Native stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
 *               HPROF_GC_ROOT_STICKY_CLASS    System class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
 *               HPROF_GC_ROOT_THREAD_BLOCK    Reference from thread block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
 *               HPROF_GC_ROOT_MONITOR_USED    Busy monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
 *               HPROF_GC_CLASS_DUMP           dump of a class object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
 *                          id         class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
 *                          id         super class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
 *                          id         class loader object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
 *                          id         signers object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
 *                          id         protection domain object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
 *                          id         reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
 *                          id         reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
 *                          u4         instance size (in bytes)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
 *                          u2         size of constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
 *                          [u2,       constant pool index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
 *                           ty,       type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
 *                                     2:  object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
 *                                     4:  boolean
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
 *                                     5:  char
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
 *                                     6:  float
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
 *                                     7:  double
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
 *                                     8:  byte
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
 *                                     9:  short
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
 *                                     10: int
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
 *                                     11: long
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
 *                           vl]*      and value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
 *                          u2         number of static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
 *                          [id,       static field name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
 *                           ty,       type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
 *                           vl]*      and value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
 *                          u2         number of inst. fields (not inc. super)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
 *                          [id,       instance field name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
 *                           ty]*      type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
 *               HPROF_GC_INSTANCE_DUMP        dump of a normal object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
 *                          id         class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
 *                          u4         number of bytes that follow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
 *                          [vl]*      instance field values (class, followed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
 *                                     by super, super's super ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
 *               HPROF_GC_OBJ_ARRAY_DUMP       dump of an object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
 *                          id         array object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
 *                          u4         number of elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
 *                          id         array class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
 *                          [id]*      elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
 *               HPROF_GC_PRIM_ARRAY_DUMP      dump of a primitive array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
 *                          id         array object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
 *                          u4         number of elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
 *                          u1         element type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
 *                                     4:  boolean array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
 *                                     5:  char array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
 *                                     6:  float array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
 *                                     7:  double array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
 *                                     8:  byte array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
 *                                     9:  short array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
 *                                     10: int array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
 *                                     11: long array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
 *                          [u1]*      elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
 * HPROF_CPU_SAMPLES        a set of sample traces of running threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
 *                u4        total number of samples
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
 *                u4        # of traces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
 *               [u4        # of samples
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
 *                u4]*      stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
 * HPROF_CONTROL_SETTINGS   the settings of on/off switches
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
 *                u4        0x00000001: alloc traces on/off
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
 *                          0x00000002: cpu sampling on/off
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
 *                u2        stack trace depth
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
 * When the header is "JAVA PROFILE 1.0.2" a heap dump can optionally
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
 * be generated as a sequence of heap dump segments. This sequence is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
 * terminated by an end record. The additional tags allowed by format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
 * "JAVA PROFILE 1.0.2" are:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
 * HPROF_HEAP_DUMP_SEGMENT  denote a heap dump segment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
 *               [heap dump sub-records]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
 *               The same sub-record types allowed by HPROF_HEAP_DUMP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
 * HPROF_HEAP_DUMP_END      denotes the end of a heap dump
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
// HPROF tags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
typedef enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  // top-level records
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  HPROF_UTF8                    = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  HPROF_LOAD_CLASS              = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  HPROF_UNLOAD_CLASS            = 0x03,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  HPROF_FRAME                   = 0x04,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  HPROF_TRACE                   = 0x05,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  HPROF_ALLOC_SITES             = 0x06,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  HPROF_HEAP_SUMMARY            = 0x07,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  HPROF_START_THREAD            = 0x0A,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  HPROF_END_THREAD              = 0x0B,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  HPROF_HEAP_DUMP               = 0x0C,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  HPROF_CPU_SAMPLES             = 0x0D,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  HPROF_CONTROL_SETTINGS        = 0x0E,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  // 1.0.2 record types
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  HPROF_HEAP_DUMP_SEGMENT       = 0x1C,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  HPROF_HEAP_DUMP_END           = 0x2C,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  // field types
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  HPROF_ARRAY_OBJECT            = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  HPROF_NORMAL_OBJECT           = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  HPROF_BOOLEAN                 = 0x04,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  HPROF_CHAR                    = 0x05,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  HPROF_FLOAT                   = 0x06,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  HPROF_DOUBLE                  = 0x07,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  HPROF_BYTE                    = 0x08,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  HPROF_SHORT                   = 0x09,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  HPROF_INT                     = 0x0A,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  HPROF_LONG                    = 0x0B,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // data-dump sub-records
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  HPROF_GC_ROOT_UNKNOWN         = 0xFF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  HPROF_GC_ROOT_JNI_GLOBAL      = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  HPROF_GC_ROOT_JNI_LOCAL       = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  HPROF_GC_ROOT_JAVA_FRAME      = 0x03,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  HPROF_GC_ROOT_NATIVE_STACK    = 0x04,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  HPROF_GC_ROOT_STICKY_CLASS    = 0x05,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  HPROF_GC_ROOT_THREAD_BLOCK    = 0x06,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  HPROF_GC_ROOT_MONITOR_USED    = 0x07,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  HPROF_GC_ROOT_THREAD_OBJ      = 0x08,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  HPROF_GC_CLASS_DUMP           = 0x20,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  HPROF_GC_INSTANCE_DUMP        = 0x21,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  HPROF_GC_OBJ_ARRAY_DUMP       = 0x22,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  HPROF_GC_PRIM_ARRAY_DUMP      = 0x23
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
} hprofTag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
// Default stack trace ID (used for dummy HPROF_TRACE record)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
enum {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   346
  STACK_TRACE_ID = 1,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   347
  INITIAL_CLASS_COUNT = 200
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
// Supports I/O operations on a dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
class DumpWriter : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    io_buffer_size  = 8*M
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  int _fd;              // file descriptor (-1 if dump file not open)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  jlong _bytes_written; // number of byte written to dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  char* _buffer;    // internal buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  int _size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  int _pos;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  char* _error;   // error message when I/O fails
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  void set_file_descriptor(int fd)              { _fd = fd; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  int file_descriptor() const                   { return _fd; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  char* buffer() const                          { return _buffer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  int buffer_size() const                       { return _size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  int position() const                          { return _pos; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  void set_position(int pos)                    { _pos = pos; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  void set_error(const char* error)             { _error = (char*)os::strdup(error); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  // all I/O go through this function
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  void write_internal(void* s, int len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  DumpWriter(const char* path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  ~DumpWriter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  void close();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  bool is_open() const                  { return file_descriptor() >= 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  void flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  // total number of bytes written to the disk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  jlong bytes_written() const           { return _bytes_written; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  // adjust the number of bytes written to disk (used to keep the count
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  // of the number of bytes written in case of rewrites)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  void adjust_bytes_written(jlong n)     { _bytes_written += n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  // number of (buffered) bytes as yet unwritten to the dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  jlong bytes_unwritten() const          { return (jlong)position(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  char* error() const                   { return _error; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  jlong current_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  void seek_to_offset(jlong pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  // writer functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  void write_raw(void* s, int len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  void write_u1(u1 x)                   { write_raw((void*)&x, 1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  void write_u2(u2 x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  void write_u4(u4 x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  void write_u8(u8 x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  void write_objectID(oop o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  void write_classID(Klass* k);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   411
  void write_id(u4 x);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
DumpWriter::DumpWriter(const char* path) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  // try to allocate an I/O buffer of io_buffer_size. If there isn't
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  // sufficient memory then reduce size until we can allocate something.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  _size = io_buffer_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
    _buffer = (char*)os::malloc(_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    if (_buffer == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
      _size = _size >> 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  } while (_buffer == NULL && _size > 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  assert((_size > 0 && _buffer != NULL) || (_size == 0 && _buffer == NULL), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  _pos = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  _error = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  _bytes_written = 0L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  _fd = os::create_binary_file(path, false);    // don't replace existing file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  // if the open failed we record the error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  if (_fd < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
    _error = (char*)os::strdup(strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
DumpWriter::~DumpWriter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // flush and close dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  if (file_descriptor() >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
    close();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  if (_buffer != NULL) os::free(_buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  if (_error != NULL) os::free(_error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
// closes dump file (if open)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
void DumpWriter::close() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // flush and close dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  if (file_descriptor() >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
    flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
    ::close(file_descriptor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
// write directly to the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
void DumpWriter::write_internal(void* s, int len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
    int n = ::write(file_descriptor(), s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
    if (n > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
      _bytes_written += n;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
    if (n != len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
      if (n < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
        set_error(strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
        set_error("file size limit");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
      ::close(file_descriptor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
      set_file_descriptor(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
// write raw bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
void DumpWriter::write_raw(void* s, int len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    // flush buffer to make toom
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    if ((position()+ len) >= buffer_size()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
      flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
    // buffer not available or too big to buffer it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    if ((buffer() == NULL) || (len >= buffer_size())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
      write_internal(s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
      // Should optimize this for u1/u2/u4/u8 sizes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
      memcpy(buffer() + position(), s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
      set_position(position() + len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
// flush any buffered bytes to the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
void DumpWriter::flush() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  if (is_open() && position() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
    write_internal(buffer(), position());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    set_position(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
jlong DumpWriter::current_offset() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
    // the offset is the file offset plus whatever we have buffered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    jlong offset = os::current_file_offset(file_descriptor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
    assert(offset >= 0, "lseek failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    return offset + (jlong)position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
    return (jlong)-1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
void DumpWriter::seek_to_offset(jlong off) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  assert(off >= 0, "bad offset");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  // need to flush before seeking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  // may be closed due to I/O error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    jlong n = os::seek_to_file_offset(file_descriptor(), off);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    assert(n >= 0, "lseek failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
void DumpWriter::write_u2(u2 x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  u2 v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  Bytes::put_Java_u2((address)&v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  write_raw((void*)&v, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
void DumpWriter::write_u4(u4 x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  u4 v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  Bytes::put_Java_u4((address)&v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  write_raw((void*)&v, 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
void DumpWriter::write_u8(u8 x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  u8 v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  Bytes::put_Java_u8((address)&v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  write_raw((void*)&v, 8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
void DumpWriter::write_objectID(oop o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  address a = (address)((uintptr_t)o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  write_u8((u8)a);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  write_u4((u4)a);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   552
void DumpWriter::write_id(u4 x) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   553
#ifdef _LP64
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   554
  write_u8((u8) x);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   555
#else
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   556
  write_u4(x);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   557
#endif
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   558
}
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   559
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
// We use java mirror as the class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
void DumpWriter::write_classID(Klass* k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  write_objectID(k->java_mirror());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
// Support class with a collection of functions used when dumping the heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
class DumperSupport : AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  // write a header of the given type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  static void write_header(DumpWriter* writer, hprofTag tag, u4 len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  // returns hprof tag for the given type signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  static hprofTag sig2tag(symbolOop sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  // returns hprof tag for the given basic type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  static hprofTag type2tag(BasicType type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  // returns the size of the instance of the given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  static u4 instance_size(klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  // dump a jfloat
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  static void dump_float(DumpWriter* writer, jfloat f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  // dump a jdouble
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  static void dump_double(DumpWriter* writer, jdouble d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  // dumps the raw value of the given field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  static void dump_field_value(DumpWriter* writer, char type, address addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  // dumps static fields of the given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  static void dump_static_fields(DumpWriter* writer, klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  // dump the raw values of the instance fields of the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  static void dump_instance_fields(DumpWriter* writer, oop o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  // dumps the definition of the instance fields for a given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  static void dump_instance_field_descriptors(DumpWriter* writer, klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  // creates HPROF_GC_INSTANCE_DUMP record for the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  static void dump_instance(DumpWriter* writer, oop o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  // creates HPROF_GC_CLASS_DUMP record for the given class and each of its
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  // array classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  static void dump_class_and_array_classes(DumpWriter* writer, klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  // creates HPROF_GC_CLASS_DUMP record for a given primitive array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  // class (and each multi-dimensional array class too)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  static void dump_basic_type_array_class(DumpWriter* writer, klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  // creates HPROF_GC_OBJ_ARRAY_DUMP record for the given object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  static void dump_object_array(DumpWriter* writer, objArrayOop array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  // creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  static void dump_prim_array(DumpWriter* writer, typeArrayOop array);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   608
  // create HPROF_FRAME record for the given method and bci
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   609
  static void dump_stack_frame(DumpWriter* writer, int frame_serial_num, int class_serial_num, methodOop m, int bci);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
// write a header of the given type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
void DumperSupport:: write_header(DumpWriter* writer, hprofTag tag, u4 len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  writer->write_u1((u1)tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  writer->write_u4(0);                  // current ticks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  writer->write_u4(len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
// returns hprof tag for the given type signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
hprofTag DumperSupport::sig2tag(symbolOop sig) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  switch (sig->byte_at(0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
    case JVM_SIGNATURE_CLASS    : return HPROF_NORMAL_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    case JVM_SIGNATURE_ARRAY    : return HPROF_NORMAL_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
    case JVM_SIGNATURE_BYTE     : return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
    case JVM_SIGNATURE_CHAR     : return HPROF_CHAR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
    case JVM_SIGNATURE_FLOAT    : return HPROF_FLOAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
    case JVM_SIGNATURE_DOUBLE   : return HPROF_DOUBLE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
    case JVM_SIGNATURE_INT      : return HPROF_INT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    case JVM_SIGNATURE_LONG     : return HPROF_LONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    case JVM_SIGNATURE_SHORT    : return HPROF_SHORT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    case JVM_SIGNATURE_BOOLEAN  : return HPROF_BOOLEAN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
    default : ShouldNotReachHere(); /* to shut up compiler */ return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
hprofTag DumperSupport::type2tag(BasicType type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  switch (type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
    case T_BYTE     : return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
    case T_CHAR     : return HPROF_CHAR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    case T_FLOAT    : return HPROF_FLOAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    case T_DOUBLE   : return HPROF_DOUBLE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
    case T_INT      : return HPROF_INT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    case T_LONG     : return HPROF_LONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    case T_SHORT    : return HPROF_SHORT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    case T_BOOLEAN  : return HPROF_BOOLEAN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    default : ShouldNotReachHere(); /* to shut up compiler */ return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
// dump a jfloat
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
void DumperSupport::dump_float(DumpWriter* writer, jfloat f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  if (g_isnan(f)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
    writer->write_u4(0x7fc00000);    // collapsing NaNs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    union {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
      int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
      float f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    } u;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
    u.f = (float)f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
    writer->write_u4((u4)u.i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
// dump a jdouble
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
void DumperSupport::dump_double(DumpWriter* writer, jdouble d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  union {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    jlong l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    double d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  } u;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  if (g_isnan(d)) {                 // collapsing NaNs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    u.l = (jlong)(0x7ff80000);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    u.l = (u.l << 32);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    u.d = (double)d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  writer->write_u8((u8)u.l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
// dumps the raw value of the given field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
void DumperSupport::dump_field_value(DumpWriter* writer, char type, address addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  switch (type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    case JVM_SIGNATURE_CLASS :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    case JVM_SIGNATURE_ARRAY : {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   684
      oop o;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   685
      if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   686
        o = oopDesc::load_decode_heap_oop((narrowOop*)addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   687
      } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   688
        o = oopDesc::load_decode_heap_oop((oop*)addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   689
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
      // reflection and sun.misc.Unsafe classes may have a reference to a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
      // klassOop so filter it out.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
      if (o != NULL && o->is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
        o = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
      // FIXME: When sharing is enabled we don't emit field references to objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
      // in shared spaces. We can remove this once we write records for the classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
      // and strings that are shared.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
      if (o != NULL && o->is_shared()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
        o = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
      writer->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
    case JVM_SIGNATURE_BYTE     : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
      jbyte* b = (jbyte*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
      writer->write_u1((u1)*b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    case JVM_SIGNATURE_CHAR     : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
      jchar* c = (jchar*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
      writer->write_u2((u2)*c);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    case JVM_SIGNATURE_SHORT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
      jshort* s = (jshort*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
      writer->write_u2((u2)*s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
    case JVM_SIGNATURE_FLOAT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
      jfloat* f = (jfloat*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
      dump_float(writer, *f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
    case JVM_SIGNATURE_DOUBLE : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
      jdouble* f = (jdouble*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
      dump_double(writer, *f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
    case JVM_SIGNATURE_INT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
      jint* i = (jint*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
      writer->write_u4((u4)*i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
    case JVM_SIGNATURE_LONG     : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
      jlong* l = (jlong*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
      writer->write_u8((u8)*l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    case JVM_SIGNATURE_BOOLEAN : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
      jboolean* b = (jboolean*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
      writer->write_u1((u1)*b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
// returns the size of the instance of the given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
u4 DumperSupport::instance_size(klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  int size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  for (FieldStream fld(ikh, false, false); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
    if (!fld.access_flags().is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
      symbolOop sig = fld.signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
      switch (sig->byte_at(0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
        case JVM_SIGNATURE_CLASS   :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
        case JVM_SIGNATURE_ARRAY   : size += oopSize; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
        case JVM_SIGNATURE_BYTE    :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
        case JVM_SIGNATURE_BOOLEAN : size += 1; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
        case JVM_SIGNATURE_CHAR    :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
        case JVM_SIGNATURE_SHORT   : size += 2; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
        case JVM_SIGNATURE_INT     :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
        case JVM_SIGNATURE_FLOAT   : size += 4; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
        case JVM_SIGNATURE_LONG    :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
        case JVM_SIGNATURE_DOUBLE  : size += 8; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
        default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  return (u4)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
// dumps static fields of the given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
void DumperSupport::dump_static_fields(DumpWriter* writer, klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  // pass 1 - count the static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  u2 field_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  for (FieldStream fldc(ikh, true, true); !fldc.eos(); fldc.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    if (fldc.access_flags().is_static()) field_count++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  writer->write_u2(field_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  // pass 2 - dump the field descriptors and raw values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  for (FieldStream fld(ikh, true, true); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    if (fld.access_flags().is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
      symbolOop sig = fld.signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
      writer->write_objectID(fld.name());   // name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
      writer->write_u1(sig2tag(sig));       // type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
      // value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
      int offset = fld.offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
      address addr = (address)k + offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
      dump_field_value(writer, sig->byte_at(0), addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
// dump the raw values of the instance fields of the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
void DumperSupport::dump_instance_fields(DumpWriter* writer, oop o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), o->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  for (FieldStream fld(ikh, false, false); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
    if (!fld.access_flags().is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
      symbolOop sig = fld.signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
      address addr = (address)o + fld.offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
      dump_field_value(writer, sig->byte_at(0), addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
// dumps the definition of the instance fields for a given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
void DumperSupport::dump_instance_field_descriptors(DumpWriter* writer, klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  // pass 1 - count the instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  u2 field_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  for (FieldStream fldc(ikh, true, true); !fldc.eos(); fldc.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
    if (!fldc.access_flags().is_static()) field_count++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  writer->write_u2(field_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  // pass 2 - dump the field descriptors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  for (FieldStream fld(ikh, true, true); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    if (!fld.access_flags().is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
      symbolOop sig = fld.signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
      writer->write_objectID(fld.name());                   // name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
      writer->write_u1(sig2tag(sig));       // type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
// creates HPROF_GC_INSTANCE_DUMP record for the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
void DumperSupport::dump_instance(DumpWriter* writer, oop o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  klassOop k = o->klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  writer->write_u1(HPROF_GC_INSTANCE_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  writer->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  // class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  writer->write_classID(Klass::cast(k));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  // number of bytes that follow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  writer->write_u4(instance_size(k) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  // field values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  dump_instance_fields(writer, o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
// creates HPROF_GC_CLASS_DUMP record for the given class and each of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
// its array classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
void DumperSupport::dump_class_and_array_classes(DumpWriter* writer, klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  Klass* klass = Klass::cast(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  assert(klass->oop_is_instance(), "not an instanceKlass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  instanceKlass* ik = (instanceKlass*)klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  writer->write_u1(HPROF_GC_CLASS_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  // class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  writer->write_classID(ik);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  // super class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  klassOop java_super = ik->java_super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  if (java_super == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
    writer->write_objectID(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
    writer->write_classID(Klass::cast(java_super));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  writer->write_objectID(ik->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  writer->write_objectID(ik->signers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  writer->write_objectID(ik->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  // reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  writer->write_objectID(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  writer->write_objectID(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  // instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  writer->write_u4(DumperSupport::instance_size(k));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
  // size of constant pool - ignored by HAT 1.1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  writer->write_u2(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  // number of static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  dump_static_fields(writer, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  // description of instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  dump_instance_field_descriptors(writer, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  // array classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  while (k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
    Klass* klass = Klass::cast(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
    assert(klass->oop_is_objArray(), "not an objArrayKlass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
    writer->write_u1(HPROF_GC_CLASS_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
    writer->write_classID(klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
    writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
    // super class of array classes is java.lang.Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
    java_super = klass->java_super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
    assert(java_super != NULL, "checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
    writer->write_classID(Klass::cast(java_super));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
    writer->write_objectID(ik->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
    writer->write_objectID(ik->signers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
    writer->write_objectID(ik->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
    writer->write_objectID(NULL);    // reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
    writer->write_objectID(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
    writer->write_u4(0);             // instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
    writer->write_u2(0);             // constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
    writer->write_u2(0);             // static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
    writer->write_u2(0);             // instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
    // get the array class for the next rank
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
    k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
// creates HPROF_GC_CLASS_DUMP record for a given primitive array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
// class (and each multi-dimensional array class too)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
void DumperSupport::dump_basic_type_array_class(DumpWriter* writer, klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
 // array classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
 while (k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
    Klass* klass = Klass::cast(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
    writer->write_u1(HPROF_GC_CLASS_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
    writer->write_classID(klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
    writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
    // super class of array classes is java.lang.Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
    klassOop java_super = klass->java_super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
    assert(java_super != NULL, "checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
    writer->write_classID(Klass::cast(java_super));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
    writer->write_objectID(NULL);    // loader
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
    writer->write_objectID(NULL);    // signers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
    writer->write_objectID(NULL);    // protection domain
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    writer->write_objectID(NULL);    // reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
    writer->write_objectID(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
    writer->write_u4(0);             // instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
    writer->write_u2(0);             // constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
    writer->write_u2(0);             // static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
    writer->write_u2(0);             // instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
    // get the array class for the next rank
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
    k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
// creates HPROF_GC_OBJ_ARRAY_DUMP record for the given object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
void DumperSupport::dump_object_array(DumpWriter* writer, objArrayOop array) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  // filter this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  if (array->klass() == Universe::systemObjArrayKlassObj()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  writer->write_u1(HPROF_GC_OBJ_ARRAY_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  writer->write_objectID(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
  writer->write_u4((u4)array->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  // array class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  writer->write_classID(Klass::cast(array->klass()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  // [id]* elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  for (int index=0; index<array->length(); index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
    oop o = array->obj_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    writer->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
#define WRITE_ARRAY(Array, Type, Size) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  for (int i=0; i<Array->length(); i++) { writer->write_##Size((Size)array->Type##_at(i)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
// creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
void DumperSupport::dump_prim_array(DumpWriter* writer, typeArrayOop array) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  BasicType type = typeArrayKlass::cast(array->klass())->element_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  writer->write_u1(HPROF_GC_PRIM_ARRAY_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  writer->write_objectID(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  writer->write_u4((u4)array->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  writer->write_u1(type2tag(type));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  // nothing to copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  if (array->length() == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  // If the byte ordering is big endian then we can copy most types directly
202
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
  1015
  int length_in_bytes = array->length() * type2aelembytes(type);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  assert(length_in_bytes > 0, "nothing to copy");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  switch (type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
    case T_INT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
        WRITE_ARRAY(array, int, u4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
        writer->write_raw((void*)(array->int_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
    case T_BYTE : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
      writer->write_raw((void*)(array->byte_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
    case T_CHAR : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
        WRITE_ARRAY(array, char, u2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
        writer->write_raw((void*)(array->char_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
    case T_SHORT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
        WRITE_ARRAY(array, short, u2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
        writer->write_raw((void*)(array->short_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
    case T_BOOLEAN : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
        WRITE_ARRAY(array, bool, u1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
        writer->write_raw((void*)(array->bool_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
    case T_LONG : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
        WRITE_ARRAY(array, long, u8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
        writer->write_raw((void*)(array->long_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
    // handle float/doubles in a special value to ensure than NaNs are
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
    // written correctly. TO DO: Check if we can avoid this on processors that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
    // use IEEE 754.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
    case T_FLOAT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
      for (int i=0; i<array->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
        dump_float( writer, array->float_at(i) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
    case T_DOUBLE : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
      for (int i=0; i<array->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
        dump_double( writer, array->double_at(i) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
    default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1084
// create a HPROF_FRAME record of the given methodOop and bci
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1085
void DumperSupport::dump_stack_frame(DumpWriter* writer,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1086
                                     int frame_serial_num,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1087
                                     int class_serial_num,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1088
                                     methodOop m,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1089
                                     int bci) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1090
  int line_number;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1091
  if (m->is_native()) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1092
    line_number = -3;  // native frame
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1093
  } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1094
    line_number = m->line_number_from_bci(bci);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1095
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1096
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1097
  write_header(writer, HPROF_FRAME, 4*oopSize + 2*sizeof(u4));
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1098
  writer->write_id(frame_serial_num);               // frame serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1099
  writer->write_objectID(m->name());                // method's name
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1100
  writer->write_objectID(m->signature());           // method's signature
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1101
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1102
  assert(Klass::cast(m->method_holder())->oop_is_instance(), "not instanceKlass");
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1103
  writer->write_objectID(instanceKlass::cast(m->method_holder())->source_file_name());  // source file name
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1104
  writer->write_u4(class_serial_num);               // class serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1105
  writer->write_u4((u4) line_number);               // line number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1106
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
// Support class used to generate HPROF_UTF8 records from the entries in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
// SymbolTable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
class SymbolTableDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  SymbolTableDumper(DumpWriter* writer)     { _writer = writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  void do_oop(oop* obj_p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1118
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
void SymbolTableDumper::do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
  symbolOop sym = (symbolOop)*obj_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  int len = sym->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  if (len > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
    char* s = sym->as_utf8();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
    DumperSupport::write_header(writer(), HPROF_UTF8, oopSize + len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
    writer()->write_objectID(sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
    writer()->write_raw(s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
// Support class used to generate HPROF_GC_ROOT_JNI_LOCAL records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
class JNILocalsDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  u4 _thread_serial_num;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1141
  int _frame_num;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  JNILocalsDumper(DumpWriter* writer, u4 thread_serial_num) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
    _thread_serial_num = thread_serial_num;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1147
    _frame_num = -1;  // default - empty stack
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1149
  void set_frame_number(int n) { _frame_num = n; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
  void do_oop(oop* obj_p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1151
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
void JNILocalsDumper::do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  // ignore null or deleted handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  oop o = *obj_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
  if (o != NULL && o != JNIHandles::deleted_handle()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
    writer()->write_u1(HPROF_GC_ROOT_JNI_LOCAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
    writer()->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
    writer()->write_u4(_thread_serial_num);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1162
    writer()->write_u4((u4)_frame_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
// Support class used to generate HPROF_GC_ROOT_JNI_GLOBAL records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
class JNIGlobalsDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  JNIGlobalsDumper(DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  void do_oop(oop* obj_p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1179
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
void JNIGlobalsDumper::do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  oop o = *obj_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  // ignore these
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
  if (o == NULL || o == JNIHandles::deleted_handle()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  // we ignore global ref to symbols and other internal objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  if (o->is_instance() || o->is_objArray() || o->is_typeArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
    writer()->write_u1(HPROF_GC_ROOT_JNI_GLOBAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
    writer()->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
    writer()->write_objectID((oopDesc*)obj_p);      // global ref ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
// Support class used to generate HPROF_GC_ROOT_MONITOR_USED records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
class MonitorUsedDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  MonitorUsedDumper(DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
  void do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
    writer()->write_u1(HPROF_GC_ROOT_MONITOR_USED);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
    writer()->write_objectID(*obj_p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1211
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
// Support class used to generate HPROF_GC_ROOT_STICKY_CLASS records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
class StickyClassDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
  StickyClassDumper(DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
  void do_oop(oop* obj_p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1226
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
void StickyClassDumper::do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
  if (*obj_p != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
    oop o = *obj_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
    if (o->is_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
      klassOop k = klassOop(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
      if (Klass::cast(k)->oop_is_instance()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
        instanceKlass* ik = instanceKlass::cast(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
        writer()->write_u1(HPROF_GC_ROOT_STICKY_CLASS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
        writer()->write_classID(ik);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
class VM_HeapDumper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
// Support class using when iterating over the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
class HeapObjectDumper : public ObjectClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
  VM_HeapDumper* _dumper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  VM_HeapDumper* dumper()               { return _dumper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  DumpWriter* writer()                  { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  // used to indicate that a record has been writen
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  void mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  HeapObjectDumper(VM_HeapDumper* dumper, DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
    _dumper = dumper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  // called for each object in the heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
  void do_object(oop o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
void HeapObjectDumper::do_object(oop o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
  // hide the sentinel for deleted handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
  if (o == JNIHandles::deleted_handle()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  // ignore KlassKlass objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  if (o->is_klass()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
  // skip classes as these emitted as HPROF_GC_CLASS_DUMP records
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4101
diff changeset
  1277
  if (o->klass() == SystemDictionary::Class_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
    if (!java_lang_Class::is_primitive(o)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  // create a HPROF_GC_INSTANCE record for each object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  if (o->is_instance()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
    DumperSupport::dump_instance(writer(), o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
    mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
    // create a HPROF_GC_OBJ_ARRAY_DUMP record for each object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
    if (o->is_objArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
      DumperSupport::dump_object_array(writer(), objArrayOop(o));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
      mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
      // create a HPROF_GC_PRIM_ARRAY_DUMP record for each type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
      if (o->is_typeArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
        DumperSupport::dump_prim_array(writer(), typeArrayOop(o));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
        mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
// The VM operation that performs the heap dump
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
class VM_HeapDumper : public VM_GC_Operation {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
 private:
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1305
  static VM_HeapDumper* _global_dumper;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1306
  static DumpWriter*    _global_writer;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1307
  DumpWriter*           _local_writer;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1308
  JavaThread*           _oome_thread;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1309
  methodOop             _oome_constructor;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
  bool _gc_before_heap_dump;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
  bool _is_segmented_dump;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  jlong _dump_start;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1313
  GrowableArray<Klass*>* _klass_map;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1314
  ThreadStackTrace** _stack_traces;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1315
  int _num_threads;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1317
  // accessors and setters
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1318
  static VM_HeapDumper* dumper()         {  assert(_global_dumper != NULL, "Error"); return _global_dumper; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1319
  static DumpWriter* writer()            {  assert(_global_writer != NULL, "Error"); return _global_writer; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1320
  void set_global_dumper() {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1321
    assert(_global_dumper == NULL, "Error");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1322
    _global_dumper = this;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1323
  }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1324
  void set_global_writer() {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1325
    assert(_global_writer == NULL, "Error");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1326
    _global_writer = _local_writer;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1327
  }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1328
  void clear_global_dumper() { _global_dumper = NULL; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1329
  void clear_global_writer() { _global_writer = NULL; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1330
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  bool is_segmented_dump() const                { return _is_segmented_dump; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  void set_segmented_dump()                     { _is_segmented_dump = true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
  jlong dump_start() const                      { return _dump_start; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  void set_dump_start(jlong pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  bool skip_operation() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
  // writes a HPROF_LOAD_CLASS record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
  static void do_load_class(klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
  // writes a HPROF_GC_CLASS_DUMP record for the given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  // (and each array class too)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  static void do_class_dump(klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
  // writes a HPROF_GC_CLASS_DUMP records for a given basic type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
  // array (and each multi-dimensional array too)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  static void do_basic_type_array_class_dump(klassOop k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
  // HPROF_GC_ROOT_THREAD_OBJ records
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1350
  int do_thread(JavaThread* thread, u4 thread_serial_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
  void do_threads();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1353
  void add_class_serial_number(Klass* k, int serial_num) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1354
    _klass_map->at_put_grow(serial_num, k);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1355
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1356
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1357
  // HPROF_TRACE and HPROF_FRAME records
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1358
  void dump_stack_traces();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1359
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  // writes a HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  void write_dump_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  // fixes up the length of the current dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  void write_current_dump_record_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  // fixes up the current dump record )and writes HPROF_HEAP_DUMP_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  // record in the case of a segmented heap dump)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  void end_of_dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
 public:
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1371
  VM_HeapDumper(DumpWriter* writer, bool gc_before_heap_dump, bool oome) :
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
    VM_GC_Operation(0 /* total collections,      dummy, ignored */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
                    0 /* total full collections, dummy, ignored */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
                    gc_before_heap_dump) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1375
    _local_writer = writer;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
    _gc_before_heap_dump = gc_before_heap_dump;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
    _is_segmented_dump = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
    _dump_start = (jlong)-1;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1379
    _klass_map = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(INITIAL_CLASS_COUNT, true);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1380
    _stack_traces = NULL;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1381
    _num_threads = 0;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1382
    if (oome) {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1383
      assert(!Thread::current()->is_VM_thread(), "Dump from OutOfMemoryError cannot be called by the VMThread");
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1384
      // get OutOfMemoryError zero-parameter constructor
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1385
      instanceKlass* oome_ik = instanceKlass::cast(SystemDictionary::OutOfMemoryError_klass());
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1386
      _oome_constructor = oome_ik->find_method(vmSymbols::object_initializer_name(),
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1387
                                                          vmSymbols::void_method_signature());
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1388
      // get thread throwing OOME when generating the heap dump at OOME
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1389
      _oome_thread = JavaThread::current();
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1390
    } else {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1391
      _oome_thread = NULL;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1392
      _oome_constructor = NULL;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1393
    }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1394
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1395
  ~VM_HeapDumper() {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1396
    if (_stack_traces != NULL) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1397
      for (int i=0; i < _num_threads; i++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1398
        delete _stack_traces[i];
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1399
      }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1400
      FREE_C_HEAP_ARRAY(ThreadStackTrace*, _stack_traces);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1401
    }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1402
    delete _klass_map;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
  VMOp_Type type() const { return VMOp_HeapDumper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  // used to mark sub-record boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  void check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  void doit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1411
VM_HeapDumper* VM_HeapDumper::_global_dumper = NULL;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1412
DumpWriter*    VM_HeapDumper::_global_writer = NULL;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1413
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
bool VM_HeapDumper::skip_operation() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
// sets the dump starting position
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
void VM_HeapDumper::set_dump_start(jlong pos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
  _dump_start = pos;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
 // writes a HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
void VM_HeapDumper::write_dump_header() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
    if (is_segmented_dump()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
      writer()->write_u1(HPROF_HEAP_DUMP_SEGMENT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
      writer()->write_u1(HPROF_HEAP_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
    writer()->write_u4(0); // current ticks
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
    // record the starting position for the dump (its length will be fixed up later)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
    set_dump_start(writer()->current_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
    writer()->write_u4(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
// fixes up the length of the current dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
void VM_HeapDumper::write_current_dump_record_length() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
    assert(dump_start() >= 0, "no dump start recorded");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
    // calculate the size of the dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
    jlong dump_end = writer()->current_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
    jlong dump_len = (dump_end - dump_start() - 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
    // record length must fit in a u4
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
    if (dump_len > (jlong)(4L*(jlong)G)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
      warning("record is too large");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
    // seek to the dump start and fix-up the length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
    writer()->seek_to_offset(dump_start());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
    writer()->write_u4((u4)dump_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    // adjust the total size written to keep the bytes written correct.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
    writer()->adjust_bytes_written(-((long) sizeof(u4)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
    // seek to dump end so we can continue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
    writer()->seek_to_offset(dump_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
    // no current dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
    set_dump_start((jlong)-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
// used on a sub-record boundary to check if we need to start a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
// new segment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
void VM_HeapDumper::check_segment_length() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
    if (is_segmented_dump()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
      // don't use current_offset that would be too expensive on a per record basis
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
      jlong dump_end = writer()->bytes_written() + writer()->bytes_unwritten();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
      assert(dump_end == writer()->current_offset(), "checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
      jlong dump_len = (dump_end - dump_start() - 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
      assert(dump_len >= 0 && dump_len <= max_juint, "bad dump length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
      if (dump_len > (jlong)HeapDumpSegmentSize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
        write_current_dump_record_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
        write_dump_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
// fixes up the current dump record )and writes HPROF_HEAP_DUMP_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
// record in the case of a segmented heap dump)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
void VM_HeapDumper::end_of_dump() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
    write_current_dump_record_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
    // for segmented dump we write the end record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
    if (is_segmented_dump()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
      writer()->write_u1(HPROF_HEAP_DUMP_END);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
      writer()->write_u4(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
      writer()->write_u4(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
// marks sub-record boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
void HeapObjectDumper::mark_end_of_record() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
  dumper()->check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
// writes a HPROF_LOAD_CLASS record for the class (and each of its
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
// array classes)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
void VM_HeapDumper::do_load_class(klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
  static u4 class_serial_num = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  // len of HPROF_LOAD_CLASS record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
  u4 remaining = 2*oopSize + 2*sizeof(u4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
  // write a HPROF_LOAD_CLASS for the class and each array class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
  do {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1517
    DumperSupport::write_header(writer(), HPROF_LOAD_CLASS, remaining);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
    // class serial number is just a number
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1520
    writer()->write_u4(++class_serial_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
    // class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
    Klass* klass = Klass::cast(k);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1524
    writer()->write_classID(klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1526
    // add the klassOop and class serial number pair
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1527
    dumper()->add_class_serial_number(klass, class_serial_num);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1528
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1529
    writer()->write_u4(STACK_TRACE_ID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
    // class name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    symbolOop name = klass->name();
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1533
    writer()->write_objectID(name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
    // write a LOAD_CLASS record for the array type (if it exists)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
  } while (k != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
// writes a HPROF_GC_CLASS_DUMP record for the given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
void VM_HeapDumper::do_class_dump(klassOop k) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1542
  DumperSupport::dump_class_and_array_classes(writer(), k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
// writes a HPROF_GC_CLASS_DUMP records for a given basic type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
// array (and each multi-dimensional array too)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
void VM_HeapDumper::do_basic_type_array_class_dump(klassOop k) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1548
  DumperSupport::dump_basic_type_array_class(writer(), k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
// Walk the stack of the given thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
// Dumps a HPROF_GC_ROOT_JAVA_FRAME record for each local
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
// Dumps a HPROF_GC_ROOT_JNI_LOCAL record for each JNI local
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1554
//
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1555
// It returns the number of Java frames in this thread stack
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1556
int VM_HeapDumper::do_thread(JavaThread* java_thread, u4 thread_serial_num) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
  JNILocalsDumper blk(writer(), thread_serial_num);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
  oop threadObj = java_thread->threadObj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
  assert(threadObj != NULL, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1562
  int stack_depth = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
  if (java_thread->has_last_Java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
    // vframes are resource allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
    Thread* current_thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    ResourceMark rm(current_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
    HandleMark hm(current_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
    RegisterMap reg_map(java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
    frame f = java_thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
    vframe* vf = vframe::new_vframe(&f, &reg_map, java_thread);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1573
    frame* last_entry_frame = NULL;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1574
    int extra_frames = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1576
    if (java_thread == _oome_thread && _oome_constructor != NULL) {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1577
      extra_frames++;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1578
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
    while (vf != NULL) {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1580
      blk.set_frame_number(stack_depth);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
      if (vf->is_java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
        // java frame (interpreted, compiled, ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
        javaVFrame *jvf = javaVFrame::cast(vf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
        if (!(jvf->method()->is_native())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
          StackValueCollection* locals = jvf->locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
          for (int slot=0; slot<locals->size(); slot++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
            if (locals->at(slot)->type() == T_OBJECT) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
              oop o = locals->obj_at(slot)();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
              if (o != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
                writer()->write_u1(HPROF_GC_ROOT_JAVA_FRAME);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
                writer()->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
                writer()->write_u4(thread_serial_num);
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1595
                writer()->write_u4((u4) (stack_depth + extra_frames));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
          }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1599
        } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1600
          // native frame
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1601
          if (stack_depth == 0) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1602
            // JNI locals for the top frame.
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1603
            java_thread->active_handles()->oops_do(&blk);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1604
          } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1605
            if (last_entry_frame != NULL) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1606
              // JNI locals for the entry frame
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1607
              assert(last_entry_frame->is_entry_frame(), "checking");
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1608
              last_entry_frame->entry_frame_call_wrapper()->handles()->oops_do(&blk);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1609
            }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1610
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
        }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1612
        // increment only for Java frames
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1613
        stack_depth++;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1614
        last_entry_frame = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1616
      } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
        // externalVFrame - if it's an entry frame then report any JNI locals
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1618
        // as roots when we find the corresponding native javaVFrame
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
        frame* fr = vf->frame_pointer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
        assert(fr != NULL, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
        if (fr->is_entry_frame()) {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1622
          last_entry_frame = fr;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
      vf = vf->sender();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
    }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1627
  } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1628
    // no last java frame but there may be JNI locals
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1629
    java_thread->active_handles()->oops_do(&blk);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
  }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1631
  return stack_depth;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
// write a HPROF_GC_ROOT_THREAD_OBJ record for each java thread. Then walk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
// the stack so that locals and JNI locals are dumped.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
void VM_HeapDumper::do_threads() {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1638
  for (int i=0; i < _num_threads; i++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1639
    JavaThread* thread = _stack_traces[i]->thread();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
    oop threadObj = thread->threadObj();
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1641
    u4 thread_serial_num = i+1;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1642
    u4 stack_serial_num = thread_serial_num + STACK_TRACE_ID;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1643
    writer()->write_u1(HPROF_GC_ROOT_THREAD_OBJ);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1644
    writer()->write_objectID(threadObj);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1645
    writer()->write_u4(thread_serial_num);  // thread number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1646
    writer()->write_u4(stack_serial_num);   // stack trace serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1647
    int num_frames = do_thread(thread, thread_serial_num);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1648
    assert(num_frames == _stack_traces[i]->get_stack_depth(),
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1649
           "total number of Java frames not matched");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
// The VM operation that dumps the heap. The dump consists of the following
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
// records:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
//  HPROF_HEADER
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
//  [HPROF_UTF8]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
//  [HPROF_LOAD_CLASS]*
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1660
//  [[HPROF_FRAME]*|HPROF_TRACE]*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
//  [HPROF_GC_CLASS_DUMP]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
//  HPROF_HEAP_DUMP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
//
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1664
// The HPROF_TRACE records represent the stack traces where the heap dump
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1665
// is generated and a "dummy trace" record which does not include
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1666
// any frames. The dummy trace record is used to be referenced as the
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1667
// unknown object alloc site.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
// The HPROF_HEAP_DUMP record has a length following by sub-records. To allow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
// the heap dump be generated in a single pass we remember the position of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
// the dump length and fix it up after all sub-records have been written.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
// To generate the sub-records we iterate over the heap, writing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
// HPROF_GC_INSTANCE_DUMP, HPROF_GC_OBJ_ARRAY_DUMP, and HPROF_GC_PRIM_ARRAY_DUMP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
// records as we go. Once that is done we write records for some of the GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
// roots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
void VM_HeapDumper::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
  CollectedHeap* ch = Universe::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
  if (_gc_before_heap_dump) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
    ch->collect_as_vm_thread(GCCause::_heap_dump);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
    // make the heap parsable (no need to retire TLABs)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
    ch->ensure_parsability(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1688
  // At this point we should be the only dumper active, so
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1689
  // the following should be safe.
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1690
  set_global_dumper();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1691
  set_global_writer();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1692
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
  // Write the file header - use 1.0.2 for large heaps, otherwise 1.0.1
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1694
  size_t used = ch->used();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
  const char* header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
  if (used > (size_t)SegmentedHeapDumpThreshold) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
    set_segmented_dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
    header = "JAVA PROFILE 1.0.2";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
    header = "JAVA PROFILE 1.0.1";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
  }
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1702
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
  // header is few bytes long - no chance to overflow int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
  writer()->write_raw((void*)header, (int)strlen(header));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
  writer()->write_u1(0); // terminator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
  writer()->write_u4(oopSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
  writer()->write_u8(os::javaTimeMillis());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
  // HPROF_UTF8 records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
  SymbolTableDumper sym_dumper(writer());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
  SymbolTable::oops_do(&sym_dumper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
  // write HPROF_LOAD_CLASS records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
  SystemDictionary::classes_do(&do_load_class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
  Universe::basic_type_classes_do(&do_load_class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1717
  // write HPROF_FRAME and HPROF_TRACE records
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1718
  // this must be called after _klass_map is built when iterating the classes above.
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1719
  dump_stack_traces();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1720
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
  // write HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
  write_dump_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  // Writes HPROF_GC_CLASS_DUMP records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
  SystemDictionary::classes_do(&do_class_dump);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
  Universe::basic_type_classes_do(&do_basic_type_array_class_dump);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  // writes HPROF_GC_INSTANCE_DUMP records.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
  // After each sub-record is written check_segment_length will be invoked. When
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
  // generated a segmented heap dump this allows us to check if the current
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
  // segment exceeds a threshold and if so, then a new segment is started.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
  // The HPROF_GC_CLASS_DUMP and HPROF_GC_INSTANCE_DUMP are the vast bulk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
  // of the heap dump.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
  HeapObjectDumper obj_dumper(this, writer());
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1428
diff changeset
  1736
  Universe::heap()->safe_object_iterate(&obj_dumper);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
  // HPROF_GC_ROOT_THREAD_OBJ + frames + jni locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
  do_threads();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
  // HPROF_GC_ROOT_MONITOR_USED
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
  MonitorUsedDumper mon_dumper(writer());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
  ObjectSynchronizer::oops_do(&mon_dumper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
  // HPROF_GC_ROOT_JNI_GLOBAL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
  JNIGlobalsDumper jni_dumper(writer());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
  JNIHandles::oops_do(&jni_dumper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
  // HPROF_GC_ROOT_STICKY_CLASS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
  StickyClassDumper class_dumper(writer());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
  SystemDictionary::always_strong_oops_do(&class_dumper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
  // fixes up the length of the dump record. In the case of a segmented
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
  // heap then the HPROF_HEAP_DUMP_END record is also written.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
  end_of_dump();
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1759
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1760
  // Now we clear the global variables, so that a future dumper might run.
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1761
  clear_global_dumper();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1762
  clear_global_writer();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1765
void VM_HeapDumper::dump_stack_traces() {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1766
  // write a HPROF_TRACE record without any frames to be referenced as object alloc sites
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1767
  DumperSupport::write_header(writer(), HPROF_TRACE, 3*sizeof(u4));
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1768
  writer()->write_u4((u4) STACK_TRACE_ID);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1769
  writer()->write_u4(0);                    // thread number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1770
  writer()->write_u4(0);                    // frame count
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1771
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1772
  _stack_traces = NEW_C_HEAP_ARRAY(ThreadStackTrace*, Threads::number_of_threads());
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1773
  int frame_serial_num = 0;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1774
  for (JavaThread* thread = Threads::first(); thread != NULL ; thread = thread->next()) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1775
    oop threadObj = thread->threadObj();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1776
    if (threadObj != NULL && !thread->is_exiting() && !thread->is_hidden_from_external_view()) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1777
      // dump thread stack trace
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1778
      ThreadStackTrace* stack_trace = new ThreadStackTrace(thread, false);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1779
      stack_trace->dump_stack_at_safepoint(-1);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1780
      _stack_traces[_num_threads++] = stack_trace;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1781
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1782
      // write HPROF_FRAME records for this thread's stack trace
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1783
      int depth = stack_trace->get_stack_depth();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1784
      int thread_frame_start = frame_serial_num;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1785
      int extra_frames = 0;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1786
      // write fake frame that makes it look like the thread, which caused OOME,
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1787
      // is in the OutOfMemoryError zero-parameter constructor
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1788
      if (thread == _oome_thread && _oome_constructor != NULL) {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1789
        int oome_serial_num = _klass_map->find(Klass::cast(_oome_constructor->method_holder()));
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1790
        // the class serial number starts from 1
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1791
        assert(oome_serial_num > 0, "OutOfMemoryError class not found");
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1792
        DumperSupport::dump_stack_frame(writer(), ++frame_serial_num, oome_serial_num,
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1793
                                        _oome_constructor, 0);
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1794
        extra_frames++;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1795
      }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1796
      for (int j=0; j < depth; j++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1797
        StackFrameInfo* frame = stack_trace->stack_frame_at(j);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1798
        methodOop m = frame->method();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1799
        int class_serial_num = _klass_map->find(Klass::cast(m->method_holder()));
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1800
        // the class serial number starts from 1
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1801
        assert(class_serial_num > 0, "class not found");
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1802
        DumperSupport::dump_stack_frame(writer(), ++frame_serial_num, class_serial_num, m, frame->bci());
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1803
      }
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1804
      depth += extra_frames;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1805
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1806
      // write HPROF_TRACE record for one thread
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1807
      DumperSupport::write_header(writer(), HPROF_TRACE, 3*sizeof(u4) + depth*oopSize);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1808
      int stack_serial_num = _num_threads + STACK_TRACE_ID;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1809
      writer()->write_u4(stack_serial_num);      // stack trace serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1810
      writer()->write_u4((u4) _num_threads);     // thread serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1811
      writer()->write_u4(depth);                 // frame count
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1812
      for (int j=1; j <= depth; j++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1813
        writer()->write_id(thread_frame_start + j);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1814
      }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1815
    }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1816
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1817
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
// dump the heap to given path.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
int HeapDumper::dump(const char* path) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
  assert(path != NULL && strlen(path) > 0, "path missing");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
  // print message in interactive case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
  if (print_to_tty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
    tty->print_cr("Dumping heap to %s ...", path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
    timer()->start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
  // create the dump writer. If the file can be opened then bail
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  DumpWriter writer(path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
  if (!writer.is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
    set_error(writer.error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
    if (print_to_tty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
      tty->print_cr("Unable to create %s: %s", path,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
        (error() != NULL) ? error() : "reason unknown");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
  // generate the dump
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1841
  VM_HeapDumper dumper(&writer, _gc_before_heap_dump, _oome);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1842
  if (Thread::current()->is_VM_thread()) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1843
    assert(SafepointSynchronize::is_at_safepoint(), "Expected to be called at a safepoint");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1844
    dumper.doit();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1845
  } else {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1846
    VMThread::execute(&dumper);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1847
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
  // close dump file and record any error that the writer may have encountered
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
  writer.close();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
  set_error(writer.error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
  // print message in interactive case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
  if (print_to_tty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
    timer()->stop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
    if (error() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
      char msg[256];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
      sprintf(msg, "Heap dump file created [%s bytes in %3.3f secs]",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
        os::jlong_format_specifier(), timer()->seconds());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
      tty->print_cr(msg, writer.bytes_written());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
      tty->print_cr("Dump file is incomplete: %s", writer.error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
  return (writer.error() == NULL) ? 0 : -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
// stop timer (if still active), and free any error string we might be holding
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
HeapDumper::~HeapDumper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
  if (timer()->is_active()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
    timer()->stop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
  set_error(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
// returns the error string (resource allocated), or NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
char* HeapDumper::error_as_C_string() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
  if (error() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
    char* str = NEW_RESOURCE_ARRAY(char, strlen(error())+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
    strcpy(str, error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
    return str;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
// set the error string
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
void HeapDumper::set_error(char* error) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
  if (_error != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
    os::free(_error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
  if (error == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
    _error = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
    _error = os::strdup(error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
    assert(_error != NULL, "allocation failure");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1902
// Called by out-of-memory error reporting by a single Java thread
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1903
// outside of a JVM safepoint
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1904
void HeapDumper::dump_heap_from_oome() {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1905
  HeapDumper::dump_heap(true);
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1906
}
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1907
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1908
// Called by error reporting by a single Java thread outside of a JVM safepoint,
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1909
// or by heap dumping by the VM thread during a (GC) safepoint. Thus, these various
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1910
// callers are strictly serialized and guaranteed not to interfere below. For more
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1911
// general use, however, this method will need modification to prevent
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1912
// inteference when updating the static variables base_path and dump_file_seq below.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
void HeapDumper::dump_heap() {
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1914
  HeapDumper::dump_heap(false);
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1915
}
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1916
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1917
void HeapDumper::dump_heap(bool oome) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1918
  static char base_path[JVM_MAXPATHLEN] = {'\0'};
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1919
  static uint dump_file_seq = 0;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1920
  char   my_path[JVM_MAXPATHLEN] = {'\0'};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
  // The dump file defaults to java_pid<pid>.hprof in the current working
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
  // directory. HeapDumpPath=<file> can be used to specify an alternative
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
  // dump file name or a directory where dump file is created.
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1925
  if (dump_file_seq == 0) { // first time in, we initialize base_path
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1926
    bool use_default_filename = true;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1927
    if (HeapDumpPath == NULL || HeapDumpPath[0] == '\0') {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1928
      // HeapDumpPath=<file> not specified
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
    } else {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1930
      assert(strlen(HeapDumpPath) < sizeof(base_path), "HeapDumpPath too long");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1931
      strcpy(base_path, HeapDumpPath);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1932
      // check if the path is a directory (must exist)
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1933
      DIR* dir = os::opendir(base_path);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1934
      if (dir == NULL) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1935
        use_default_filename = false;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1936
      } else {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1937
        // HeapDumpPath specified a directory. We append a file separator
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1938
        // (if needed).
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1939
        os::closedir(dir);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1940
        size_t fs_len = strlen(os::file_separator());
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1941
        if (strlen(base_path) >= fs_len) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1942
          char* end = base_path;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1943
          end += (strlen(base_path) - fs_len);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1944
          if (strcmp(end, os::file_separator()) != 0) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1945
            assert(strlen(base_path) + strlen(os::file_separator()) < sizeof(base_path),
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1946
              "HeapDumpPath too long");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1947
            strcat(base_path, os::file_separator());
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1948
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
    }
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1952
    // If HeapDumpPath wasn't a file name then we append the default name
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1953
    if (use_default_filename) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1954
      char fn[32];
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1955
      sprintf(fn, "java_pid%d", os::current_process_id());
4101
6603abdd6464 6818264: Heap dumper unexpectedly adds .hprof suffix
ysr
parents: 2154
diff changeset
  1956
      assert(strlen(base_path) + strlen(fn) + strlen(".hprof") < sizeof(base_path), "HeapDumpPath too long");
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1957
      strcat(base_path, fn);
4101
6603abdd6464 6818264: Heap dumper unexpectedly adds .hprof suffix
ysr
parents: 2154
diff changeset
  1958
      strcat(base_path, ".hprof");
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1959
    }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1960
    assert(strlen(base_path) < sizeof(my_path), "Buffer too small");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1961
    strcpy(my_path, base_path);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1962
  } else {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1963
    // Append a sequence number id for dumps following the first
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1964
    char fn[33];
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1965
    sprintf(fn, ".%d", dump_file_seq);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1966
    assert(strlen(base_path) + strlen(fn) < sizeof(my_path), "HeapDumpPath too long");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1967
    strcpy(my_path, base_path);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1968
    strcat(my_path, fn);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
  }
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1970
  dump_file_seq++;   // increment seq number for next time we dump
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
  HeapDumper dumper(false /* no GC before heap dump */,
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1973
                    true  /* send to tty */,
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1974
                    oome  /* pass along out-of-memory-error flag */);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1975
  dumper.dump(my_path);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
}