/*

 * Copyright (c) 2004, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

package sun.jvm.hotspot.utilities;

import java.io.*;

import java.nio.channels.*;

import java.util.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.memory.*;

import sun.jvm.hotspot.oops.*;

import sun.jvm.hotspot.runtime.*;

import sun.jvm.hotspot.classfile.*;

/*

 * This class writes Java heap in hprof binary format. This format is

 * used by Heap Analysis Tool (HAT). The class is heavily influenced

 * by 'hprof_io.c' of 1.5 new hprof implementation.

 */

/* hprof binary format: (result either written to a file or sent over

 * the network).

 *

 * WARNING: This format is still under development, and is subject to

 * change without notice.

 *

 * header     "JAVA PROFILE 1.0.2" (0-terminated)

 * u4         size of identifiers. Identifiers are used to represent

 *            UTF8 strings, objects, stack traces, etc. They usually

 *            have the same size as host pointers. For example, on

 *            Solaris and Win32, the size is 4.

 * u4         high word

 * u4         low word    number of milliseconds since 0:00 GMT, 1/1/70

 * [record]*  a sequence of records.

 *

 */

/*

 *

 * Record format:

 *

 * u1         a TAG denoting the type of the record

 * u4         number of *microseconds* since the time stamp in the

 *            header. (wraps around in a little more than an hour)

 * u4         number of bytes *remaining* in the record. Note that

 *            this number excludes the tag and the length field itself.

 * [u1]*      BODY of the record (a sequence of bytes)

 */

