Attachment #155709 for bug #287907

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 9-14 Link Here

(-)parser/org/eclipse/cdt/core/index/IIndex.java (+7 lines)
9	* Markus Schorn - initial API and implementation	9	* Markus Schorn - initial API and implementation
10	* Andrew Ferguson (Symbian)	10	* Andrew Ferguson (Symbian)
11	* Bryan Wilkinson (QNX)	11	* Bryan Wilkinson (QNX)
		12	* Sergey Prigogin (Google)
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.cdt.core.index;	14	package org.eclipse.cdt.core.index;
14		15
Lines 92-97 Link Here
92	public void releaseReadLock();	93	public void releaseReadLock();
93		94
94	/**	95	/**
		96	* @return <code>true</code> if there are threads waiting for read locks.
		97	* @since 5.2
		98	*/
		99	public boolean hasWaitingReaders();
		100
		101	/**
95	* Returns a timestamp of when the index was last written to. This can	102	* Returns a timestamp of when the index was last written to. This can
96	* be used to figure out whether information read from the index is	103	* be used to figure out whether information read from the index is
97	* still reliable or not.	104	* still reliable or not.




 *    Bryan Wilkinson (QNX)
 *    Andrew Ferguson (Symbian)
 *    Anton Leherbauer (Wind River Systems)
 *    Sergey Prigogin (Google)
 *******************************************************************************/ 
package org.eclipse.cdt.internal.core.index;


		return fReadLock;
	}

	public boolean hasWaitingReaders() {
		for (int i= 0; i < fFragments.length; i++) {
			if (fFragments[i].hasWaitingReaders()) {
				return true;
			}
		}
		return false;
	}

	public long getLastWriteAccess() {
		long result= 0;
		for (int i = 0; i < fFragments.length; i++) {

Lines 9-14 Link Here

(-)parser/org/eclipse/cdt/internal/core/index/EmptyCIndex.java (+5 lines)
9	* Markus Schorn - initial API and implementation	9	* Markus Schorn - initial API and implementation
10	* Bryan Wilkinson (QNX)	10	* Bryan Wilkinson (QNX)
11	* Andrew Ferguson (Symbian)	11	* Andrew Ferguson (Symbian)
		12	* Sergey Prigogin (Google)
12	*******************************************************************************/	13	*******************************************************************************/
13		14
14	package org.eclipse.cdt.internal.core.index;	15	package org.eclipse.cdt.internal.core.index;
Lines 85-90 Link Here
85	public void releaseReadLock() {	86	public void releaseReadLock() {
86	}	87	}
87		88
		89	public boolean hasWaitingReaders() {
		90	return false;
		91	}
		92
88	public long getLastWriteAccess() {	93	public long getLastWriteAccess() {
89	return 0;	94	return 0;
90	}	95	}

Lines 9-14 Link Here

(-)parser/org/eclipse/cdt/internal/core/index/IIndexFragment.java (+6 lines)
9	* Markus Schorn - initial API and implementation	9	* Markus Schorn - initial API and implementation
10	* Bryan Wilkinson (QNX)	10	* Bryan Wilkinson (QNX)
11	* Andrew Ferguson (Symbian)	11	* Andrew Ferguson (Symbian)
		12	* Sergey Prigogin (Google)
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.cdt.internal.core.index;	14	package org.eclipse.cdt.internal.core.index;
14		15
Lines 191-196 Link Here
191	void releaseReadLock();	192	void releaseReadLock();
192		193
193	/**	194	/**
		195	* @return <code>true</code> if there are threads waiting for read locks.
		196	*/
		197	public boolean hasWaitingReaders();
		198
		199	/**
194	* Returns the timestamp of the last modification to the index.	200	* Returns the timestamp of the last modification to the index.
195	*/	201	*/
196	long getLastWriteAccess();	202	long getLastWriteAccess();




 * Contributors:
 *    Markus Schorn - initial API and implementation
 *    Andrew Ferguson (Symbian)
 *    Sergey Prigogin (Google)
 *******************************************************************************/ 

package org.eclipse.cdt.internal.core.index;

import org.eclipse.cdt.core.index.IIndexFile;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.internal.core.pdom.ASTFilePathResolver;
import org.eclipse.cdt.internal.core.pdom.YieldableIndexLock;
import org.eclipse.core.runtime.CoreException;

/**

	/**
	 * Creates a file object for the given location or returns an existing one.
	 */
	IIndexFragmentFile addFile(int linkageID, IIndexFileLocation location) throws CoreException;

	/**
	 * Creates a uncommitted file object for the given location.
	 */
	IIndexFragmentFile addUncommittedFile(int linkageID, IIndexFileLocation location) throws CoreException;

	/**
	 * Makes an uncommitted file that was created earlier by calling
	 * {@link #addUncommittedFile(int, IIndexFileLocation)} method visible in the index.
	 *
	 * @return The file that was updated.
	 * @throws CoreException
	 */
	IIndexFragmentFile commitUncommittedFile() throws CoreException;

	/**
	 * Adds content to the given file.

	void setFileContent(IIndexFragmentFile sourceFile, 
			int linkageID, IncludeInformation[] includes, 
			IASTPreprocessorStatement[] macros, IASTName[][] names,
			ASTFilePathResolver resolver, YieldableIndexLock lock) throws CoreException, InterruptedException;

	/**
	 * Clears the entire index.




 * Contributors:
 *    Markus Schorn - initial API and implementation
 *    Andrew Ferguson (Symbian)
 *    Sergey Prigogin (Google)
******************************************************************************/ 

package org.eclipse.cdt.internal.core.index;


import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.internal.core.index.IWritableIndex.IncludeInformation;
import org.eclipse.cdt.internal.core.pdom.ASTFilePathResolver;
import org.eclipse.cdt.internal.core.pdom.YieldableIndexLock;
import org.eclipse.core.runtime.CoreException;

/**


	/**
	 * Creates a file object for the given location and linkage or returns an existing one.
	 * @param fileLocation an IIndexFileLocation representing the location of the file.
	 * @return the existing IIndexFragmentFile for this location, or a newly created one. 
	 * @throws CoreException
	 */
	IIndexFragmentFile addFile(int linkageID, IIndexFileLocation fileLocation) throws CoreException;

	/**
	 * Creates a file object for the given location and linkage. The created file object is not added to
	 * the file index.
	 * @param fileLocation an IIndexFileLocation representing the location of the file.
	 * @return a newly created IIndexFragmentFile. 
	 * @throws CoreException
	 */
	IIndexFragmentFile addUncommittedFile(int linkageID, IIndexFileLocation fileLocation) throws CoreException;

	/**
	 * Makes the file that was created earlier by calling {@link #addUncommittedFile(int, IIndexFileLocation)}
	 * visible in the index.
     *
	 * @return The file that was updated.
	 * @throws CoreException
	 */
	IIndexFragmentFile commitUncommittedFile() throws CoreException;

	/**
	 * Adds includes, macros and names to the given file.
	 */
	void addFileContent(IIndexFragmentFile sourceFile, IncludeInformation[] includes,  
			IASTPreprocessorStatement[] macros, IASTName[][] names, ASTFilePathResolver resolver,
			YieldableIndexLock lock) throws CoreException, InterruptedException;

	/**
	 * Acquires a write lock, while giving up a certain amount of read locks.




 * Contributors:
 *    Markus Schorn - initial API and implementation
 *    Andrew Ferguson (Symbian)
 *    Sergey Prigogin (Google)
 *******************************************************************************/ 

package org.eclipse.cdt.internal.core.index;

import org.eclipse.cdt.core.index.IIndexFile;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.internal.core.pdom.ASTFilePathResolver;
import org.eclipse.cdt.internal.core.pdom.YieldableIndexLock;
import org.eclipse.core.runtime.CoreException;

public class WritableCIndex extends CIndex implements IWritableIndex {

		return fWritableFragment.getFiles(location);
	}

	public IIndexFragmentFile addFile(int linkageID, IIndexFileLocation location) throws CoreException {
		return fWritableFragment.addFile(linkageID, location);
	}

	public IIndexFragmentFile addUncommittedFile(int linkageID, IIndexFileLocation location) throws CoreException {
		return fWritableFragment.addUncommittedFile(linkageID, location);
	}

	public IIndexFragmentFile commitUncommittedFile() throws CoreException {
		return fWritableFragment.commitUncommittedFile();
	}

	private boolean isWritableFragment(IIndexFragment frag) {
		return frag == fWritableFragment;
	}

	public void setFileContent(IIndexFragmentFile file, int linkageID, IncludeInformation[] includes,
			IASTPreprocessorStatement[] macros, IASTName[][] names, ASTFilePathResolver resolver,
			YieldableIndexLock lock) throws CoreException, InterruptedException {
		IIndexFragment indexFragment = file.getIndexFragment();
		if (!isWritableFragment(indexFragment)) {
			assert false : "Attempt to update file of read-only fragment"; //$NON-NLS-1$

					ii.fTargetFile= addFile(linkageID, ii.fLocation);
				}
			}
			((IWritableIndexFragment) indexFragment).addFileContent(file, includes, macros, names, resolver, lock);
		}
	}





 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Doug Schaefer (QNX) - Initial API and implementation
 *    Markus Schorn (Wind River Systems)
 *    IBM Corporation
 *    Andrew Ferguson (Symbian)
 *    Anton Leherbauer (Wind River Systems)
 *    Sergey Prigogin (Google)
 *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom;


