allocationcache.java

derby database source code.good for you.

		 throws StandardException
	{
		AllocExtent extent = null;
		int extentNumber;
		long lastValidPageNumber = ContainerHandle.INVALID_PAGE_NUMBER;

		if (!isValid)
			validate(handle, firstAllocPageNumber);

		if (numExtents == 0)	// no extent at all, no page in the container
			return ContainerHandle.INVALID_PAGE_NUMBER;

		// start from the last extent, goes backward till a valid page is found

		for (extentNumber = numExtents-1;
			 extentNumber >= 0;
			 extentNumber--)
		{
			extent = extents[extentNumber];
			lastValidPageNumber = extent.getLastValidPageNumber();
			if (lastValidPageNumber != ContainerHandle.INVALID_PAGE_NUMBER)
				break;
		}
		return lastValidPageNumber;
	}

	/*
	  Get the next page (after pageNumber) that is valid 
	  */
	protected long getNextValidPage(BaseContainerHandle handle, 
									long pageNumber, 
									long firstAllocPageNumber)
		 throws StandardException
	{
		int extentNumber;

		if (!isValid)
			validate(handle, firstAllocPageNumber);

		if (numExtents == 0)	// no extent at all, no page in the container
			return ContainerHandle.INVALID_PAGE_NUMBER;

		// find the extent whose hiRange is > pageNumber.  Most of the time,
		// this is the extent this pageNumber is in, but some times, when
		// pageNumber == hiRange of extent i, extent i+1 is found.
		AllocExtent extent = null;
		for (extentNumber = 0; extentNumber < numExtents; extentNumber++)
		{
			if (pageNumber < hiRange[extentNumber])
			{
				extent = extents[extentNumber];
				break;
			}
		}

		if (extent == null)		// extent has been invalidated or not there
		{
			// the cache is valid and up to date, 
			// the only reason why we cannot find an extent is if this is the
			// last valid page of the container
			return ContainerHandle.INVALID_PAGE_NUMBER;
		}

		// extent == extents[extentNumber]
		if (SanityManager.DEBUG)
			SanityManager.ASSERT(extent == extents[extentNumber]);

		// we found an extent which may contain a valid page that is of higher
		// pagenumber than the passed in page number.  Still need to walk the
		// extent array to make sure 

		long nextValidPage = ContainerHandle.INVALID_PAGE_NUMBER;

		while(extentNumber < numExtents)
		{
			extent = extents[extentNumber] ;
			nextValidPage = extent.getNextValidPageNumber(pageNumber);
			if (nextValidPage != ContainerHandle.INVALID_PAGE_NUMBER)
				break;

			extentNumber++;
		}
		return nextValidPage;

	}

	/**
	  Get the page status of a page
	*/
	protected int getPageStatus(BaseContainerHandle handle, long pageNumber,
								long firstAllocPageNumber)
		 throws StandardException
	{
		AllocExtent extent = null;

		for (int i = 0; i < numExtents; i++)
		{
			if (lowRange[i] <= pageNumber && pageNumber <= hiRange[i])
			{
				extent = extents[i];
				break;
			}
		}

		if (extent == null)
		{
			if (SanityManager.DEBUG) {
				if (isValid) {

					SanityManager.DEBUG_PRINT("trace", "Allocation cache is " + 
								(isValid ? "Valid" : "Invalid"));
					
					for (int i = 0; i < numExtents; i++) {
						SanityManager.DEBUG_PRINT("trace", "Extent " + i + " at " + extentPageNums[i] +
										" range is " + lowRange[i] + " to " + hiRange[i]);
						if (extents[i] == null)
							SanityManager.DEBUG_PRINT("trace", "extent is null");
						else
							SanityManager.DEBUG_PRINT("trace", extents[i].toDebugString());

					}

					SanityManager.THROWASSERT("valid cache cannot find page "+pageNumber);
				}
			}

			if (!isValid)
				validate(handle, firstAllocPageNumber);
			// try again

			for (int i = 0; i < numExtents; i++)
			{
				if (lowRange[i] <= pageNumber && pageNumber <= hiRange[i])
				{
					extent = extents[i];
					break;
				}
			}

			if (SanityManager.DEBUG)
				if (extent == null)
					SanityManager.THROWASSERT("valid cache cannot find page " +
												pageNumber);
		}

		return extent.getPageStatus(pageNumber);
	}

	/**
	  Validate the cache, find all alloc pages and fill in the arrays
	  */
	private void validate(BaseContainerHandle handle, long firstAllocPageNumber)
		 throws StandardException
	{
		if (numExtents == 0)	// never been initialized, read it all in
		{
			long pagenum = firstAllocPageNumber;

			while(!isValid)
			{
				growArrays(++numExtents);

				Object obj = handle.getAllocPage(pagenum);

				if (SanityManager.DEBUG)
				{
					if (obj == null)
						SanityManager.THROWASSERT(
							"cannot find " + numExtents +
							" alloc page at " + pagenum);
					if ( ! (obj instanceof AllocPage))
						SanityManager.THROWASSERT(
							"page at " + pagenum +
							" is not an allocPage, is a " +
							obj.getClass().getName());
				}	

				AllocPage allocPage = (AllocPage)obj;
				setArrays(numExtents-1, allocPage);

				if (allocPage.isLast())
					isValid = true;
				else
					// get next alloc page
					pagenum = allocPage.getNextAllocPageNumber();

				allocPage.unlatch();
			}
		}
		else		// has been initialized before, but is now invalidated
		{
			for (int i = 0; i < numExtents-1; i++)
			{
				if (extents[i] == null)	// reinitialize this extent
				{
					AllocPage allocPage = 
                        (AllocPage)handle.getAllocPage(extentPageNums[i]);

					setArrays(i, allocPage);

					if (SanityManager.DEBUG)
					{
						if (i < numExtents-1)
                        {
                            if (extentPageNums[i+1] != 
                                    allocPage.getNextAllocPageNumber())
                            {
                                SanityManager.THROWASSERT(
                                    "bad alloc page - " +
                                    ";extentPageNums[i+1] = " + 
                                        extentPageNums[i+1] +
                                    ";allocPage.getNextAllocPageNumber() = " + 
                                        allocPage.getNextAllocPageNumber());
                            }
                        }
					}

					allocPage.unlatch();
				}
			}
			// always get the last alloc page to see if the number of alloc
			// pages remain the same
			long pagenum = extentPageNums[numExtents-1];
			while (!isValid)
			{
				AllocPage allocPage = (AllocPage)handle.getAllocPage(pagenum);

				if (extents[numExtents-1] == null)
					setArrays(numExtents-1, allocPage);

				if (!allocPage.isLast())
				{
					growArrays(++numExtents);
					pagenum = allocPage.getNextAllocPageNumber();
				}
				else
					isValid = true;

				allocPage.unlatch();
			}
		}
	}

	/* shorthand to set the 4 array values */
	private void setArrays(int i, AllocPage allocPage)
	{
		if (SanityManager.DEBUG)
        {
            if (SanityManager.DEBUG_ON(FileContainer.SPACE_TRACE))
            {
                SanityManager.DEBUG(
                    FileContainer.SPACE_TRACE, 
                    "Alloc page " + i + " at " + allocPage.getPageNumber() + 
                    " updated");
            }
        }

		AllocExtent extent = allocPage.getAllocExtent();
		extents[i] = extent;
		lowRange[i] = extent.getFirstPagenum();
		hiRange[i] = extent.getLastPagenum();
		extentPageNums[i] = allocPage.getPageNumber();
	}

	/* shorthand to grow the 4 arrays to the desired size */
	private void growArrays(int size)
	{
		int oldLength;

		if (lowRange == null || lowRange.length == 0)
			oldLength = 0;
		else 
			oldLength = lowRange.length;

		if (oldLength >= size)	// no need to grow
			return;

		long[] saveLow = lowRange;
		long[] saveHi = hiRange;
		AllocExtent[] saveExtents = extents;
		boolean[] saveDirty = isDirty;
		long[] savePageNums = extentPageNums;

		lowRange = new long[size];
		hiRange = new long[size];
		isDirty = new boolean[size];
		extents = new AllocExtent[size];
		extentPageNums = new long[size];

		if (oldLength > 0)
		{
			if (SanityManager.DEBUG)
			{
				SanityManager.ASSERT(oldLength == saveHi.length);
				SanityManager.ASSERT(oldLength == saveExtents.length);
				SanityManager.ASSERT(oldLength == savePageNums.length);
			}
			System.arraycopy(saveLow, 	  0, lowRange, 	0, saveLow.length);
			System.arraycopy(saveHi,	  0, hiRange, 	0, saveHi.length);
			System.arraycopy(saveDirty,	  0, isDirty,   0, saveDirty.length);
			System.arraycopy(saveExtents, 0, extents,	0, saveExtents.length);
			System.arraycopy(savePageNums,0,extentPageNums,0, savePageNums.length);
		}

		for (int i = oldLength; i < size; i++)
		{
			lowRange[i] = ContainerHandle.INVALID_PAGE_NUMBER;
			hiRange[i] = ContainerHandle.INVALID_PAGE_NUMBER;
			isDirty[i] = false;
			extentPageNums[i] = ContainerHandle.INVALID_PAGE_NUMBER;
			extents[i] = null;
		}
	}

	/** 
	  dump the allocation cache information
	*/
	protected void dumpAllocationCache()
	{
		if (SanityManager.DEBUG)
        {
            if (SanityManager.DEBUG_ON(FileContainer.SPACE_TRACE))
            {
                SanityManager.DEBUG(FileContainer.SPACE_TRACE, 
                                    "Allocation cache is " + 
                                    (isValid ? "Valid" : "Invalid"));
                for (int i = 0; i < numExtents; i++)
                {
                    SanityManager.DEBUG(
                        FileContainer.SPACE_TRACE, 
                        "Extent " + i + " at " + extentPageNums[i] +
                        " range is " + lowRange[i] + " to " + hiRange[i]);

                    if (extents[i] == null)
                    {
                        SanityManager.DEBUG(
                            FileContainer.SPACE_TRACE, "extent is null");
                    }
                    else
                    {
                        SanityManager.DEBUG(
                            FileContainer.SPACE_TRACE, 
                            extents[i].toDebugString());
                    }
                }
            }
        }
	}

}