/*

 * The following TAGs are supported:

 *

 * TAG           BODY       notes

 *----------------------------------------------------------

 * HPROF_UTF8               a UTF8-encoded name

 *

 *               id         name ID

 *               [u1]*      UTF8 characters (no trailing zero)

 *

 * HPROF_LOAD_CLASS         a newly loaded class

 *

 *                u4        class serial number (> 0)

 *                id        class object ID

 *                u4        stack trace serial number

 *                id        class name ID

 *

 * HPROF_UNLOAD_CLASS       an unloading class

 *

 *                u4        class serial_number

 *

 * HPROF_FRAME              a Java stack frame

 *

 *                id        stack frame ID

 *                id        method name ID

 *                id        method signature ID

 *                id        source file name ID

 *                u4        class serial number

 *                i4        line number. >0: normal

 *                                       -1: unknown

 *                                       -2: compiled method

 *                                       -3: native method

 *

 * HPROF_TRACE              a Java stack trace

 *

 *               u4         stack trace serial number

 *               u4         thread serial number

 *               u4         number of frames

 *               [id]*      stack frame IDs

 *

 *

 * HPROF_ALLOC_SITES        a set of heap allocation sites, obtained after GC

 *

 *               u2         flags 0x0001: incremental vs. complete

 *                                0x0002: sorted by allocation vs. live

 *                                0x0004: whether to force a GC

 *               u4         cutoff ratio

 *               u4         total live bytes

 *               u4         total live instances

 *               u8         total bytes allocated

 *               u8         total instances allocated

 *               u4         number of sites that follow

 *               [u1        is_array: 0:  normal object

 *                                    2:  object array

 *                                    4:  boolean array

 *                                    5:  char array

 *                                    6:  float array

 *                                    7:  double array

 *                                    8:  byte array

 *                                    9:  short array

 *                                    10: int array

 *                                    11: long array

 *                u4        class serial number (may be zero during startup)

 *                u4        stack trace serial number

 *                u4        number of bytes alive

 *                u4        number of instances alive

 *                u4        number of bytes allocated

 *                u4]*      number of instance allocated

 *

 * HPROF_START_THREAD       a newly started thread.

 *

 *               u4         thread serial number (> 0)

 *               id         thread object ID

 *               u4         stack trace serial number

 *               id         thread name ID

 *               id         thread group name ID

 *               id         thread group parent name ID

 *

 * HPROF_END_THREAD         a terminating thread.

 *

 *               u4         thread serial number

 *

 * HPROF_HEAP_SUMMARY       heap summary

 *

 *               u4         total live bytes

 *               u4         total live instances

 *               u8         total bytes allocated

 *               u8         total instances allocated

 *

 * HPROF_HEAP_DUMP          denote a heap dump

 *

 *               [heap dump sub-records]*

 *

 *                          There are four kinds of heap dump sub-records:

 *

 *               u1         sub-record type

 *

 *               HPROF_GC_ROOT_UNKNOWN         unknown root

 *

 *                          id         object ID

 *

 *               HPROF_GC_ROOT_THREAD_OBJ      thread object

 *

 *                          id         thread object ID  (may be 0 for a

 *                                     thread newly attached through JNI)

 *                          u4         thread sequence number

 *                          u4         stack trace sequence number

 *

 *               HPROF_GC_ROOT_JNI_GLOBAL      JNI global ref root

 *

 *                          id         object ID

 *                          id         JNI global ref ID

 *

 *               HPROF_GC_ROOT_JNI_LOCAL       JNI local ref

 *

 *                          id         object ID

 *                          u4         thread serial number

 *                          u4         frame # in stack trace (-1 for empty)

 *

 *               HPROF_GC_ROOT_JAVA_FRAME      Java stack frame

 *

 *                          id         object ID

 *                          u4         thread serial number

 *                          u4         frame # in stack trace (-1 for empty)

 *

 *               HPROF_GC_ROOT_NATIVE_STACK    Native stack

 *

 *                          id         object ID

 *                          u4         thread serial number

 *

 *               HPROF_GC_ROOT_STICKY_CLASS    System class

 *

 *                          id         object ID

 *

 *               HPROF_GC_ROOT_THREAD_BLOCK    Reference from thread block

 *

 *                          id         object ID

 *                          u4         thread serial number

 *

 *               HPROF_GC_ROOT_MONITOR_USED    Busy monitor

 *

 *                          id         object ID

 *

 *               HPROF_GC_CLASS_DUMP           dump of a class object

 *

 *                          id         class object ID

 *                          u4         stack trace serial number

 *                          id         super class object ID

 *                          id         class loader object ID

 *                          id         signers object ID

 *                          id         protection domain object ID

 *                          id         reserved

 *                          id         reserved

 *

 *                          u4         instance size (in bytes)

 *

 *                          u2         size of constant pool

 *                          [u2,       constant pool index,

 *                           ty,       type

 *                                     2:  object

 *                                     4:  boolean

 *                                     5:  char

 *                                     6:  float

 *                                     7:  double

 *                                     8:  byte

 *                                     9:  short

 *                                     10: int

 *                                     11: long

 *                           vl]*      and value

 *

 *                          u2         number of static fields

 *                          [id,       static field name,

 *                           ty,       type,

 *                           vl]*      and value

 *

 *                          u2         number of inst. fields (not inc. super)

 *                          [id,       instance field name,

 *                           ty]*      type

 *

 *               HPROF_GC_INSTANCE_DUMP        dump of a normal object

 *

 *                          id         object ID

 *                          u4         stack trace serial number

 *                          id         class object ID

 *                          u4         number of bytes that follow

 *                          [vl]*      instance field values (class, followed

 *                                     by super, super's super ...)

 *

 *               HPROF_GC_OBJ_ARRAY_DUMP       dump of an object array

 *

 *                          id         array object ID

 *                          u4         stack trace serial number

 *                          u4         number of elements

 *                          id         array class ID

 *                          [id]*      elements

 *

 *               HPROF_GC_PRIM_ARRAY_DUMP      dump of a primitive array

 *

 *                          id         array object ID

 *                          u4         stack trace serial number

 *                          u4         number of elements

 *                          u1         element type

 *                                     4:  boolean array

 *                                     5:  char array

 *                                     6:  float array

 *                                     7:  double array

 *                                     8:  byte array

 *                                     9:  short array

 *                                     10: int array

 *                                     11: long array

 *                          [u1]*      elements

 *

 * HPROF_CPU_SAMPLES        a set of sample traces of running threads

 *

 *                u4        total number of samples

 *                u4        # of traces

 *               [u4        # of samples

 *                u4]*      stack trace serial number

 *

 * HPROF_CONTROL_SETTINGS   the settings of on/off switches

 *

 *                u4        0x00000001: alloc traces on/off

 *                          0x00000002: cpu sampling on/off

 *                u2        stack trace depth

 *

 *

 * A heap dump can optionally be generated as a sequence of heap dump

 * segments. This sequence is terminated by an end record. The additional

 * tags allowed by format "JAVA PROFILE 1.0.2" are:

 *

 * HPROF_HEAP_DUMP_SEGMENT  denote a heap dump segment

 *

 *               [heap dump sub-records]*

 *               The same sub-record types allowed by HPROF_HEAP_DUMP

 *

 * HPROF_HEAP_DUMP_END      denotes the end of a heap dump

 *

 */