import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable;
import org.eclipse.cdt.core.index.IIndexBinding;
import org.eclipse.cdt.core.index.IIndexFile;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.core.index.IIndexLinkage;
import org.eclipse.cdt.core.index.IIndexLocationConverter;

		}
	}

	protected PDOMLinkage createLinkage(int linkageID) throws CoreException {
		PDOMLinkage pdomLinkage= fLinkageIDCache.get(linkageID);
		if (pdomLinkage == null) {
			final String linkageName= Linkage.getLinkageName(linkageID);

		}
	}


	public void releaseReadLock() {
		boolean clearCache= false;
		synchronized (mutex) {

		fireChange(event);
	}

	public boolean hasWaitingReaders() {
		synchronized (mutex) {
			return waitingReaders > 0;
		}
	}
	
	public long getLastWriteAccess() {
		return lastWriteAccess;
	}

		PDOMName name;
		if ((options & FIND_DECLARATIONS) != 0) {
			for (name= pdomBinding.getFirstDeclaration(); name != null; name= name.getNextInBinding()) {
				addName(name, names);
			}
		}
		if ((options & FIND_DEFINITIONS) != 0) {
			for (name = pdomBinding.getFirstDefinition(); name != null; name= name.getNextInBinding()) {
				addName(name, names);
			}
		}
		if ((options & FIND_REFERENCES) != 0) {
			for (name = pdomBinding.getFirstReference(); name != null; name= name.getNextInBinding()) {
				addName(name, names);
			}
		}
	}

			for (PDOMMacro macro= container.getFirstDefinition(); macro != null; macro= macro.getNextInContainer()) {
				final IIndexFragmentName name = macro.getDefinition();
				if (name != null) {
					addName(name, names);
				}
			}
		}
		if ((options & FIND_REFERENCES) != 0) {
			for (PDOMMacroReferenceName name = container.getFirstReference(); name != null; name= name.getNextInContainer()) {
				addName(name, names);
			}
		}
	}

	private void addName(IIndexFragmentName name, ArrayList<IIndexFragmentName> names) throws CoreException {
		IIndexFile file = name.getFile();
		if (file == null || file.getTimestamp() > 0) {
			names.add(name);
		}
	}

	public IIndexFragmentInclude[] findIncludedBy(IIndexFragmentFile file) throws CoreException {
		PDOMFile pdomFile= adaptFile(file);
		if (pdomFile != null) {
			List<PDOMInclude> result = new ArrayList<PDOMInclude>();
			for (PDOMInclude i= pdomFile.getFirstIncludedBy(); i != null; i= i.getNextInIncludedBy()) {
				if (i.getIncludedBy().getTimestamp() > 0) {
					result.add(i);
				}
			}
			return result.toArray(new PDOMInclude[result.size()]);
		}

	public String createKeyForCache(long record, char[] name) {
		return new StringBuilder(name.length+2).append((char) (record >> 16)).append((char) record).append(name).toString();
	}

	public boolean hasLastingDefinition(PDOMBinding binding) throws CoreException {
		return binding.hasDefinition();
	}
	
	private PDOMBinding[] getCrossLanguageBindings(IBinding binding) throws CoreException {
		switch(binding.getLinkage().getLinkageID()) {

Lines 7-12 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/PDOMProxy.java (+5 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Markus Schorn - initial API and implementation	9	* Markus Schorn - initial API and implementation
		10	* Sergey Prigogin (Google)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.internal.core.pdom;	12	package org.eclipse.cdt.internal.core.pdom;
12		13
Lines 187-192 Link Here
187	}	188	}
188	}	189	}
189		190
		191	public boolean hasWaitingReaders() {
		192	return fDelegate != null && fDelegate.hasWaitingReaders();
		193	}
		194
