Back to index...

	/*
	* Copyright (c) 2003, 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.management.counter.perf;

	import sun.management.counter.*;
	import java.nio.*;

	class Prologue {
	// these constants should match their #define counterparts in vmdata.hpp
	private final static byte PERFDATA_BIG_ENDIAN = 0;
	private final static byte PERFDATA_LITTLE_ENDIAN = 1;
	private final static int PERFDATA_MAGIC = 0xcafec0c0;

	private class PrologueFieldOffset {
	private final static int SIZEOF_BYTE = 1;
	private final static int SIZEOF_INT = 4;
	private final static int SIZEOF_LONG = 8;

	private final static int MAGIC_SIZE = SIZEOF_INT;
	private final static int BYTE_ORDER_SIZE = SIZEOF_BYTE;
	private final static int MAJOR_SIZE = SIZEOF_BYTE;
	private final static int MINOR_SIZE = SIZEOF_BYTE;
	private final static int ACCESSIBLE_SIZE = SIZEOF_BYTE;
	private final static int USED_SIZE = SIZEOF_INT;
	private final static int OVERFLOW_SIZE = SIZEOF_INT;
	private final static int MOD_TIMESTAMP_SIZE = SIZEOF_LONG;
	private final static int ENTRY_OFFSET_SIZE = SIZEOF_INT;
	private final static int NUM_ENTRIES_SIZE = SIZEOF_INT;

	// these constants must match the field offsets and sizes
	// in the PerfDataPrologue structure in perfMemory.hpp
	final static int MAGIC = 0;
	final static int BYTE_ORDER = MAGIC + MAGIC_SIZE;
	final static int MAJOR_VERSION = BYTE_ORDER + BYTE_ORDER_SIZE;
	final static int MINOR_VERSION = MAJOR_VERSION + MAJOR_SIZE;
	final static int ACCESSIBLE = MINOR_VERSION + MINOR_SIZE;
	final static int USED = ACCESSIBLE + ACCESSIBLE_SIZE;
	final static int OVERFLOW = USED + USED_SIZE;
	final static int MOD_TIMESTAMP = OVERFLOW + OVERFLOW_SIZE;
	final static int ENTRY_OFFSET = MOD_TIMESTAMP + MOD_TIMESTAMP_SIZE;
	final static int NUM_ENTRIES = ENTRY_OFFSET + ENTRY_OFFSET_SIZE;
	final static int PROLOGUE_2_0_SIZE = NUM_ENTRIES + NUM_ENTRIES_SIZE;
	}


	private ByteBuffer header;
	private int magic;

	Prologue(ByteBuffer b) {
	this.header = b.duplicate();

	// the magic number is always stored in big-endian format
	// save and restore the buffer's initial byte order around
	// the fetch of the data.
	header.order(ByteOrder.BIG_ENDIAN);
	header.position(PrologueFieldOffset.MAGIC);
	magic = header.getInt();

	// the magic number is always stored in big-endian format
	if (magic != PERFDATA_MAGIC) {
	throw new InstrumentationException("Bad Magic: " +
	Integer.toHexString(getMagic()));
	}


	// set the buffer's byte order according to the value of its
	// byte order field.
	header.order(getByteOrder());

	// Check version
	int major = getMajorVersion();
	int minor = getMinorVersion();

	if (major < 2) {
	throw new InstrumentationException("Unsupported version: " +
	major + "." + minor);
	}

	// Currently, only support 2.0 version.
	header.limit(PrologueFieldOffset.PROLOGUE_2_0_SIZE);
	}

	public int getMagic() {
	return magic;
	}

	public int getMajorVersion() {
	header.position(PrologueFieldOffset.MAJOR_VERSION);
	return (int)header.get();
	}

	public int getMinorVersion() {
	header.position(PrologueFieldOffset.MINOR_VERSION);
	return (int)header.get();
	}

	public ByteOrder getByteOrder() {
	header.position(PrologueFieldOffset.BYTE_ORDER);

	byte byte_order = header.get();
	if (byte_order == PERFDATA_BIG_ENDIAN) {
	return ByteOrder.BIG_ENDIAN;
	}
	else {
	return ByteOrder.LITTLE_ENDIAN;
	}
	}

	public int getEntryOffset() {
	header.position(PrologueFieldOffset.ENTRY_OFFSET);
	return header.getInt();
	}

	// The following fields are updated asynchronously
	// while they are accessed by these methods.
	public int getUsed() {
	header.position(PrologueFieldOffset.USED);
	return header.getInt();
	}

	public int getOverflow() {
	header.position(PrologueFieldOffset.OVERFLOW);
	return header.getInt();
	}

	public long getModificationTimeStamp() {
	header.position(PrologueFieldOffset.MOD_TIMESTAMP);
	return header.getLong();
	}

	public int getNumEntries() {
	header.position(PrologueFieldOffset.NUM_ENTRIES);
	return header.getInt();
	}

	public boolean isAccessible() {
	header.position(PrologueFieldOffset.ACCESSIBLE);
	byte b = header.get();
	return (b == 0 ? false : true);
	}
	}

Back to index...