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

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


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