Attachment #157044 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;

	/**
	 * Removes an uncommitted file if there is one. Used to recover from a failed index update.
	 *  
	 * @throws CoreException
	 */
	void clearUncommittedFile() 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 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;

	/**
	 * Removes an uncommitted file if there is one. Used to recover from a failed index update.
	 *  
	 * @throws CoreException
	 */
	void clearUncommittedFile() 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();
	}

	public void clearUncommittedFile() throws CoreException {
		fWritableFragment.clearUncommittedFile();
	}

	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;


public class PDOM extends PlatformObject implements IPDOM {
	private static final int BLOCKED_WRITE_LOCK_OUTPUT_INTERVAL = 30000;
	private static final int LONG_WRITE_LOCK_REPORT_THRESHOLD = 1000;
	private static final int LONG_READ_LOCK_WAIT_REPORT_THRESHOLD = 1000;
	static boolean sDEBUG_LOCKS= false; // initialized in the PDOMManager, because IBM needs PDOM independent of runtime plugin.

	/**

		}
	}

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

	private long timeWriteLockAcquired;

	public void acquireReadLock() throws InterruptedException {
		long t = sDEBUG_LOCKS ? System.nanoTime() : 0;
		synchronized (mutex) {
			++waitingReaders;
			try {

			}
			++lockCount;
			db.setLocked(true);

			if (sDEBUG_LOCKS) {
				t = (System.nanoTime() - t) / 1000000;
				if (t >= LONG_READ_LOCK_WAIT_REPORT_THRESHOLD) {
					System.out.println("Acquired index read lock after " + t + " ms wait."); //$NON-NLS-1$//$NON-NLS-2$
				}
				incReadLock(fLockDebugging);
			}
		}
	}


	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()) {
				if (isCommitted(name)) {
					names.add(name);
				}
			}
		}
		if ((options & FIND_DEFINITIONS) != 0) {
			for (name = pdomBinding.getFirstDefinition(); name != null; name= name.getNextInBinding()) {
				if (isCommitted(name)) {
					names.add(name);
				}
			}
		}
		if ((options & FIND_REFERENCES) != 0) {
			for (name = pdomBinding.getFirstReference(); name != null; name= name.getNextInBinding()) {
				if (isCommitted(name)) {
					names.add(name);
				}
			}
		}
	}

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

	protected boolean isCommitted(PDOMName name) throws CoreException {
		return true;
	}

	protected boolean isCommitted(PDOMMacro name) throws CoreException {
		return true;
	}

	protected boolean isCommitted(PDOMMacroReferenceName name) throws CoreException {
		return true;
	}

	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();

Lines 8-13 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/PDOMWriter.java (-33 / +68 lines)
8	* Contributors:	8	* Contributors:
9	* Markus Schorn - initial API and implementation	9	* Markus Schorn - initial API and implementation
10	* IBM Corporation	10	* IBM Corporation
		11	* Sergey Prigogin (Google)
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.cdt.internal.core.pdom;	13	package org.eclipse.cdt.internal.core.pdom;
13		14
Lines 46-51 Link Here
46	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;	47	import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
47	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier;	48	import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCompositeTypeSpecifier.ICPPASTBaseSpecifier;
48	import org.eclipse.cdt.core.index.IIndexFileLocation;	49	import org.eclipse.cdt.core.index.IIndexFileLocation;
		50	import org.eclipse.cdt.core.index.IIndexInclude;
49	import org.eclipse.cdt.core.parser.IProblem;	51	import org.eclipse.cdt.core.parser.IProblem;
50	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;	52	import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
51	import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;	53	import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;
Lines 68-73 Link Here
68	* @since 4.0	70	* @since 4.0
69	*/	71	*/
70	abstract public class PDOMWriter {	72	abstract public class PDOMWriter {
		73	// TODO(sprigogin): Remove SEMI_TRANSACTIONAL_UPDATES and ALLOW_LOCK_YIELDING constants and simplify the code.
		74	public static boolean SEMI_TRANSACTIONAL_UPDATES = true;
		75	public static boolean ALLOW_LOCK_YIELDING = true;
71	public static int SKIP_ALL_REFERENCES= -1;	76	public static int SKIP_ALL_REFERENCES= -1;
72	public static int SKIP_TYPE_REFERENCES= 1;	77	public static int SKIP_TYPE_REFERENCES= 1;
73	public static int SKIP_MACRO_REFERENCES= 2;	78	public static int SKIP_MACRO_REFERENCES= 2;
Lines 200-210 Link Here
200	if (fShowActivity) {	205	if (fShowActivity) {
201	trace("Indexer: adding " + ifl.getURI()); //$NON-NLS-1$	206	trace("Indexer: adding " + ifl.getURI()); //$NON-NLS-1$
202	}	207	}
203	index.acquireWriteLock(readlockCount);
204	long start= System.currentTimeMillis();
205	Throwable th= null;	208	Throwable th= null;
		209	YieldableIndexLock lock = new YieldableIndexLock(index, readlockCount, flushIndex);
		210	lock.acquire();
206	try {	211	try {
207	storeFileInIndex(index, ifl, symbolMap, linkageID, configHash, contextIncludes);	212	storeFileInIndex(index, ifl, symbolMap, linkageID, configHash, contextIncludes, lock);
208	} catch (RuntimeException e) {	213	} catch (RuntimeException e) {
209	th= e;	214	th= e;
210	} catch (PDOMNotImplementedError e) {	215	} catch (PDOMNotImplementedError e) {
Lines 214-220 Link Here
214	} catch (AssertionError e) {	219	} catch (AssertionError e) {
215	th= e;	220	th= e;
216	} finally {	221	} finally {
217	index.releaseWriteLock(readlockCount, flushIndex);	222	lock.release();
218	}	223	}
219	if (th != null) {	224	if (th != null) {
220	stati.add(createStatus(NLS.bind(Messages.PDOMWriter_errorWhileParsing,	225	stati.add(createStatus(NLS.bind(Messages.PDOMWriter_errorWhileParsing,
Lines 223-229 Link Here
223	if (i < ifls.length - 1) {	228	if (i < ifls.length - 1) {
224	updateFileCount(0, 0, 1); // update header count	229	updateFileCount(0, 0, 1); // update header count
225	}	230	}
226	fStatistics.fAddToIndexTime += System.currentTimeMillis() - start;	231	fStatistics.fAddToIndexTime += lock.getCumulativeLockTime();
227	}	232	}
228	}	233	}
229	}	234	}
Lines 448-487 Link Here
448		453
449	private IIndexFragmentFile storeFileInIndex(IWritableIndex index, IIndexFileLocation location,	454	private IIndexFragmentFile storeFileInIndex(IWritableIndex index, IIndexFileLocation location,
450	Map<IIndexFileLocation, Symbols> symbolMap, int linkageID, int configHash,	455	Map<IIndexFileLocation, Symbols> symbolMap, int linkageID, int configHash,
451	Set<IASTPreprocessorIncludeStatement> contextIncludes) throws CoreException {	456	Set<IASTPreprocessorIncludeStatement> contextIncludes, YieldableIndexLock lock)
		457	throws CoreException, InterruptedException {
452	Set<IIndexFileLocation> clearedContexts= Collections.emptySet();	458	Set<IIndexFileLocation> clearedContexts= Collections.emptySet();
453	IIndexFragmentFile file= index.getWritableFile(linkageID, location);	459	IIndexFragmentFile file;
454	if (file != null) {	460	long timestamp = fResolver.getLastModified(location);
455	clearedContexts= new HashSet<IIndexFileLocation>();	461	if (SEMI_TRANSACTIONAL_UPDATES) {
456	index.clearFile(file, clearedContexts);	462	// In fine grained locking mode we create a temporary PDOMFile with zero timestamp,
		463	// add names to it, then replace contents of the old file from the temporary one, then
		464	// delete the temporary file. The write lock on the index is periodically yielded while
		465	// adding names to the temporary file, if the process takes long time.
		466	IIndexFragmentFile oldFile = index.getWritableFile(linkageID, location);
		467	if (oldFile != null) {
		468	IIndexInclude[] includedBy = index.findIncludedBy(oldFile);
		469	if (includedBy.length > 0) {
		470	clearedContexts= new HashSet<IIndexFileLocation>();
		471	for (IIndexInclude include : includedBy) {
		472	clearedContexts.add(include.getIncludedByLocation());
		473	}
		474	}
		475	}
		476	file= index.addUncommittedFile(linkageID, location);
457	} else {	477	} else {
458	file= index.addFile(linkageID, location);	478	file= index.getWritableFile(linkageID, location);
		479	if (file != null) {
		480	clearedContexts= new HashSet<IIndexFileLocation>();
		481	index.clearFile(file, clearedContexts);
		482	} else {
		483	file= index.addFile(linkageID, location);
		484	}
		485	file.setTimestamp(timestamp);
459	}	486	}
460	file.setTimestamp(fResolver.getLastModified(location));	487	try {
461	file.setScannerConfigurationHashcode(configHash);	488	file.setScannerConfigurationHashcode(configHash);
462	Symbols lists= symbolMap.get(location);	489	Symbols lists= symbolMap.get(location);
463	if (lists != null) {	490	if (lists != null) {
464	IASTPreprocessorStatement[] macros= lists.fMacros.toArray(new IASTPreprocessorStatement[lists.fMacros.size()]);	491	IASTPreprocessorStatement[] macros= lists.fMacros.toArray(new IASTPreprocessorStatement[lists.fMacros.size()]);
465	IASTName[][] names= lists.fNames.toArray(new IASTName[lists.fNames.size()][]);	492	IASTName[][] names= lists.fNames.toArray(new IASTName[lists.fNames.size()][]);
466	for (IASTName[] name2 : names) {	493	for (IASTName[] name2 : names) {
467	final IASTName name= name2[0];	494	final IASTName name= name2[0];
468	if (name != null) {	495	if (name != null) {
469	ASTInternal.setFullyResolved(name.getBinding(), true);	496	ASTInternal.setFullyResolved(name.getBinding(), true);
		497	}
470	}	498	}
471	}	499
472		500	IncludeInformation[] includeInfos= new IncludeInformation[lists.fIncludes.size()];
473	IncludeInformation[] includeInfos= new IncludeInformation[lists.fIncludes.size()];	501	for (int i= 0; i < lists.fIncludes.size(); i++) {
474	for (int i= 0; i < lists.fIncludes.size(); i++) {	502	final IASTPreprocessorIncludeStatement include = lists.fIncludes.get(i);
475	final IASTPreprocessorIncludeStatement include = lists.fIncludes.get(i);	503	final IncludeInformation info= includeInfos[i]= new IncludeInformation();
476	final IncludeInformation info= includeInfos[i]= new IncludeInformation();	504	info.fStatement= include;
477	info.fStatement= include;	505	if (include.isResolved()) {
478	if (include.isResolved()) {	506	info.fLocation= fResolver.resolveASTPath(include.getPath());
479	info.fLocation= fResolver.resolveASTPath(include.getPath());	507	info.fIsContext= include.isActive() &&
480	info.fIsContext= include.isActive() &&	508	(contextIncludes.contains(include) \|\| clearedContexts.contains(info.fLocation));
481	(contextIncludes.contains(include) \|\| clearedContexts.contains(info.fLocation));	509	}
482	}	510	}
		511	index.setFileContent(file, linkageID, includeInfos, macros, names, fResolver,
		512	SEMI_TRANSACTIONAL_UPDATES && ALLOW_LOCK_YIELDING ? lock : null);
		513	}
		514	if (SEMI_TRANSACTIONAL_UPDATES) {
		515	file.setTimestamp(timestamp);
		516	file = index.commitUncommittedFile();
483	}	517	}
484	index.setFileContent(file, linkageID, includeInfos, macros, names, fResolver);	518	} finally {
		519	index.clearUncommittedFile();
485	}	520	}
486	return file;	521	return file;
487	}	522	}




 * 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.PDOMMacro;
import org.eclipse.cdt.internal.core.pdom.dom.PDOMMacroReferenceName;
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 {


	@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 clearUncommittedFile() throws CoreException {
		if (uncommittedFile != null) {
			try {
				uncommittedFile.clear(null);
				uncommittedFile.delete();
			} finally {
				uncommittedFile = null;
				uncommittedLocation = null;
				fileBeingUpdated = null;
			}
		}
	}

	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)


	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;
	}

	@Override
	protected boolean isCommitted(PDOMName name) throws CoreException {
		return uncommittedFile == null || !uncommittedFile.getPDOM().equals(name.getPDOM()) ||
				uncommittedFile.getRecord() != name.getFileRecord();
	}

	@Override
	protected boolean isCommitted(PDOMMacro name) throws CoreException {
		return uncommittedFile == null || !uncommittedFile.getPDOM().equals(name.getPDOM()) ||
				uncommittedFile.getRecord() != name.getFileRecord();
	}

	@Override
	protected boolean isCommitted(PDOMMacroReferenceName name) throws CoreException {
		return uncommittedFile == null || !uncommittedFile.getPDOM().equals(name.getPDOM()) ||
				uncommittedFile.getRecord() != name.getFileRecord();
	}

	/* (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)


	@Override
	public final int hashCode() {
		return System.identityHashCode(fLinkage.getPDOM()) + (int) (41 * record);
	}
	
	/**
	 * 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 (this.equals(includedBy)) {
				include.delete();
			}
			include = nextInclude;
		}
		include = sourceFile.getFirstInclude();
		setFirstInclude(include);
		while (include != null) {
			IIndexFile includedBy = include.getIncludedBy();
			if (sourceFile.equals(includedBy)) {
				include.setIncludedBy(this);
				if (sourceFile.equals(include.getIncludes())) {
					include.setIncludes(this);
				}
			}
			include = include.getNextInIncludes();
		}

		// 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();

		PDOMMacroReferenceName lastMacroName= null;
		for (IASTName[] name : names) {
			if (name[0] != null) {
				if (lock != null) {
					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);
	}

	/**
	 * Deletes this file from PDOM. Only uncommitted files can be safely deleted.
	 *
	 * @throws CoreException
	 */
	public 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	}




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


	public PDOM getPDOM() {
		return fLinkage.getPDOM();
	}

	public long getRecord() {
		return fRecord;
	}

		return filerec != 0 ? new PDOMFile(fLinkage, filerec) : null;
	}

	public long getFileRecord() throws CoreException {
		return fLinkage.getDB().getRecPtr(fRecord + FILE);
	}

	void setFile(PDOMFile file) throws CoreException {
		fLinkage.getDB().putRecPtr(fRecord + FILE, file != null ? file.getRecord() : 0);
	}

	public int getEndingLineNumber() {
		return 0;
	}

Lines 8-13 Link Here

(-)parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMMacroReferenceName.java (-1 / +15 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 21-26 Link Here
21	import org.eclipse.cdt.internal.core.index.IIndexFragment;	22	import org.eclipse.cdt.internal.core.index.IIndexFragment;
22	import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding;	23	import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding;
23	import org.eclipse.cdt.internal.core.index.IIndexFragmentName;	24	import org.eclipse.cdt.internal.core.index.IIndexFragmentName;
		25	import org.eclipse.cdt.internal.core.pdom.PDOM;
24	import org.eclipse.cdt.internal.core.pdom.db.Database;	26	import org.eclipse.cdt.internal.core.pdom.db.Database;
25	import org.eclipse.core.runtime.CoreException;	27	import org.eclipse.core.runtime.CoreException;
26	import org.eclipse.core.runtime.IPath;	28	import org.eclipse.core.runtime.IPath;
Lines 67-72 Link Here
67	return record;	69	return record;
68	}	70	}
69		71
		72	public PDOM getPDOM() {
		73	return linkage.getPDOM();
		74	}
		75
70	private long getRecField(int offset) throws CoreException {	76	private long getRecField(int offset) throws CoreException {
71	return linkage.getDB().getRecPtr(record + offset);	77	return linkage.getDB().getRecPtr(record + offset);
72	}	78	}
Lines 110-116 Link Here
110	long filerec = linkage.getDB().getRecPtr(record + FILE_REC_OFFSET);	116	long filerec = linkage.getDB().getRecPtr(record + FILE_REC_OFFSET);
111	return filerec != 0 ? new PDOMFile(linkage, filerec) : null;	117	return filerec != 0 ? new PDOMFile(linkage, filerec) : null;
112	}	118	}
113		119
		120	public long getFileRecord() throws CoreException {
		121	return linkage.getDB().getRecPtr(record + FILE_REC_OFFSET);
		122	}
		123
		124	void setFile(PDOMFile file) throws CoreException {
		125	linkage.getDB().putRecPtr(record + FILE_REC_OFFSET, file != null ? file.getRecord() : 0);
		126	}
		127