190	public synchronized void resetCacheCounters() {	195	public synchronized void resetCacheCounters() {
191	if (fDelegate != null)	196	if (fDelegate != null)
192	fDelegate.resetCacheCounters();	197	fDelegate.resetCacheCounters();




 * Contributors:
 *    Markus Schorn - initial API and implementation
 *    IBM Corporation
 *    Sergey Prigogin (Google)
 *******************************************************************************/ 
package org.eclipse.cdt.internal.core.pdom;


import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.core.index.IIndexInclude;
import org.eclipse.cdt.core.parser.IProblem;
import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;

 * @since 4.0
 */
abstract public class PDOMWriter {
	public static boolean FINE_GRAINED_LOCKING = true;
	public static int SKIP_ALL_REFERENCES= -1;
	public static int SKIP_TYPE_REFERENCES= 1;
	public static int SKIP_MACRO_REFERENCES= 2;

				if (fShowActivity) {
					trace("Indexer: adding " + ifl.getURI());  //$NON-NLS-1$
				}
				index.acquireWriteLock(readlockCount);
				long start= System.currentTimeMillis();
				Throwable th= null;
				YieldableIndexLock lock = new YieldableIndexLock(index, readlockCount, flushIndex);
				lock.acquire();
				try {
					storeFileInIndex(index, ifl, symbolMap, linkageID, configHash, contextIncludes, lock);
				} catch (RuntimeException e) {
					th= e; 
				} catch (PDOMNotImplementedError e) {

				} catch (AssertionError e) {
					th= e;
				} finally {
					lock.release();
				}
				if (th != null) {
					stati.add(createStatus(NLS.bind(Messages.PDOMWriter_errorWhileParsing,

				if (i < ifls.length - 1) {
					updateFileCount(0, 0, 1); // update header count
				}
				fStatistics.fAddToIndexTime += lock.getCumulativeLockTime();
			}
		}
	}


	private IIndexFragmentFile storeFileInIndex(IWritableIndex index, IIndexFileLocation location,
			Map<IIndexFileLocation, Symbols> symbolMap, int linkageID, int configHash,
			Set<IASTPreprocessorIncludeStatement> contextIncludes, YieldableIndexLock lock)
			throws CoreException, InterruptedException {
		Set<IIndexFileLocation> clearedContexts= Collections.emptySet();
		IIndexFragmentFile file;
		long timestamp = fResolver.getLastModified(location);
		if (FINE_GRAINED_LOCKING) {
			// In fine grained locking mode we create a temporary PDOMFile with zero timestamp,
			// add names to it, then replace contents of the old file from the temporary one, then
			// delete the temporary file. The write lock on the index is periodically yielded while
			// adding names to the temporary file, if the process takes long time.
			IIndexFragmentFile oldFile = index.getWritableFile(linkageID, location);
			if (oldFile != null) {
				IIndexInclude[] includedBy = index.findIncludedBy(oldFile);
				if (includedBy.length > 0) {
					clearedContexts= new HashSet<IIndexFileLocation>();
					for (IIndexInclude include : includedBy) {
						clearedContexts.add(include.getIncludedByLocation());
					}
				}
			}
			file= index.addUncommittedFile(linkageID, location);
		} else {
			file= index.getWritableFile(linkageID, location);
			if (file != null) {
				clearedContexts= new HashSet<IIndexFileLocation>();
				index.clearFile(file, clearedContexts);
			} else {
				file= index.addFile(linkageID, location);
			}
			file.setTimestamp(timestamp);
		}
		file.setTimestamp(fResolver.getLastModified(location));
		file.setScannerConfigurationHashcode(configHash);
		Symbols lists= symbolMap.get(location);
		if (lists != null) {

						(contextIncludes.contains(include) || clearedContexts.contains(info.fLocation));
				}
			}
			index.setFileContent(file, linkageID, includeInfos, macros, names, fResolver,
					FINE_GRAINED_LOCKING ? lock : null);
		}
		if (FINE_GRAINED_LOCKING) {
			file.setTimestamp(timestamp);
			file = index.commitUncommittedFile();
		}			
		return file;
	}
	




 * Contributors:
 *    Markus Schorn - initial API and implementation
 *    Andrew Ferguson (Symbian)
 *    Sergey Prigogin (Google)
 *******************************************************************************/ 
package org.eclipse.cdt.internal.core.pdom;


import org.eclipse.cdt.internal.core.index.IIndexFragmentFile;
import org.eclipse.cdt.internal.core.index.IWritableIndexFragment;
import org.eclipse.cdt.internal.core.index.IWritableIndex.IncludeInformation;
import org.eclipse.cdt.internal.core.pdom.db.BTree;
import org.eclipse.cdt.internal.core.pdom.db.ChunkCache;
import org.eclipse.cdt.internal.core.pdom.db.DBProperties;
import org.eclipse.cdt.internal.core.pdom.db.IBTreeVisitor;
import org.eclipse.cdt.internal.core.pdom.dom.IPDOMLinkageFactory;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMBinding;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMFile;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMLinkage;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMName;
import org.eclipse.core.runtime.CoreException;

public class WritablePDOM extends PDOM implements IWritableIndexFragment {	
	private boolean fClearedBecauseOfVersionMismatch= false;
	private boolean fCreatedFromScratch= false;
	private ASTFilePathResolver fPathResolver;
	private PDOMFile fileBeingUpdated;
	private PDOMFile uncommittedFile;
	private IIndexFileLocation uncommittedLocation;

	public WritablePDOM(File dbPath, IIndexLocationConverter locationConverter, Map<String, IPDOMLinkageFactory> linkageFactoryMappings) throws CoreException {
		this(dbPath, locationConverter, ChunkCache.getSharedInstance(), linkageFactoryMappings);


	@Override
	public IIndexFragmentFile addFile(int linkageID, IIndexFileLocation location) throws CoreException {
		if (uncommittedLocation != null && uncommittedLocation.equals(location)) {
			return uncommittedFile;
		}
		return super.addFile(linkageID, location);
	}

	public IIndexFragmentFile addUncommittedFile(int linkageID, IIndexFileLocation location) throws CoreException {
		uncommittedLocation = location;
		fileBeingUpdated = getFile(linkageID, uncommittedLocation);
		PDOMLinkage linkage= createLinkage(linkageID);
		uncommittedFile = new PDOMFile(linkage, location, linkageID);
		return uncommittedFile;
	}

	public IIndexFragmentFile commitUncommittedFile() throws CoreException {
		if (uncommittedFile == null)
			return null;
		IIndexFragmentFile file;
		if (fileBeingUpdated == null) {
			// New file.
			BTree fileIndex = getFileIndex();
			fileIndex.insert(uncommittedFile.getRecord());
			file = uncommittedFile;
		} else {
			// Existing file.
			fileBeingUpdated.replaceContentsFrom(uncommittedFile);
			file = fileBeingUpdated;
			fileBeingUpdated = null;
		}
		fEvent.fFilesWritten.add(uncommittedLocation);
		uncommittedFile = null;
		uncommittedLocation = null;
		return file;
	}

	public void addFileContent(IIndexFragmentFile sourceFile, IncludeInformation[] includes, 
			IASTPreprocessorStatement[] macros, IASTName[][] names, ASTFilePathResolver pathResolver,
			YieldableIndexLock lock) throws CoreException, InterruptedException {
		assert sourceFile.getIndexFragment() == this;
		
		PDOMFile pdomFile = (PDOMFile) sourceFile;

		final ASTFilePathResolver origResolver= fPathResolver;
		fPathResolver= pathResolver;
		try {
			pdomFile.addNames(names, lock);
		} finally {
			fPathResolver= origResolver;
		}
		
		final IIndexFileLocation location = pdomFile.getLocation();
		if (location != null) {
			fEvent.fClearedFiles.remove(location);
			fEvent.fFilesWritten.add(location);
		}
	}

	public void clearFile(IIndexFragmentFile file, Collection<IIndexFileLocation> contextsRemoved) throws CoreException {


	public PDOMFile getFileForASTPath(int linkageID, String astPath) throws CoreException {
		if (fPathResolver != null && astPath != null) {
			IIndexFileLocation location = fPathResolver.resolveASTPath(astPath);
			if (location.equals(uncommittedLocation))
				return fileBeingUpdated != null ? fileBeingUpdated : uncommittedFile;
			return getFile(linkageID, location);
		}
		return null;
	}

	@Override
	public boolean hasLastingDefinition(PDOMBinding binding) throws CoreException {
		if (fileBeingUpdated == null) {
			return binding.hasDefinition();
		}
		// Definitions in fileBeingUpdated will soon go away, so look for a definition elsewhere.
		for (PDOMName name = binding.getFirstDefinition(); name != null; name = name.getNextInBinding()) {
			if (!fileBeingUpdated.getPDOM().equals(name.getPDOM()) ||
					fileBeingUpdated.getRecord() != name.getFileRecord()) {
				return true;
			}
		}
		return false;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.cdt.internal.core.index.IWritableIndexFragment#getDatabaseSizeBytes()
	 */




/*******************************************************************************
 * Copyright (c) 2010 Google, Inc 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * 	  Sergey Prigogin (Google) - initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom;

import org.eclipse.cdt.internal.core.index.IWritableIndex;

/**
 * Write lock on the index that can be yielded temporarily to unblock threads that need
 * read access to the index. 
 * @since 5.2
 */
public class YieldableIndexLock {
	private final IWritableIndex index;
	private final int readlockCount;
	private final boolean flushIndex;
	private long lastLockTime;
	private long cumulativeLockTime;

	public YieldableIndexLock(IWritableIndex index, int readlockCount, boolean flushIndex) {
		this.index = index;
		this.readlockCount = readlockCount;
		this.flushIndex = flushIndex;
	}

	/**
	 * Acquires the lock.
	 * 
	 * @throws InterruptedException
	 */
	public void acquire() throws InterruptedException {
		index.acquireWriteLock(readlockCount);
		lastLockTime = System.currentTimeMillis();
	}

	/**
	 * Releases the lock.
	 */
	public void release() {
		if (lastLockTime != 0) {
			index.releaseWriteLock(readlockCount, flushIndex);
			cumulativeLockTime += System.currentTimeMillis() - lastLockTime;
			lastLockTime = 0;
		}
	}

	/**
	 * Yields the lock temporarily if it was held for YIELD_INTERVAL or more, and somebody is waiting
	 * for a read lock. 
	 * @throws InterruptedException
	 */
	public void yield() throws InterruptedException {
		if (index.hasWaitingReaders()) {
			index.releaseWriteLock(readlockCount, false);
			cumulativeLockTime += System.currentTimeMillis() - lastLockTime;
			lastLockTime = 0;
			acquire();
		}
	}

	/**
	 * @return Total time the lock was held in milliseconds. 
	 */
	public long getCumulativeLockTime() {
		return cumulativeLockTime;
	}
}




 *    QNX - Initial API and implementation
 *    Markus Schorn (Wind River Systems)
 *    Andrew Ferguson (Symbian)
 *    Sergey Prigogin (Google)
 *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom.dom;


import org.eclipse.cdt.core.dom.ast.IMacroBinding;
import org.eclipse.cdt.core.dom.ast.IParameter;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPUsingDirective;
import org.eclipse.cdt.core.index.IIndexFile;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.core.index.IIndexInclude;
import org.eclipse.cdt.core.index.IIndexLocationConverter;

import org.eclipse.cdt.internal.core.index.IndexFileLocation;
import org.eclipse.cdt.internal.core.index.IWritableIndex.IncludeInformation;
import org.eclipse.cdt.internal.core.pdom.PDOM;
import org.eclipse.cdt.internal.core.pdom.YieldableIndexLock;
import org.eclipse.cdt.internal.core.pdom.db.BTree;
import org.eclipse.cdt.internal.core.pdom.db.Database;
import org.eclipse.cdt.internal.core.pdom.db.IBTreeComparator;

		return record;
	}

	public PDOM getPDOM() {
		return fLinkage.getPDOM();
	}
	
	@Override
	public boolean equals(Object obj) {
		if (obj == this)

	}
	
	/**
	 * Transfers names, macros and includes from another file to this one and deletes the other file.
	 * @param sourceFile the file to transfer the local bindings from.
	 * @throws CoreException
	 */
	public void replaceContentsFrom(PDOMFile sourceFile) throws CoreException {
		ICPPUsingDirective[] directives= getUsingDirectives();
		for (ICPPUsingDirective ud : directives) {
			if (ud instanceof IPDOMNode) {
				((IPDOMNode) ud).delete(null);
			}
		}
		setFirstUsingDirectiveRec(sourceFile.getLastUsingDirectiveRec());

		// Replace the includes
		PDOMInclude include = getFirstInclude();
		while (include != null) {
			PDOMInclude nextInclude = include.getNextInIncludes();
			IIndexFile includedBy = include.getIncludedBy();
			if (includedBy.equals(this)) {
				include.delete();
			}
			include = nextInclude;
		}
		include = sourceFile.getFirstInclude();
		setFirstInclude(include);
		while (include != null) {
			IIndexFile includedBy = include.getIncludedBy();
			if (includedBy.equals(sourceFile)) {
				include.setIncludedBy(this);
			}
			include = include.getNextInIncludes();
		}

		include = sourceFile.getFirstIncludedBy();
		setFirstIncludedBy(include);
		while (include != null) {
			include.setIncludes(this);
			include = include.getNextInIncludedBy();
		}

		// Replace all the macros in this file.
		PDOMLinkage linkage= getLinkage();
		PDOMMacro macro = getFirstMacro();
		while (macro != null) {
			PDOMMacro nextMacro = macro.getNextMacro();
			macro.delete(linkage);
			macro = nextMacro;
		}
		macro = sourceFile.getFirstMacro();
		setFirstMacro(macro);
		for (; macro != null; macro = macro.getNextMacro()) {
			macro.setFile(this);
		}

		// Replace all macro references
		ArrayList<PDOMMacroReferenceName> mrefs= new ArrayList<PDOMMacroReferenceName>();
		PDOMMacroReferenceName mref = getFirstMacroReference();
		while (mref != null) {
			mrefs.add(mref);
			mref= mref.getNextInFile();
		}
		for (PDOMMacroReferenceName m : mrefs) {
			m.delete();
		}
		mref = sourceFile.getFirstMacroReference();
		setFirstMacroReference(mref);
		for (; mref != null; mref = mref.getNextInFile()) {
			mref.setFile(this);
		}

		// Replace all the names in this file
		ArrayList<PDOMName> names= new ArrayList<PDOMName>();
		PDOMName name = getFirstName();
		for (; name != null; name= name.getNextInFile()) {
			names.add(name);
			linkage.onDeleteName(name);
		}
		for (Iterator<PDOMName> iterator = names.iterator(); iterator.hasNext();) {
			name = iterator.next();
			name.delete();
		}
		name = sourceFile.getFirstName();
		setFirstName(name);
		for (; name != null; name= name.getNextInFile()) {
			name.setFile(this);
		}

		setTimestamp(sourceFile.getTimestamp());
		setScannerConfigurationHashcode(sourceFile.getScannerConfigurationHashcode());

		sourceFile.delete();
	}

	/**
	 * This method should not be called on PDOMFile objects that are referenced by the file index.
	 * @param location a new location
	 * @throws CoreException
	 */
	public void setLocation(IIndexFileLocation location) throws CoreException {
		String locationString = fLinkage.getPDOM().getLocationConverter().toInternalFormat(location);
		if (locationString == null)
			throw new CoreException(CCorePlugin.createStatus(Messages.getString("PDOMFile.toInternalProblem") + //$NON-NLS-1$
					location.getURI()));
		setInternalLocation(locationString);
	}

	/**
	 * Directly changes this record's internal location string. The format of this string is unspecified
	 * in general and is determined by the associated IIndexLocationConverter.
	 * This method should not be called on PDOMFile objects that are referenced by the file index.
	 * @param internalLocation
	 * @throws CoreException
	 */

		return fLinkage;
	}

	public void addNames(IASTName[][] names, YieldableIndexLock lock) throws CoreException, InterruptedException {
		assert getFirstName() == null;
		assert getFirstMacroReference() == null;
		final PDOMLinkage linkage= getLinkage();
		HashMap<IASTName, PDOMName> nameCache= new HashMap<IASTName, PDOMName>();
		PDOMName lastName= null;
		PDOMMacroReferenceName lastMacroName= null;
		int counter = 0;
		for (IASTName[] name : names) {
			if (name[0] != null) {
				// Once in a while check if anybody waits for index reader lock
				// and yield the writer lock if so.
				if (lock != null && ++counter >= 50) {
					counter = 0;
					lock.yield();
				}
				PDOMName caller= nameCache.get(name[1]);
				IIndexFragmentName fname= createPDOMName(linkage, name[0], caller);
				if (fname instanceof PDOMName) {

			include.delete();
			include = nextInclude;
		}
		setFirstInclude(null);

		// Delete all the macros in this file
		PDOMLinkage linkage= getLinkage();

		setTimestamp(-1);
	}

	private void delete() throws CoreException {
		fLinkage.getDB().free(record);
	}

	public void addIncludesTo(IncludeInformation[] includeInfos) throws CoreException {
		assert getFirstInclude() == null;


Lines 141-146 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMInclude.java (-1 / +6 lines)
141	return rec != 0 ? new PDOMFile(linkage, rec) : null;	141	return rec != 0 ? new PDOMFile(linkage, rec) : null;
142	}	142	}
143		143
		144	void setIncludes(PDOMFile includedFile) throws CoreException {
		145	long rec = includedFile != null ? includedFile.getRecord() : 0;
		146	linkage.getDB().putRecPtr(record + INCLUDED_FILE, rec);
		147	}
		148
144	/**	149	/**
145	* Checks if the name is the same as the end part of the path of the included file.	150	* Checks if the name is the same as the end part of the path of the included file.
146	*/	151	*/
Lines 166-172 Link Here
166	return rec != 0 ? new PDOMFile(linkage, rec) : null;	171	return rec != 0 ? new PDOMFile(linkage, rec) : null;
167	}	172	}
168		173
169	private void setIncludedBy(PDOMFile includedBy) throws CoreException {	174	void setIncludedBy(PDOMFile includedBy) throws CoreException {
170	long rec = includedBy != null ? includedBy.getRecord() : 0;	175	long rec = includedBy != null ? includedBy.getRecord() : 0;
171	linkage.getDB().putRecPtr(record + INCLUDED_BY, rec);	176	linkage.getDB().putRecPtr(record + INCLUDED_BY, rec);
172	}	177	}

Lines 9-14 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMMacro.java (+5 lines)
9	* QNX - Initial API and implementation	9	* QNX - Initial API and implementation
10	* Markus Schorn (Wind River Systems)	10	* Markus Schorn (Wind River Systems)
11	* Andrew Ferguson (Symbian)	11	* Andrew Ferguson (Symbian)
		12	* Sergey Prigogin (Google)
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.cdt.internal.core.pdom.dom;	14	package org.eclipse.cdt.internal.core.pdom.dom;
14		15
Lines 269-274 Link Here
269	return filerec != 0 ? new PDOMFile(fLinkage, filerec) : null;	270	return filerec != 0 ? new PDOMFile(fLinkage, filerec) : null;
270	}	271	}
271		272
		273	void setFile(PDOMFile file) throws CoreException {
		274	fLinkage.getDB().putRecPtr(fRecord + FILE, file != null ? file.getRecord() : 0);
		275	}
		276
272	public int getEndingLineNumber() {	277	public int getEndingLineNumber() {
273	return 0;	278	return 0;
274	}	279	}

Lines 8-13 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMMacroReferenceName.java (-1 / +6 lines)
8	* Contributors:	8	* Contributors:
9	* QNX - Initial API and implementation	9	* QNX - Initial API and implementation
10	* Markus Schorn (Wind River Systems)	10	* Markus Schorn (Wind River Systems)
		11	* Sergey Prigogin (Google)
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.cdt.internal.core.pdom.dom;	13	package org.eclipse.cdt.internal.core.pdom.dom;
13		14
Lines 110-116 Link Here
110	long filerec = linkage.getDB().getRecPtr(record + FILE_REC_OFFSET);	111	long filerec = linkage.getDB().getRecPtr(record + FILE_REC_OFFSET);
111	return filerec != 0 ? new PDOMFile(linkage, filerec) : null;	112	return filerec != 0 ? new PDOMFile(linkage, filerec) : null;
112	}	113	}
113		114
		115	void setFile(PDOMFile file) throws CoreException {
		116	linkage.getDB().putRecPtr(record + FILE_REC_OFFSET, file != null ? file.getRecord() : 0);
		117	}
		118