public class HeapHprofBinWriter extends AbstractHeapGraphWriter {

    private static final long HPROF_SEGMENTED_HEAP_DUMP_THRESHOLD = 2L * 0x40000000;

    // The approximate size of a heap segment. Used to calculate when to create

    // a new segment.

    private static final long HPROF_SEGMENTED_HEAP_DUMP_SEGMENT_SIZE = 1L * 0x40000000;

    // hprof binary file header

    private static final String HPROF_HEADER_1_0_2 = "JAVA PROFILE 1.0.2";

    // constants in enum HprofTag

    private static final int HPROF_UTF8             = 0x01;

    private static final int HPROF_LOAD_CLASS       = 0x02;

    private static final int HPROF_UNLOAD_CLASS     = 0x03;

    private static final int HPROF_FRAME            = 0x04;

    private static final int HPROF_TRACE            = 0x05;

    private static final int HPROF_ALLOC_SITES      = 0x06;

    private static final int HPROF_HEAP_SUMMARY     = 0x07;

    private static final int HPROF_START_THREAD     = 0x0A;

    private static final int HPROF_END_THREAD       = 0x0B;

    private static final int HPROF_HEAP_DUMP        = 0x0C;

    private static final int HPROF_CPU_SAMPLES      = 0x0D;

    private static final int HPROF_CONTROL_SETTINGS = 0x0E;

    // 1.0.2 record types

    private static final int HPROF_HEAP_DUMP_SEGMENT = 0x1C;

    private static final int HPROF_HEAP_DUMP_END     = 0x2C;

    // Heap dump constants

    // constants in enum HprofGcTag

    private static final int HPROF_GC_ROOT_UNKNOWN       = 0xFF;

    private static final int HPROF_GC_ROOT_JNI_GLOBAL    = 0x01;

    private static final int HPROF_GC_ROOT_JNI_LOCAL     = 0x02;

    private static final int HPROF_GC_ROOT_JAVA_FRAME    = 0x03;

    private static final int HPROF_GC_ROOT_NATIVE_STACK  = 0x04;

    private static final int HPROF_GC_ROOT_STICKY_CLASS  = 0x05;

    private static final int HPROF_GC_ROOT_THREAD_BLOCK  = 0x06;

    private static final int HPROF_GC_ROOT_MONITOR_USED  = 0x07;

    private static final int HPROF_GC_ROOT_THREAD_OBJ    = 0x08;

    private static final int HPROF_GC_CLASS_DUMP         = 0x20;

    private static final int HPROF_GC_INSTANCE_DUMP      = 0x21;

    private static final int HPROF_GC_OBJ_ARRAY_DUMP     = 0x22;

    private static final int HPROF_GC_PRIM_ARRAY_DUMP    = 0x23;

    // constants in enum HprofType

    private static final int HPROF_ARRAY_OBJECT  = 1;

    private static final int HPROF_NORMAL_OBJECT = 2;

    private static final int HPROF_BOOLEAN       = 4;

    private static final int HPROF_CHAR          = 5;

    private static final int HPROF_FLOAT         = 6;

    private static final int HPROF_DOUBLE        = 7;

    private static final int HPROF_BYTE          = 8;

    private static final int HPROF_SHORT         = 9;

    private static final int HPROF_INT           = 10;

    private static final int HPROF_LONG          = 11;

    // Java type codes

    private static final int JVM_SIGNATURE_BOOLEAN = 'Z';

    private static final int JVM_SIGNATURE_CHAR    = 'C';

    private static final int JVM_SIGNATURE_BYTE    = 'B';

    private static final int JVM_SIGNATURE_SHORT   = 'S';

    private static final int JVM_SIGNATURE_INT     = 'I';

    private static final int JVM_SIGNATURE_LONG    = 'J';

    private static final int JVM_SIGNATURE_FLOAT   = 'F';

    private static final int JVM_SIGNATURE_DOUBLE  = 'D';

    private static final int JVM_SIGNATURE_ARRAY   = '[';

    private static final int JVM_SIGNATURE_CLASS   = 'L';

    private static final long MAX_U4_VALUE = 0xFFFFFFFFL;

    int serialNum = 1;

    public HeapHprofBinWriter() {

        this.KlassMap = new ArrayList<Klass>();

    }