114	PDOMMacroReferenceName getNextInFile() throws CoreException {	128	PDOMMacroReferenceName getNextInFile() throws CoreException {
115	return getNameField(FILE_NEXT_OFFSET);	129	return getNameField(FILE_NEXT_OFFSET);
116	}	130	}

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 (-14 / +52 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 96-101 Link Here
96	public class PDOM extends PlatformObject implements IPDOM {	97	public class PDOM extends PlatformObject implements IPDOM {
97	private static final int BLOCKED_WRITE_LOCK_OUTPUT_INTERVAL = 30000;	98	private static final int BLOCKED_WRITE_LOCK_OUTPUT_INTERVAL = 30000;
98	private static final int LONG_WRITE_LOCK_REPORT_THRESHOLD = 1000;	99	private static final int LONG_WRITE_LOCK_REPORT_THRESHOLD = 1000;
		100	private static final int LONG_READ_LOCK_WAIT_REPORT_THRESHOLD = 1000;
99	static boolean sDEBUG_LOCKS= false; // initialized in the PDOMManager, because IBM needs PDOM independent of runtime plugin.	101	static boolean sDEBUG_LOCKS= false; // initialized in the PDOMManager, because IBM needs PDOM independent of runtime plugin.
100		102
101	/**	103	/**
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 766-771 Link Here
766	private long timeWriteLockAcquired;	768	private long timeWriteLockAcquired;
767		769
768	public void acquireReadLock() throws InterruptedException {	770	public void acquireReadLock() throws InterruptedException {
		771	long t = sDEBUG_LOCKS ? System.nanoTime() : 0;
769	synchronized (mutex) {	772	synchronized (mutex) {
770	++waitingReaders;	773	++waitingReaders;
771	try {	774	try {
Lines 776-789 Link Here
776	}	779	}
777	++lockCount;	780	++lockCount;
778	db.setLocked(true);	781	db.setLocked(true);
779		782
780	if (sDEBUG_LOCKS) {	783	if (sDEBUG_LOCKS) {
		784	t = (System.nanoTime() - t) / 1000000;
		785	if (t >= LONG_READ_LOCK_WAIT_REPORT_THRESHOLD) {
		786	System.out.println("Acquired index read lock after " + t + " ms wait."); //$NON-NLS-1$//$NON-NLS-2$
		787	}
781	incReadLock(fLockDebugging);	788	incReadLock(fLockDebugging);
782	}	789	}
783	}	790	}
784	}	791	}
785		792
786
787	public void releaseReadLock() {	793	public void releaseReadLock() {
788	boolean clearCache= false;	794	boolean clearCache= false;
789	synchronized (mutex) {	795	synchronized (mutex) {
Lines 884-889 Link Here
884	fireChange(event);	890	fireChange(event);
885	}	891	}
886		892
		893	public boolean hasWaitingReaders() {
		894	synchronized (mutex) {
		895	return waitingReaders > 0;
		896	}
		897	}
		898
887	public long getLastWriteAccess() {	899	public long getLastWriteAccess() {
888	return lastWriteAccess;	900	return lastWriteAccess;
889	}	901	}
Lines 957-973 Link Here
957	PDOMName name;	969	PDOMName name;
958	if ((options & FIND_DECLARATIONS) != 0) {	970	if ((options & FIND_DECLARATIONS) != 0) {
959	for (name= pdomBinding.getFirstDeclaration(); name != null; name= name.getNextInBinding()) {	971	for (name= pdomBinding.getFirstDeclaration(); name != null; name= name.getNextInBinding()) {
960	names.add(name);	972	if (isCommitted(name)) {
		973	names.add(name);
		974	}
961	}	975	}
962	}	976	}
963	if ((options & FIND_DEFINITIONS) != 0) {	977	if ((options & FIND_DEFINITIONS) != 0) {
964	for (name = pdomBinding.getFirstDefinition(); name != null; name= name.getNextInBinding()) {	978	for (name = pdomBinding.getFirstDefinition(); name != null; name= name.getNextInBinding()) {
965	names.add(name);	979	if (isCommitted(name)) {
		980	names.add(name);
		981	}
966	}	982	}
967	}	983	}
968	if ((options & FIND_REFERENCES) != 0) {	984	if ((options & FIND_REFERENCES) != 0) {
969	for (name = pdomBinding.getFirstReference(); name != null; name= name.getNextInBinding()) {	985	for (name = pdomBinding.getFirstReference(); name != null; name= name.getNextInBinding()) {
970	names.add(name);	986	if (isCommitted(name)) {
		987	names.add(name);
		988	}
971	}	989	}
972	}	990	}
973	}	991	}
Lines 977-1000 Link Here
977	if ((options & FIND_DEFINITIONS) != 0) {	995	if ((options & FIND_DEFINITIONS) != 0) {
978	for (PDOMMacro macro= container.getFirstDefinition(); macro != null; macro= macro.getNextInContainer()) {	996	for (PDOMMacro macro= container.getFirstDefinition(); macro != null; macro= macro.getNextInContainer()) {
979	final IIndexFragmentName name = macro.getDefinition();	997	final IIndexFragmentName name = macro.getDefinition();
980	if (name != null) {	998	if (name != null && isCommitted(macro)) {
981	names.add(name);	999	names.add(name);
982	}	1000	}
983	}	1001	}
984	}	1002	}
985	if ((options & FIND_REFERENCES) != 0) {	1003	if ((options & FIND_REFERENCES) != 0) {
986	for (PDOMMacroReferenceName name = container.getFirstReference(); name != null; name= name.getNextInContainer()) {	1004	for (PDOMMacroReferenceName name = container.getFirstReference(); name != null; name= name.getNextInContainer()) {
987	names.add(name);	1005	if (isCommitted(name)) {
		1006	names.add(name);
		1007	}
988	}	1008	}
989	}	1009	}
990	}	1010	}
991		1011
		1012	protected boolean isCommitted(PDOMName name) throws CoreException {
		1013	return true;
		1014	}
		1015
		1016	protected boolean isCommitted(PDOMMacro name) throws CoreException {
		1017	return true;
		1018	}
		1019
		1020	protected boolean isCommitted(PDOMMacroReferenceName name) throws CoreException {
		1021	return true;
		1022	}
		1023
992	public IIndexFragmentInclude[] findIncludedBy(IIndexFragmentFile file) throws CoreException {	1024	public IIndexFragmentInclude[] findIncludedBy(IIndexFragmentFile file) throws CoreException {
993	PDOMFile pdomFile= adaptFile(file);	1025	PDOMFile pdomFile= adaptFile(file);
994	if (pdomFile != null) {	1026	if (pdomFile != null) {
995	List<PDOMInclude> result = new ArrayList<PDOMInclude>();	1027	List<PDOMInclude> result = new ArrayList<PDOMInclude>();
996	for (PDOMInclude i= pdomFile.getFirstIncludedBy(); i != null; i= i.getNextInIncludedBy()) {	1028	for (PDOMInclude i= pdomFile.getFirstIncludedBy(); i != null; i= i.getNextInIncludedBy()) {
997	result.add(i);	1029	if (i.getIncludedBy().getTimestamp() > 0) {
		1030	result.add(i);
		1031	}
998	}	1032	}
999	return result.toArray(new PDOMInclude[result.size()]);	1033	return result.toArray(new PDOMInclude[result.size()]);
1000	}	1034	}
Lines 1197-1202 Link Here
1197	public String createKeyForCache(long record, char[] name) {	1231	public String createKeyForCache(long record, char[] name) {
1198	return new StringBuilder(name.length + 2).append((char) (record >> 16)).append((char) record).append(name).toString();	1232	return new StringBuilder(name.length + 2).append((char) (record >> 16)).append((char) record).append(name).toString();
1199	}	1233	}
		1234
		1235	public boolean hasLastingDefinition(PDOMBinding binding) throws CoreException {
		1236	return binding.hasDefinition();
		1237	}
1200		1238
1201	private PDOMBinding[] getCrossLanguageBindings(IBinding binding) throws CoreException {	1239	private PDOMBinding[] getCrossLanguageBindings(IBinding binding) throws CoreException {
1202	switch(binding.getLinkage().getLinkageID()) {	1240	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	}