114	PDOMMacroReferenceName getNextInFile() throws CoreException {	119	PDOMMacroReferenceName getNextInFile() throws CoreException {
115	return getNameField(FILE_NEXT_OFFSET);	120	return getNameField(FILE_NEXT_OFFSET);
116	}	121	}

Lines 8-13 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMName.java (+14 lines)
8	* Contributors:	8	* Contributors:
9	* QNX - Initial API and implementation	9	* QNX - Initial API and implementation
10	* Markus Schorn (Wind River Systems)	10	* Markus Schorn (Wind River Systems)
		11	* Sergey Prigogin (Google)
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.cdt.internal.core.pdom.dom;	13	package org.eclipse.cdt.internal.core.pdom.dom;
13		14
Lines 22-27 Link Here
22	import org.eclipse.cdt.core.parser.util.CharArrayUtils;	23	import org.eclipse.cdt.core.parser.util.CharArrayUtils;
23	import org.eclipse.cdt.internal.core.index.IIndexFragment;	24	import org.eclipse.cdt.internal.core.index.IIndexFragment;
24	import org.eclipse.cdt.internal.core.index.IIndexFragmentName;	25	import org.eclipse.cdt.internal.core.index.IIndexFragmentName;
		26	import org.eclipse.cdt.internal.core.pdom.PDOM;