    public synchronized void write(String fileName) throws IOException {

        // open file stream and create buffered data output stream

        fos = new FileOutputStream(fileName);

        out = new DataOutputStream(new BufferedOutputStream(fos));

        VM vm = VM.getVM();

        dbg = vm.getDebugger();

        objectHeap = vm.getObjectHeap();

        symTbl = vm.getSymbolTable();

        OBJ_ID_SIZE = (int) vm.getOopSize();

        BOOLEAN_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_BOOLEAN);

        BYTE_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_BYTE);

        CHAR_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_CHAR);

        SHORT_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_SHORT);

        INT_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_INT);

        LONG_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_LONG);

        FLOAT_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_FLOAT);

        DOUBLE_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_DOUBLE);

        OBJECT_BASE_OFFSET = TypeArray.baseOffsetInBytes(BasicType.T_OBJECT);

        BOOLEAN_SIZE = objectHeap.getBooleanSize();

        BYTE_SIZE = objectHeap.getByteSize();

        CHAR_SIZE = objectHeap.getCharSize();

        SHORT_SIZE = objectHeap.getShortSize();

        INT_SIZE = objectHeap.getIntSize();

        LONG_SIZE = objectHeap.getLongSize();

        FLOAT_SIZE = objectHeap.getFloatSize();

        DOUBLE_SIZE = objectHeap.getDoubleSize();

        // Check weather we should dump the heap as segments

        useSegmentedHeapDump = vm.getUniverse().heap().used() > HPROF_SEGMENTED_HEAP_DUMP_THRESHOLD;

        // hprof bin format header

        writeFileHeader();

        // dummy stack trace without any frames so that

        // HAT can be run without -stack false option

        writeDummyTrace();

        // hprof UTF-8 symbols section

        writeSymbols();

        // HPROF_LOAD_CLASS records for all classes

        writeClasses();

        // write HPROF_FRAME and HPROF_TRACE records

        dumpStackTraces();

        // write CLASS_DUMP records

        writeClassDumpRecords();

        // this will write heap data into the buffer stream

        super.write();

        // flush buffer stream.

        out.flush();

        // Fill in final length

        fillInHeapRecordLength();

        if (useSegmentedHeapDump) {

            // Write heap segment-end record

            out.writeByte((byte) HPROF_HEAP_DUMP_END);

            out.writeInt(0);

            out.writeInt(0);

        }

        // flush buffer stream and throw it.

        out.flush();

        out = null;

        // close the file stream

        fos.close();

    }

    @Override

    protected void writeHeapRecordPrologue() throws IOException {

        if (currentSegmentStart == 0) {

            // write heap data header, depending on heap size use segmented heap

            // format

            out.writeByte((byte) (useSegmentedHeapDump ? HPROF_HEAP_DUMP_SEGMENT

                    : HPROF_HEAP_DUMP));

            out.writeInt(0);

            // remember position of dump length, we will fixup

            // length later - hprof format requires length.

            out.flush();

            currentSegmentStart = fos.getChannel().position();

            // write dummy length of 0 and we'll fix it later.

            out.writeInt(0);

        }

    }

    @Override

    protected void writeHeapRecordEpilogue() throws IOException {

        if (useSegmentedHeapDump) {

            out.flush();

            if ((fos.getChannel().position() - currentSegmentStart - 4L) >= HPROF_SEGMENTED_HEAP_DUMP_SEGMENT_SIZE) {

                fillInHeapRecordLength();

                currentSegmentStart = 0;

            }

        }

    }

    private void fillInHeapRecordLength() throws IOException {

        // now get the current position to calculate length

        long dumpEnd = fos.getChannel().position();

        // calculate the length of heap data

        long dumpLenLong = (dumpEnd - currentSegmentStart - 4L);

        // Check length boundary, overflow could happen but is _very_ unlikely

        if (dumpLenLong >= (4L * 0x40000000)) {

            throw new RuntimeException("Heap segment size overflow.");

        }

        // Save the current position

        long currentPosition = fos.getChannel().position();

        // seek the position to write length

        fos.getChannel().position(currentSegmentStart);

        int dumpLen = (int) dumpLenLong;

        // write length as integer

        fos.write((dumpLen >>> 24) & 0xFF);

        fos.write((dumpLen >>> 16) & 0xFF);

        fos.write((dumpLen >>> 8) & 0xFF);

        fos.write((dumpLen >>> 0) & 0xFF);