/*

 * Copyright (c) 2004, 2012, 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.*;

/*

 * 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.1" (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

 *

 */

public class HeapHprofBinWriter extends AbstractHeapGraphWriter {

    // hprof binary file header

    private static final String HPROF_HEADER = "JAVA PROFILE 1.0.1";

    // 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;

    // 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';

    public synchronized void write(String fileName) throws IOException {

        // open file stream and create buffered data output stream

        FileOutputStream fos = new FileOutputStream(fileName);

        FileChannel chn = fos.getChannel();

        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();

        // 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 heap data now

        out.writeByte((byte)HPROF_HEAP_DUMP);

        out.writeInt(0); // relative timestamp

        // remember position of dump length, we will fixup

        // length later - hprof format requires length.

        out.flush();

        long dumpStart = chn.position();

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

        out.writeInt(0);

        // write CLASS_DUMP records

        writeClassDumpRecords();

        // this will write heap data into the buffer stream

        super.write();

        // flush buffer stream and throw it.

        out.flush();

        out = null;

        // now get current position to calculate length

        long dumpEnd = chn.position();

        // calculate length of heap data

        int dumpLen = (int) (dumpEnd - dumpStart - 4);

        // seek the position to write length

        chn.position(dumpStart);

        // write length as integer

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

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

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

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

        // close the file stream

        fos.close();

    }

    private void writeClassDumpRecords() throws IOException {

        SystemDictionary sysDict = VM.getVM().getSystemDictionary();

        try {

            sysDict.allClassesDo(new SystemDictionary.ClassVisitor() {

                            public void visit(Klass k) {

                                try {

                                    writeClassDumpRecord(k);

                                } catch (IOException e) {

                                    throw new RuntimeException(e);

                                }

                            }

                        });

        } catch (RuntimeException re) {

            handleRuntimeException(re);

        }

    }

    protected void writeClass(Instance instance) throws IOException {

        Klass reflectedKlass = java_lang_Class.asKlass(instance);

        // dump instance record only for primitive type Class objects.

        // all other Class objects are covered by writeClassDumpRecords.

        if (reflectedKlass == null) {

            writeInstance(instance);

        }

    }

    private void writeClassDumpRecord(Klass k) throws IOException {

        out.writeByte((byte)HPROF_GC_CLASS_DUMP);

        writeObjectID(k.getJavaMirror());

        out.writeInt(DUMMY_STACK_TRACE_ID);

        Klass superKlass = k.getJavaSuper();

        if (superKlass != null) {

            writeObjectID(superKlass.getJavaMirror());

        } else {

            writeObjectID(null);

        }

        if (k instanceof InstanceKlass) {

            InstanceKlass ik = (InstanceKlass) k;

            writeObjectID(ik.getClassLoader());

            // two reserved id fields

            writeObjectID(null);

            writeObjectID(null);

            List fields = getInstanceFields(ik);

            int instSize = getSizeForFields(fields);

            classDataCache.put(ik, new ClassData(instSize, fields));

            out.writeInt(instSize);

            // For now, ignore constant pool - HAT ignores too!

            // output number of cp entries as zero.

            out.writeShort((short) 0);

            List declaredFields = ik.getImmediateFields();

            List staticFields = new ArrayList();

            List instanceFields = new ArrayList();

            Iterator itr = null;

            for (itr = declaredFields.iterator(); itr.hasNext();) {

                Field field = (Field) itr.next();

                if (field.isStatic()) {

                    staticFields.add(field);

                } else {

                    instanceFields.add(field);

                }

            }

            // dump static field descriptors

            writeFieldDescriptors(staticFields, ik);

            // dump instance field descriptors

            writeFieldDescriptors(instanceFields, null);

        } else {

            if (k instanceof ObjArrayKlass) {

                ObjArrayKlass oak = (ObjArrayKlass) k;

                Klass bottomKlass = oak.getBottomKlass();

                if (bottomKlass instanceof InstanceKlass) {

                    InstanceKlass ik = (InstanceKlass) bottomKlass;

                    writeObjectID(ik.getClassLoader());

                } else {

                    writeObjectID(null);

                    writeObjectID(null);

                    writeObjectID(null);

                }

            } else {

                writeObjectID(null);