hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/PageCache.java - edge/openjdk - Git at Google

 /*
  * 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. */
   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. */
   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 */
   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 */
   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. */
   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. */
   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 */
   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 */
   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;
   }
 }
	/*
	* 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. */
	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. */
	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 */
	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 */
	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. */
	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. */
	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 */
	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 */
	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;
	}
	}