25	import org.eclipse.cdt.internal.core.pdom.db.Database;	27	import org.eclipse.cdt.internal.core.pdom.db.Database;
26	import org.eclipse.core.runtime.CoreException;	28	import org.eclipse.core.runtime.CoreException;
27	import org.eclipse.core.runtime.IPath;	29	import org.eclipse.core.runtime.IPath;
Lines 121-126 Link Here
121	linkage.getDB().putRecPtr(record + offset, fieldrec);	123	linkage.getDB().putRecPtr(record + offset, fieldrec);
122	}	124	}
123		125
		126	public PDOM getPDOM() {
		127	return linkage.getPDOM();
		128	}
		129
124	public PDOMBinding getBinding() throws CoreException {	130	public PDOMBinding getBinding() throws CoreException {
125	long bindingrec = getRecField(BINDING_REC_OFFSET);	131	long bindingrec = getRecField(BINDING_REC_OFFSET);
126	return linkage.getBinding(bindingrec);	132	return linkage.getBinding(bindingrec);
Lines 162-167 Link Here
162	return filerec != 0 ? new PDOMFile(linkage, filerec) : null;	168	return filerec != 0 ? new PDOMFile(linkage, filerec) : null;
163	}	169	}
164		170
		171	public long getFileRecord() throws CoreException {
		172	return linkage.getDB().getRecPtr(record + FILE_REC_OFFSET);
		173	}
		174
		175	void setFile(PDOMFile file) throws CoreException {
		176	linkage.getDB().putRecPtr(record + FILE_REC_OFFSET, file != null ? file.getRecord() : 0);
		177	}
		178
