<!doctype html public "-//IETF//DTD HTML/EN">
<html>
<head>
<!--
 

 Copyright 2004 Sun Microsystems, Inc.  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.  Sun designates this
 particular file as subject to the "Classpath" exception as provided
 by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 CA 95054 USA or visit www.sun.com if you need additional information or
 have any questions.


-->
</head>
<body bgcolor="white">
<p>
Provides the implementation classes for the <em>local:</em> protocol for
the HotSpot PerfData instrumentation buffer monitoring implementation.
</p>
<p>
The <em>local:</em> protocol is the default protocol for the PerfData
implementation. It utilizes a name shared memory mechanism, identified
by a backing store file in the file system name space. The location of
the backing store file is platform specific and is dictated primarily by
the JVM implementation. However, the <tt>java.io.tmpdir</em> system
property generally contains the location of the files, with the exception
of the Solaris implementation, as the SDK and HotSpot JVM use different
locations for their temporary file storage. The HotSpot JVM uses the
<em>/tmp</em> directory and the SDK uses <em>/var/tmp</em>. The classes
in this specifically use <em>/tmp</em> when running on Solaris.
</body>
</html>
