/*
 * Copyright (c) 2000, 2002, 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.debugger;

/** This class implements an LRU page-level cache of configurable page
    size and number of pages. It is configured with a PageFetcher
    which enables it to transparently satisfy requests which span
    multiple pages when one or more of those pages is not in the
    cache. It is generic enough to be sharable among debugger
    implementations. */

import sun.jvm.hotspot.utilities.*;

public class PageCache {
  
The pageSize must be a power of two and implicitly specifies the alignment of pages. numPages specifies how many pages should be cached.
/** The pageSize must be a power of two and implicitly specifies the alignment of pages. numPages specifies how many pages should be cached. */
public PageCache(long pageSize, long maxNumPages, PageFetcher fetcher) { checkPageInfo(pageSize, maxNumPages); this.pageSize = pageSize; this.maxNumPages = maxNumPages; this.fetcher = fetcher; addressToPageMap = new LongHashMap(); enabled = true; }
This handles fetches which span multiple pages by virtue of the presence of the PageFetcher. Throws UnmappedAddressException if a page on which data was requested was unmapped. This can not really handle numBytes > 32 bits.
/** This handles fetches which span multiple pages by virtue of the presence of the PageFetcher. Throws UnmappedAddressException if a page on which data was requested was unmapped. This can not really handle numBytes > 32 bits. */
public synchronized byte[] getData(long startAddress, long numBytes) throws UnmappedAddressException { byte[] data = new byte[(int) numBytes]; long numRead = 0; while (numBytes > 0) { long pageBaseAddress = startAddress & pageMask; // Look up this page Page page = checkPage(getPage(pageBaseAddress), startAddress); // Figure out how many bytes to read from this page long pageOffset = startAddress - pageBaseAddress; long numBytesFromPage = Math.min(pageSize - pageOffset, numBytes); // Read them starting at the appropriate offset in the // destination buffer page.getDataAsBytes(startAddress, numBytesFromPage, data, numRead); // Increment offsets numRead += numBytesFromPage; numBytes -= numBytesFromPage; startAddress += numBytesFromPage; } return data; } public synchronized boolean getBoolean(long address) { return (getByte(address) != 0); } public synchronized byte getByte(long address) { return checkPage(getPage(address & pageMask), address).getByte(address); } public synchronized short getShort(long address, boolean bigEndian) { return checkPage(getPage(address & pageMask), address).getShort(address, bigEndian); } public synchronized char getChar(long address, boolean bigEndian) { return checkPage(getPage(address & pageMask), address).getChar(address, bigEndian); } public synchronized int getInt(long address, boolean bigEndian) { return checkPage(getPage(address & pageMask), address).getInt(address, bigEndian); } public synchronized long getLong(long address, boolean bigEndian) { return checkPage(getPage(address & pageMask), address).getLong(address, bigEndian); } public synchronized float getFloat(long address, boolean bigEndian) { return checkPage(getPage(address & pageMask), address).getFloat(address, bigEndian); } public synchronized double getDouble(long address, boolean bigEndian) { return checkPage(getPage(address & pageMask), address).getDouble(address, bigEndian); }
A mechanism for clearing cached data covering the given region
/** A mechanism for clearing cached data covering the given region */
public synchronized void clear(long startAddress, long numBytes) { long pageBaseAddress = startAddress & pageMask; long endAddress = startAddress + numBytes; while (pageBaseAddress < endAddress) { flushPage(pageBaseAddress); pageBaseAddress += pageSize; } }
A mechanism for clearing out the cache is necessary to handle detaching and reattaching
/** A mechanism for clearing out the cache is necessary to handle detaching and reattaching */
public synchronized void clear() { // Should probably break next/prev links in list as well addressToPageMap.clear(); lruList = null; numPages = 0; }
Disables the page cache; no further pages will be added to the cache and all existing pages will be flushed. Call this when the target process has been resumed.
/** Disables the page cache; no further pages will be added to the cache and all existing pages will be flushed. Call this when the target process has been resumed. */
public synchronized void disable() { enabled = false; clear(); }
Enables the page cache; fetched pages will be added to the cache. Call this when the target process has been suspended.
/** Enables the page cache; fetched pages will be added to the cache. Call this when the target process has been suspended. */
public synchronized void enable() { enabled = true; } //-------------------------------------------------------------------------------- // Internals only below this point // // This is implemented with two data structures: a hash table for // fast lookup by a page's base address and a circular doubly-linked // list for implementing LRU behavior. private boolean enabled; private long pageSize; private long maxNumPages; private long pageMask; private long numPages; private PageFetcher fetcher; private LongHashMap addressToPageMap; // Map<long, Page> private Page lruList; // Most recently fetched page, or null
Page fetcher plus LRU functionality
/** Page fetcher plus LRU functionality */
private Page getPage(long pageBaseAddress) { // Check head of LRU list first to avoid hash table lookup and // extra list work if possible if (lruList != null) { if (lruList.getBaseAddress() == pageBaseAddress) { // Hit. Return it. return lruList; } } // Long key = new Long(pageBaseAddress); long key = pageBaseAddress; Page page = (Page) addressToPageMap.get(key); if (page == null) { // System.err.println("** Cache miss at address 0x" + Long.toHexString(pageBaseAddress) + " **"); // Fetch new page page = fetcher.fetchPage(pageBaseAddress, pageSize); if (enabled) { // Add to cache, evicting last element if necessary addressToPageMap.put(key, page); if (Assert.ASSERTS_ENABLED) { Assert.that(page == (Page) addressToPageMap.get(pageBaseAddress), "must have found page in cache!"); } addPageToList(page); // See whether eviction of oldest is necessary if (numPages == maxNumPages) { Page evictedPage = lruList.getPrev(); // System.err.println("-> Evicting page at 0x" + Long.toHexString(evictedPage.getBaseAddress()) + // "; " + countPages() + " pages left (expect " + numPages + ")"); removePageFromList(evictedPage); addressToPageMap.remove(evictedPage.getBaseAddress()); } else { ++numPages; } } } else { // Page already in cache, move to front of list removePageFromList(page); addPageToList(page); } return page; } private Page checkPage(Page page, long startAddress) { if (!page.isMapped()) { throw new UnmappedAddressException(startAddress); } return page; } private int countPages() { Page page = lruList; int num = 0; if (page == null) { return num; } do { ++num; page = page.getNext(); } while (page != lruList); return num; } private void flushPage(long pageBaseAddress) { long key = pageBaseAddress; Page page = (Page) addressToPageMap.remove(key); if (page != null) { removePageFromList(page); } } // Adds given page to head of list private void addPageToList(Page page) { if (lruList == null) { lruList = page; page.setNext(page); page.setPrev(page); } else { // Add to front of list page.setNext(lruList); page.setPrev(lruList.getPrev()); lruList.getPrev().setNext(page); lruList.setPrev(page); lruList = page; } } // Removes given page from list private void removePageFromList(Page page) { if (page.getNext() == page) { lruList = null; } else { if (lruList == page) { lruList = page.getNext(); } page.getPrev().setNext(page.getNext()); page.getNext().setPrev(page.getPrev()); } page.setPrev(null); page.setNext(null); }
Ensure that page size fits within 32 bits and is a power of two, and that maxNumPages > 0
/** Ensure that page size fits within 32 bits and is a power of two, and that maxNumPages > 0 */
private void checkPageInfo(long pageSize, long maxNumPages) { if ((pageSize <= 0) || maxNumPages <= 0) { throw new IllegalArgumentException("pageSize and maxNumPages must both be greater than zero"); } long tmpPageSize = pageSize >>> 32; if (tmpPageSize != 0) { throw new IllegalArgumentException("pageSize " + pageSize + " too big (must fit within 32 bits)"); } int numNonZeroBits = 0; for (int i = 0; i < 32; ++i) { if ((pageSize & 1L) != 0) { ++numNonZeroBits; if ((numNonZeroBits > 1) || (i == 0)) { throw new IllegalArgumentException("pageSize " + pageSize + " must be a power of two"); } } pageSize >>>= 1; if (numNonZeroBits == 0) { pageMask = (pageMask << 1) | 1L; } } pageMask = ~pageMask; } }