165	public IIndexName getEnclosingDefinition() throws CoreException {	179	public IIndexName getEnclosingDefinition() throws CoreException {
166	long namerec = getEnclosingDefinitionRecord();	180	long namerec = getEnclosingDefinitionRecord();
167	return namerec != 0 ? new PDOMName(linkage, namerec) : null;	181	return namerec != 0 ? new PDOMName(linkage, namerec) : null;

Lines 299-305 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPLinkage.java (-3 / +3 lines)
299	if (fromName.isDefinition()) {	299	if (fromName.isDefinition()) {
300	return true;	300	return true;
301	}	301	}
302	return !pdomBinding.hasDefinition();	302	return !getPDOM().hasLastingDefinition(pdomBinding);
303	}	303	}
304	return false;	304	return false;
305	}	305	}
Lines 444-451 Link Here
444	if (!(method instanceof IProblemBinding)) {	444	if (!(method instanceof IProblemBinding)) {
445	PDOMBinding pdomBinding= adaptBinding(method);	445	PDOMBinding pdomBinding= adaptBinding(method);
446	if (pdomBinding == null) {	446	if (pdomBinding == null) {
447	createBinding(type, method, fileLocalRec);	447	pdomBinding = createBinding(type, method, fileLocalRec);
448	} else if (!pdomBinding.hasDefinition()) {	448	} else if (!getPDOM().hasLastingDefinition(pdomBinding)) {
449	pdomBinding.update(this, method);	449	pdomBinding.update(this, method);
450	}	450	}
451	}	451	}

