Attachment 156655 Details for Bug 289057 – Patch demonstrating the changes

[patch] Patch demonstrating the changes

patch1.txt (text/plain), 13.35 KB, created by Satyam Kandula

on 2010-01-20 10:18:24 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Satyam Kandula

Created: 2010-01-20 10:18:24 EST

Size: 13.35 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: compiler/org/eclipse/jdt/internal/compiler/util/HashtableOfObject.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/HashtableOfObject.java,v
>retrieving revision 1.34
>diff -u -r1.34 HashtableOfObject.java
>--- compiler/org/eclipse/jdt/internal/compiler/util/HashtableOfObject.java	7 Mar 2009 01:08:09 -0000	1.34
>+++ compiler/org/eclipse/jdt/internal/compiler/util/HashtableOfObject.java	20 Jan 2010 14:59:16 -0000
>@@ -1,5 +1,5 @@
> /*******************************************************************************
>- * Copyright (c) 2000, 2009 IBM Corporation and others.
>+ * Copyright (c) 2000, 2010 IBM Corporation and others.
>  * All rights reserved. This program and the accompanying materials
>  * are made available under the terms of the Eclipse Public License v1.0
>  * which accompanies this distribution, and is available at
>@@ -24,6 +24,10 @@
> 	public int elementSize; // number of elements in the table
> 	int threshold;
> 
>+	// used during putInOrder
>+	private int lastIndex = -1;
>+	private boolean foundEmpty = false;
>+
> 	public HashtableOfObject() {
> 		this(13);
> 	}
>@@ -39,6 +43,13 @@
> 		this.valueTable = new Object[extraRoom];
> 	}
> 
>+	public  HashtableOfObject(int size, int hashtablesize) {
>+		this.elementSize = 0;
>+		this.threshold = size; // size represents the expected number of elements
>+		this.keyTable = new char[hashtablesize][];
>+		this.valueTable = new Object[hashtablesize];
>+	}
>+	
> 	public void clear() {
> 		for (int i = this.keyTable.length; --i >= 0;) {
> 			this.keyTable[i] = null;
>@@ -111,8 +122,40 @@
> 		if (++this.elementSize > this.threshold)
> 			rehash();
> 		return value;
>+	}	
>+	/**
>+	 * This can be used while recreating the hashtable from 
>+	 * an hashtable contents that was persisted on a file. 
>+	 * This should be called in the same order of the other hashtable's 
>+	 * valuetable. It also assumes that the key used and length
>+	 * are same. This function just tries to recreate the similar hashtable
>+	 * by finding out the empty slots.
>+	 */
>+	public Object putInOrder(char[] key, Object value) {
>+		int length = this.keyTable.length, 
>+		index = CharOperation.hashCode(key) % length;
>+
>+		if (index <= this.lastIndex) {
>+			index = this.lastIndex + 1;
>+		} else if (index != this.lastIndex + 1) {
>+			if (!this.foundEmpty) {
>+				// in the previous hash table, this index could have 
>+				// had conflicts such that it could have got reindexed
>+				// at the beginning of the hash table, where as the original
>+				// index would have been at the end of the hashtable.
>+				if (index+this.threshold-this.elementSize > length) {
>+					index = this.lastIndex+1;
>+				} else {
>+					this.foundEmpty = true;
>+				}
>+			}
>+		}
>+		this.keyTable[index] = key;
>+		this.valueTable[index] = value;
>+		this.lastIndex = index;
>+		++this.elementSize;
>+		return value;
> 	}
>-
> 	public Object removeKey(char[] key) {
> 		int length = this.keyTable.length,
> 			index = CharOperation.hashCode(key) % length;
>Index: search/org/eclipse/jdt/internal/core/index/DiskIndex.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/index/DiskIndex.java,v
>retrieving revision 1.68
>diff -u -r1.68 DiskIndex.java
>--- search/org/eclipse/jdt/internal/core/index/DiskIndex.java	16 Jan 2009 14:29:29 -0000	1.68
>+++ search/org/eclipse/jdt/internal/core/index/DiskIndex.java	20 Jan 2010 14:59:18 -0000
>@@ -1,5 +1,5 @@
> /*******************************************************************************
>- * Copyright (c) 2000, 2009 IBM Corporation and others.
>+ * Copyright (c) 2000, 2010 IBM Corporation and others.
>  * All rights reserved. This program and the accompanying materials
>  * are made available under the terms of the Eclipse Public License v1.0
>  * which accompanies this distribution, and is available at
>@@ -46,7 +46,7 @@
> private int streamEnd; // used when writing data from the streamBuffer to the file
> char separator = Index.DEFAULT_SEPARATOR;
> 
>-public static final String SIGNATURE= "INDEX VERSION 1.126"; //$NON-NLS-1$
>+public static final String SIGNATURE= "INDEX VERSION 1.127"; //$NON-NLS-1$
> private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();
> public static boolean DEBUG = false;
> 
>@@ -132,7 +132,7 @@
> 	}
> 	return results;
> }
>-private HashtableOfObject addQueryResult(HashtableOfObject results, char[] word, HashtableOfObject wordsToDocNumbers, MemoryIndex memoryIndex) throws IOException {
>+private HashtableOfObject addQueryResult(HashtableOfObject results, char[] word, Object wordsToDocNumbers, MemoryIndex memoryIndex) throws IOException {
> 	// must skip over documents which have been added/changed/deleted in the memory index
> 	if (results == null)
> 		results = new HashtableOfObject(13);
>@@ -141,11 +141,11 @@
> 		if (result == null)
> 			results.put(word, new EntryResult(word, wordsToDocNumbers));
> 		else
>-			result.addDocumentTable(wordsToDocNumbers);
>+			result.addDocument(wordsToDocNumbers);
> 	} else {
> 		SimpleLookupTable docsToRefs = memoryIndex.docsToReferences;
> 		if (result == null) result = new EntryResult(word, null);
>-		int[] docNumbers = readDocumentNumbers(wordsToDocNumbers.get(word));
>+		int[] docNumbers = readDocumentNumbers(wordsToDocNumbers);
> 		for (int i = 0, l = docNumbers.length; i < l; i++) {
> 			String docName = readDocumentName(docNumbers[i]);
> 			if (!docsToRefs.containsKey(docName))
>@@ -170,7 +170,7 @@
> 					results = new HashtableOfObject(wordsToDocNumbers.elementSize);
> 				for (int j = 0, m = words.length; j < m; j++)
> 					if (words[j] != null)
>-						results = addQueryResult(results, words[j], wordsToDocNumbers, memoryIndex);
>+						results = addQueryResult(results, words[j], wordsToDocNumbers.valueTable[j], memoryIndex);
> 			}
> 		}
> 		if (results != null && this.cachedChunks == null)
>@@ -180,8 +180,9 @@
> 			case SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE:
> 				for (int i = 0, l = categories.length; i < l; i++) {
> 					HashtableOfObject wordsToDocNumbers = readCategoryTable(categories[i], false);
>-					if (wordsToDocNumbers != null && wordsToDocNumbers.containsKey(key))
>-						results = addQueryResult(results, key, wordsToDocNumbers, memoryIndex);
>+					Object value;
>+					if (wordsToDocNumbers != null && ((value = wordsToDocNumbers.get(key)) != null))
>+						results = addQueryResult(results, key, value, memoryIndex);
> 				}
> 				break;
> 			case SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE:
>@@ -192,7 +193,7 @@
> 						for (int j = 0, m = words.length; j < m; j++) {
> 							char[] word = words[j];
> 							if (word != null && key[0] == word[0] && CharOperation.prefixEquals(key, word))
>-								results = addQueryResult(results, word, wordsToDocNumbers, memoryIndex);
>+								results = addQueryResult(results, word, wordsToDocNumbers.valueTable[j], memoryIndex);
> 						}
> 					}
> 				}
>@@ -205,7 +206,7 @@
> 						for (int j = 0, m = words.length; j < m; j++) {
> 							char[] word = words[j];
> 							if (word != null && Index.isMatch(key, word, matchRule))
>-								results = addQueryResult(results, word, wordsToDocNumbers, memoryIndex);
>+								results = addQueryResult(results, word, wordsToDocNumbers.valueTable[j], memoryIndex);
> 						}
> 					}
> 				}
>@@ -613,6 +614,7 @@
> 		this.bufferIndex = 0;
> 		this.bufferEnd = stream.read(this.streamBuffer, 0, this.streamBuffer.length);
> 		int size = readStreamInt(stream);
>+		int hashtablesize = readStreamInt(stream);
> 		try {
> 			if (size < 0) { // DEBUG
> 				System.err.println("-------------------- DEBUG --------------------"); //$NON-NLS-1$
>@@ -621,7 +623,7 @@
> 				System.err.println("size = "+size); //$NON-NLS-1$
> 				System.err.println("--------------------   END   --------------------"); //$NON-NLS-1$
> 			}
>-			categoryTable = new HashtableOfObject(size);
>+			categoryTable = new HashtableOfObject(size, hashtablesize);
> 		} catch (OutOfMemoryError oom) {
> 			// DEBUG
> 			oom.printStackTrace();
>@@ -641,9 +643,9 @@
> 			//		> 1 & < 256 then the size of the array is > 1 & < 256, the document array follows immediately
> 			//		256 if the array size >= 256 followed by another int which is the offset to the array (written prior to the table)
> 			if (arrayOffset <= 0) {
>-				categoryTable.put(word, new int[] {-arrayOffset}); // store 1 element array by negating documentNumber
>+				categoryTable.putInOrder(word, new int[] {-arrayOffset}); // store 1 element array by negating documentNumber
> 			} else if (arrayOffset < largeArraySize) {
>-				categoryTable.put(word, readStreamDocumentArray(stream, arrayOffset)); // read in-lined array providing size
>+				categoryTable.putInOrder(word, readStreamDocumentArray(stream, arrayOffset)); // read in-lined array providing size
> 			} else {
> 				arrayOffset = readStreamInt(stream); // read actual offset
> 				if (readDocNumbers) {
>@@ -653,7 +655,7 @@
> 						firstOffset = arrayOffset;
> 					matchingWords[count++] = word;
> 				}
>-				categoryTable.put(word, new Integer(arrayOffset)); // offset to array in the file
>+				categoryTable.putInOrder(word, new Integer(arrayOffset)); // offset to array in the file
> 			}
> 		}
> 		this.categoryTables.put(INTERNED_CATEGORY_NAMES.get(categoryName), categoryTable);
>@@ -1060,6 +1062,7 @@
> 	this.categoryOffsets.put(categoryName, this.streamEnd); // remember the offset to the start of the table
> 	this.categoryTables.put(categoryName, null); // flush cached table
> 	writeStreamInt(stream, wordsToDocs.elementSize);
>+	writeStreamInt(stream, wordsToDocs.valueTable.length);
> 	char[][] words = wordsToDocs.keyTable;
> 	for (int i = 0, l = words.length; i < l; i++) {
> 		Object o = values[i];
>Index: search/org/eclipse/jdt/internal/core/index/EntryResult.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/index/EntryResult.java,v
>retrieving revision 1.13
>diff -u -r1.13 EntryResult.java
>--- search/org/eclipse/jdt/internal/core/index/EntryResult.java	7 Mar 2009 01:08:11 -0000	1.13
>+++ search/org/eclipse/jdt/internal/core/index/EntryResult.java	20 Jan 2010 14:59:18 -0000
>@@ -1,5 +1,5 @@
> /*******************************************************************************
>- * Copyright (c) 2000, 2009 IBM Corporation and others.
>+ * Copyright (c) 2000, 2010 IBM Corporation and others.
>  * All rights reserved. This program and the accompanying materials
>  * are made available under the terms of the Eclipse Public License v1.0
>  * which accompanies this distribution, and is available at
>@@ -11,42 +11,41 @@
> package org.eclipse.jdt.internal.core.index;
> 
> import org.eclipse.jdt.core.compiler.CharOperation;
>-import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;
> import org.eclipse.jdt.internal.compiler.util.SimpleSet;
> 
> public class EntryResult {
> 
> private char[] word;
>-private HashtableOfObject[] documentTables;
>+private Object[] documents;
> private SimpleSet documentNames;
> 
>-public EntryResult(char[] word, HashtableOfObject table) {
>+public EntryResult(char[] word, Object document) {
> 	this.word = word;
>-	if (table != null)
>-		this.documentTables = new HashtableOfObject[] {table};
>+	if (document != null)
>+		this.documents = new Object[] {document};
> }
> public void addDocumentName(String documentName) {
> 	if (this.documentNames == null)
> 		this.documentNames = new SimpleSet(3);
> 	this.documentNames.add(documentName);
> }
>-public void addDocumentTable(HashtableOfObject table) {
>-	if (this.documentTables != null) {
>-		int length = this.documentTables.length;
>-		System.arraycopy(this.documentTables, 0, this.documentTables = new HashtableOfObject[length + 1], 0, length);
>-		this.documentTables[length] = table;
>+public void addDocument(Object document) {
>+	if (this.documents != null) {
>+		int length = this.documents.length;
>+		System.arraycopy(this.documents, 0, this.documents = new Object[length + 1], 0, length);
>+		this.documents[length] = document;
> 	} else {
>-		this.documentTables = new HashtableOfObject[] {table};
>+		this.documents = new Object[] {document};
> 	}
> }
> public char[] getWord() {
> 	return this.word;
> }
> public String[] getDocumentNames(Index index) throws java.io.IOException {
>-	if (this.documentTables != null) {
>-		int length = this.documentTables.length;
>+	if (this.documents != null) {
>+		int length = this.documents.length;
> 		if (length == 1 && this.documentNames == null) { // have a single table
>-			Object offset = this.documentTables[0].get(this.word);
>+			Object offset = this.documents[0];
> 			int[] numbers = index.diskIndex.readDocumentNumbers(offset);
> 			String[] names = new String[numbers.length];
> 			for (int i = 0, l = numbers.length; i < l; i++)
>@@ -55,7 +54,7 @@
> 		}
> 
> 		for (int i = 0; i < length; i++) {
>-			Object offset = this.documentTables[i].get(this.word);
>+			Object offset = this.documents[i];
> 			int[] numbers = index.diskIndex.readDocumentNumbers(offset);
> 			for (int j = 0, k = numbers.length; j < k; j++)
> 				addDocumentName(index.diskIndex.readDocumentName(numbers[j]));
>@@ -74,6 +73,6 @@
> 	return names;
> }
> public boolean isEmpty() {
>-	return this.documentTables == null && this.documentNames == null;
>+	return this.documents == null && this.documentNames == null;
> }
> }

Actions: View | Diff

Attachments on bug 289057: 147120 | 147231 | 147285 | 156655 | 157871 | 158022 | 161165 | 161407