On Friday 09 May 2008 03:09, j16sdiz at freenetproject.org wrote:
>  
>               /**
> -              * Sample to take at a time
> +              * Scan all entries and try to move them
>                */
> -             private static final double SAMPLE_RATE = 0.05; // 5%
> +             private void moveOldEntry0(boolean queueItem) {
> +                     newEntries = 0;
> +                     oldEntries = 0;
> +                     freeEntries = 0;
> +                     resolvedEntries = 0;
> +                     droppedEntries = 0;
>  
> +                     List oldItems = null;
> +                     if (queueItem) {
> +                             oldItems = new ArrayList();
> +                     }
> +
> +                     long maxOffset = maxOldItemOffset;
> +                     maxOldItemOffset = 0;
> +                     for (long offset = 0; offset <= maxOffset; offset++) {
> +                             if (logDEBUG && offset % 1024 == 0) {
> +                                     Logger.debug(this, "Resize progress: 
> newEntries=" + newEntries + ", 
oldEntries=" + oldEntries
> +                                             + ", freeEntries=" + 
> freeEntries + ", resolvedEntries=" + 
resolvedEntries
> +                                             + ", droppedEntries=" + 
> droppedEntries);
> +                             }
> +
> +                             if (shutdown)
> +                                     return;
> +
> +                             if (!lockEntry(offset)) //lock 
> +                                     continue;
> +                             try {
> +                                     Entry entry = readEntry(offset, null);
> +
> +                                     if (entry.isFree()) {
> +                                             // free block
> +                                             freeEntries++;
> +                                     } else if (entry.getStoreSize() == 
> storeSize) {
> +                                             // new store size entries
> +                                             maxOldItemOffset = offset;
> +                                             newEntries++;
> +                                     } else { // if (entry.getStoreSize() == 
> prevStoreSize)
> +                                             // old store size entries, try 
> to move them
> +                                             oldEntries++;
> +                                             maxOldItemOffset = offset;
> +
> +                                             entry.setStoreSize(storeSize);
> +                                             long newOffset = 
> entry.getOffset();
> +
> +                                             if (newOffset == offset) { // 
> lucky! 
> +                                                     writeEntry(entry); // 
> write back entry storeSize
> +                                                     resolvedEntries++;
> +                                                     continue;
> +                                             }
> +
> +                                             if (!lockEntry(newOffset)) // 
> lock
> +                                                     continue;
> +                                             try {
> +                                                     // see what's in the 
> new offset
> +                                                     Entry newOffsetEntry = 
> readEntry(newOffset, null);
> +
> +                                                     if 
> (newOffsetEntry.isFree()) {
> +                                                             // the new 
> offset is freeeeeeee..
> +                                                             
> writeEntry(entry);
> +                                                             
> freeOffset(offset);
> +                                                             
> resolvedEntries++;
> +                                                     } else if 
> (newOffsetEntry.getStoreSize() == storeSize) {
> +                                                             // new offset 
> already have a new entry, free old entry
> +                                                             
> freeOffset(offset);
> +                                                             
> droppedEntries++;
> +                                                     } else if 
> (Arrays.equals(entry.digestedRoutingKey, 
newOffsetEntry.digestedRoutingKey)) {
> +                                                             // same 
> digested routing key, free the old entry
> +                                                             
> freeOffset(offset);
> +                                                             
> resolvedEntries++;
> +                                                     } else if (queueItem) {
> +                                                             // break tie by 
> moveing old item to queue
> +                                                             if 
> (oldItems.size() * entryTotalLength < RESIZE_MEMORY) {
> +                                                                     
> oldItems.add(newOffsetEntry);
> +                                                                     if 
> (newOffset > offset) {
> +                                                                             
> oldEntries++; // newOffset wasn't counted count it
> +                                                                     }
> +
> +                                                                     
> writeEntry(entry);
> +                                                                     
> freeOffset(offset);
> +                                                                     
> resolvedEntries++;

Where are we writing it to here? It looks like we write it to the old 
location, and then delete it?

> +                                                             }
> +                                                     }
> +                                             } finally {
> +                                                     unlockEntry(newOffset);
> +                                             }
> +                                     }
> +                             } catch (IOException e) {
> +                                     Logger.debug(this, "IOExcception on 
> moveOldEntries0", e);
> +                             } finally {
> +                                     unlockEntry(offset);
> +                             }
> +                     }
> +
> +                     if (queueItem) {
> +                             putBackOldItems(oldItems);
> +                     }
> +             }
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: not available
URL: 
<https://emu.freenetproject.org/pipermail/devl/attachments/20080509/78235e59/attachment.pgp>

Reply via email to