Lines 8-13 Link Here

(-)parser/org/eclipse/cdt/internal/index/tests/EmptyIndexFragment.java (+6 lines)
8	* Contributors:	8	* Contributors:
9	* Andrew Ferguson (Symbian) - initial API and implementation	9	* Andrew Ferguson (Symbian) - initial API and implementation
10	* Markus Schorn (Wind River Systems)	10	* Markus Schorn (Wind River Systems)
		11	* Sergey Prigogin (Google)
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.cdt.internal.index.tests;	13	package org.eclipse.cdt.internal.index.tests;
13		14
Lines 123-128 Link Here
123	}	124	}
124		125
125	public void releaseReadLock() {}	126	public void releaseReadLock() {}
		127
		128	public boolean hasWaitingReaders() {
		129	return false;
		130	}
		131
126	public void resetCacheCounters() {}	132	public void resetCacheCounters() {}
127		133
128	public IIndexFragmentFileSet createFileSet() {	134	public IIndexFragmentFileSet createFileSet() {

Return to bug 287907

Lines 6-16 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/PDOM.java (-13 / +33 lines)
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Doug Schaefer (QNX) - Initial API and implementation	9	* Doug Schaefer (QNX) - Initial API and implementation
10	* Markus Schorn (Wind River Systems)	10	* Markus Schorn (Wind River Systems)
11	* IBM Corporation	11	* IBM Corporation
12	* Andrew Ferguson (Symbian)	12	* Andrew Ferguson (Symbian)
13	* Anton Leherbauer (Wind River Systems)	13	* Anton Leherbauer (Wind River Systems)
		14	* Sergey Prigogin (Google)
14	*******************************************************************************/	15	*******************************************************************************/
15	package org.eclipse.cdt.internal.core.pdom;	16	package org.eclipse.cdt.internal.core.pdom;
16		17
Lines 48-53 Link Here
48	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;	49	import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
49	import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable;	50	import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable;
50	import org.eclipse.cdt.core.index.IIndexBinding;	51	import org.eclipse.cdt.core.index.IIndexBinding;
		52	import org.eclipse.cdt.core.index.IIndexFile;
51	import org.eclipse.cdt.core.index.IIndexFileLocation;	53	import org.eclipse.cdt.core.index.IIndexFileLocation;
52	import org.eclipse.cdt.core.index.IIndexLinkage;	54	import org.eclipse.cdt.core.index.IIndexLinkage;
53	import org.eclipse.cdt.core.index.IIndexLocationConverter;	55	import org.eclipse.cdt.core.index.IIndexLocationConverter;
Lines 341-347 Link Here
341	}	343	}
342	}	344	}
343		345
344	private PDOMLinkage createLinkage(int linkageID) throws CoreException {	346	protected PDOMLinkage createLinkage(int linkageID) throws CoreException {
345	PDOMLinkage pdomLinkage= fLinkageIDCache.get(linkageID);	347	PDOMLinkage pdomLinkage= fLinkageIDCache.get(linkageID);
346	if (pdomLinkage == null) {	348	if (pdomLinkage == null) {
347	final String linkageName= Linkage.getLinkageName(linkageID);	349	final String linkageName= Linkage.getLinkageName(linkageID);
Lines 783-789 Link Here
783	}	785	}
784	}	786	}
785		787
786
787	public void releaseReadLock() {	788	public void releaseReadLock() {
788	boolean clearCache= false;	789	boolean clearCache= false;
789	synchronized (mutex) {	790	synchronized (mutex) {
Lines 884-889 Link Here
884	fireChange(event);	885	fireChange(event);
885	}	886	}
886		887
		888	public boolean hasWaitingReaders() {
		889	synchronized (mutex) {
		890	return waitingReaders > 0;
		891	}
		892	}
		893
887	public long getLastWriteAccess() {	894	public long getLastWriteAccess() {
888	return lastWriteAccess;	895	return lastWriteAccess;
889	}	896	}
Lines 957-973 Link Here
957	PDOMName name;	964	PDOMName name;
958	if ((options & FIND_DECLARATIONS) != 0) {	965	if ((options & FIND_DECLARATIONS) != 0) {
959	for (name= pdomBinding.getFirstDeclaration(); name != null; name= name.getNextInBinding()) {	966	for (name= pdomBinding.getFirstDeclaration(); name != null; name= name.getNextInBinding()) {
960	names.add(name);	967	addName(name, names);
961	}	968	}
962	}	969	}
963	if ((options & FIND_DEFINITIONS) != 0) {	970	if ((options & FIND_DEFINITIONS) != 0) {
964	for (name = pdomBinding.getFirstDefinition(); name != null; name= name.getNextInBinding()) {	971	for (name = pdomBinding.getFirstDefinition(); name != null; name= name.getNextInBinding()) {
965	names.add(name);	972	addName(name, names);
966	}	973	}
967	}	974	}
968	if ((options & FIND_REFERENCES) != 0) {	975	if ((options & FIND_REFERENCES) != 0) {
969	for (name = pdomBinding.getFirstReference(); name != null; name= name.getNextInBinding()) {	976	for (name = pdomBinding.getFirstReference(); name != null; name= name.getNextInBinding()) {
970	names.add(name);	977	addName(name, names);
971	}	978	}
972	}	979	}
973	}	980	}
Lines 978-1000 Link Here
978	for (PDOMMacro macro= container.getFirstDefinition(); macro != null; macro= macro.getNextInContainer()) {	985	for (PDOMMacro macro= container.getFirstDefinition(); macro != null; macro= macro.getNextInContainer()) {
979	final IIndexFragmentName name = macro.getDefinition();	986	final IIndexFragmentName name = macro.getDefinition();
980	if (name != null) {	987	if (name != null) {
981	names.add(name);	988	addName(name, names);
982	}	989	}
983	}	990	}
984	}	991	}
985	if ((options & FIND_REFERENCES) != 0) {	992	if ((options & FIND_REFERENCES) != 0) {
986	for (PDOMMacroReferenceName name = container.getFirstReference(); name != null; name= name.getNextInContainer()) {	993	for (PDOMMacroReferenceName name = container.getFirstReference(); name != null; name= name.getNextInContainer()) {
987	names.add(name);	994	addName(name, names);
988	}	995	}
989	}	996	}
990	}	997	}
991		998
		999	private void addName(IIndexFragmentName name, ArrayList<IIndexFragmentName> names) throws CoreException {
		1000	IIndexFile file = name.getFile();
		1001	if (file == null \|\| file.getTimestamp() > 0) {
		1002	names.add(name);
		1003	}
		1004	}
		1005
992	public IIndexFragmentInclude[] findIncludedBy(IIndexFragmentFile file) throws CoreException {	1006	public IIndexFragmentInclude[] findIncludedBy(IIndexFragmentFile file) throws CoreException {
993	PDOMFile pdomFile= adaptFile(file);	1007	PDOMFile pdomFile= adaptFile(file);
994	if (pdomFile != null) {	1008	if (pdomFile != null) {
995	List<PDOMInclude> result = new ArrayList<PDOMInclude>();	1009	List<PDOMInclude> result = new ArrayList<PDOMInclude>();
996	for (PDOMInclude i= pdomFile.getFirstIncludedBy(); i != null; i= i.getNextInIncludedBy()) {	1010	for (PDOMInclude i= pdomFile.getFirstIncludedBy(); i != null; i= i.getNextInIncludedBy()) {
997	result.add(i);	1011	if (i.getIncludedBy().getTimestamp() > 0) {
		1012	result.add(i);
		1013	}
998	}	1014	}
999	return result.toArray(new PDOMInclude[result.size()]);	1015	return result.toArray(new PDOMInclude[result.size()]);
1000	}	1016	}
Lines 1197-1202 Link Here
1197	public String createKeyForCache(long record, char[] name) {	1213	public String createKeyForCache(long record, char[] name) {
1198	return new StringBuilder(name.length+2).append((char) (record >> 16)).append((char) record).append(name).toString();	1214	return new StringBuilder(name.length+2).append((char) (record >> 16)).append((char) record).append(name).toString();
1199	}	1215	}
		1216
		1217	public boolean hasLastingDefinition(PDOMBinding binding) throws CoreException {
		1218	return binding.hasDefinition();
		1219	}
1200		1220
1201	private PDOMBinding[] getCrossLanguageBindings(IBinding binding) throws CoreException {	1221	private PDOMBinding[] getCrossLanguageBindings(IBinding binding) throws CoreException {
1202	switch(binding.getLinkage().getLinkageID()) {	1222	switch(binding.getLinkage().getLinkageID()) {

Added Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/YieldableIndexLock.java (+74 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 Google, Inc and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Sergey Prigogin (Google) - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.cdt.internal.core.pdom;
12
13	import org.eclipse.cdt.internal.core.index.IWritableIndex;
14
15	/**
16	* Write lock on the index that can be yielded temporarily to unblock threads that need
17	* read access to the index.
18	* @since 5.2
19	*/
20	public class YieldableIndexLock {
21	private final IWritableIndex index;
22	private final int readlockCount;
23	private final boolean flushIndex;
24	private long lastLockTime;
25	private long cumulativeLockTime;
26
27	public YieldableIndexLock(IWritableIndex index, int readlockCount, boolean flushIndex) {
28	this.index = index;
29	this.readlockCount = readlockCount;
30	this.flushIndex = flushIndex;
31	}
32
33	/**
34	* Acquires the lock.
35	*
36	* @throws InterruptedException
37	*/
38	public void acquire() throws InterruptedException {
39	index.acquireWriteLock(readlockCount);
40	lastLockTime = System.currentTimeMillis();
41	}
42
43	/**
44	* Releases the lock.
45	*/
46	public void release() {
47	if (lastLockTime != 0) {
48	index.releaseWriteLock(readlockCount, flushIndex);
49	cumulativeLockTime += System.currentTimeMillis() - lastLockTime;
50	lastLockTime = 0;
51	}
52	}
53
54	/**
55	* Yields the lock temporarily if it was held for YIELD_INTERVAL or more, and somebody is waiting
56	* for a read lock.
57	* @throws InterruptedException
58	*/
59	public void yield() throws InterruptedException {
60	if (index.hasWaitingReaders()) {
61	index.releaseWriteLock(readlockCount, false);
62	cumulativeLockTime += System.currentTimeMillis() - lastLockTime;
63	lastLockTime = 0;
64	acquire();
65	}
66	}
67
68	/**
69	* @return Total time the lock was held in milliseconds.
70	*/
71	public long getCumulativeLockTime() {
72	return cumulativeLockTime;
73	}
74	}