From 6a803d0d952f2b49cc57cc2cbe05f0987ed13761 Mon Sep 17 00:00:00 2001 From: Oleg Krasilnikov Date: Fri, 10 Mar 2006 13:19:22 +0000 Subject: [PATCH] Bug #69078: C/C++ indexer too slow. Tests for performance measurement. Indexer code changes were applied before. --- .../tests/DOMSourceIndexerPerfTests.java | 244 ++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/DOMSourceIndexerPerfTests.java diff --git a/core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/DOMSourceIndexerPerfTests.java b/core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/DOMSourceIndexerPerfTests.java new file mode 100644 index 00000000000..6a5e8cd8f2d --- /dev/null +++ b/core/org.eclipse.cdt.core.tests/indexer/org/eclipse/cdt/core/indexer/tests/DOMSourceIndexerPerfTests.java @@ -0,0 +1,244 @@ +/********************************************************************** + * Copyright (c) 2002, 2005 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +/* + * Created on Jun 19, 2003 + */ +package org.eclipse.cdt.core.indexer.tests; + +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +import org.eclipse.cdt.core.CCorePlugin; +import org.eclipse.cdt.core.ICDescriptor; +import org.eclipse.cdt.core.ICDescriptorOperation; +import org.eclipse.cdt.core.index.IIndexChangeListener; +import org.eclipse.cdt.core.index.IIndexDelta; +import org.eclipse.cdt.core.index.IndexChangeEvent; +import org.eclipse.cdt.core.testplugin.CProjectHelper; +import org.eclipse.cdt.core.testplugin.CTestPlugin; +import org.eclipse.cdt.internal.core.index.domsourceindexer.DOMSourceIndexer; +import org.eclipse.cdt.internal.core.search.indexing.IndexManager; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.core.runtime.Path; + +/** + * @author bgheorgh + */ +public class DOMSourceIndexerPerfTests extends TestCase { + IProject testProject; + DOMSourceIndexer sourceIndexer; + IndexManager indexManager; + static long timeC = 0; + static long timeCPP = 0; + static int countC = 0; + static int countCPP = 0; + static final int MAXCOUNT = 10; + + /** + * @param name + */ + public DOMSourceIndexerPerfTests(String name) { + super(name); + } + + public void resetIndexer(final String indexerId){ + if ( testProject != null) { + ICDescriptorOperation op = new ICDescriptorOperation() { + + public void execute(ICDescriptor descriptor, IProgressMonitor monitor) throws CoreException { + descriptor.remove(CCorePlugin.INDEXER_UNIQ_ID); + descriptor.create(CCorePlugin.INDEXER_UNIQ_ID,indexerId); + } + }; + try { + CCorePlugin.getDefault().getCDescriptorManager().runDescriptorOperation(testProject, op, new NullProgressMonitor()); + CCorePlugin.getDefault().getCoreModel().getIndexManager().indexerChangeNotification(testProject); + } catch (CoreException e) {} + } + } + + public static void main(String[] args) {} + + /* + * @see TestCase#setUp() + */ + protected void setUp() throws Exception { + super.setUp(); + testProject = CProjectHelper.createCCProject("IndexerTestProject", "bin").getProject(); //$NON-NLS-1$ + assertNotNull("Unable to create project", testProject); //$NON-NLS-1$ + + resetIndexer(CCorePlugin.DEFAULT_INDEXER_UNIQ_ID); + indexManager = CCorePlugin.getDefault().getCoreModel().getIndexManager(); + sourceIndexer = (DOMSourceIndexer) indexManager.getIndexerForProject(testProject); + } + /* + * @see TestCase#tearDown() + */ + protected void tearDown() { + try { + super.tearDown(); + } catch (Exception e1) {} + //Delete project + if (testProject.exists()) { + try { + System.gc(); + System.runFinalization(); + testProject.delete(true, null); + } catch (CoreException e) { + fail(getMessage(e.getStatus())); + } + } + } + + /** + * Makes error message from multistatus + * + * @param status + * @return + */ + private String getMessage(IStatus status) { + StringBuffer message = new StringBuffer("["); //$NON-NLS-1$ + message.append(status.getMessage()); + if (status.isMultiStatus()) { + IStatus children[] = status.getChildren(); + for (int i = 0; i < children.length; i++) { + message.append(getMessage(children[i])); + } + } + message.append("]"); //$NON-NLS-1$ + return message.toString(); + } + + public static Test suite() { + timeC = 0; + timeCPP = 0; + countC = 0; + countCPP = 0; + TestSuite suite = new TestSuite(DOMSourceIndexerPerfTests.class.getName()); + Test t1 = new DOMSourceIndexerPerfTests("testC"); //$NON-NLS-1$ + Test t2 = new DOMSourceIndexerPerfTests("testCPP"); //$NON-NLS-1$ + + for (int i = 0; i < MAXCOUNT; i++) { + suite.addTest(t1); + suite.addTest(t2); + } + return suite; + + } + /** + * Unpack archive contents to project directory + * + * @param name - name of archive file w/o extension + * @param mask - pattern to check file extensions + * @return - list of files which fit to pattern + */ + + private ArrayList unzip(String name, String mask) { + ArrayList lst = new ArrayList(20); + + byte[] buffer = new byte[512]; + String archname = "resources/zips/" + name + ".zip"; + ZipFile zipFile = null; + + try { + zipFile = new ZipFile(CTestPlugin.getDefault().getFileInPlugin(new Path(archname))); + IPath projPath = testProject.getLocation(); + Enumeration entries = zipFile.entries(); + + while (entries.hasMoreElements()) { + ZipEntry entry = (ZipEntry)entries.nextElement(); + if (!entry.isDirectory()) { + IPath entryPath = projPath.append(entry.getName()); + InputStream in = zipFile.getInputStream(entry); + OutputStream out = new FileOutputStream(entryPath.toFile()); + for (int n = in.read(buffer); n >= 0; n = in.read(buffer)) + out.write(buffer, 0, n); + in.close(); + out.close(); + if (entryPath.lastSegment().endsWith(mask)) { + lst.add(entryPath.lastSegment()); + } + } + } + zipFile.close(); + } catch (IOException e) { + fail("Unzip error with " + archname + " : " + e.getLocalizedMessage()); + } + return lst; + } + + /** + * Adds files from list to index and counts indexing time + * + * @param lst - list of file names to be added + * @return - time (in ms) spent for indexing + */ + private long indexFiles(ArrayList lst) { + // wait for finish of other indexing processes, if any + while(indexManager.awaitingJobsCount()>0) { + try { Thread.sleep(20); + } catch (InterruptedException e) {} + } + System.gc(); + long t0 = System.currentTimeMillis(); + for (int i=0; i0) { + try { Thread.sleep(20); + } catch (InterruptedException e) {} + } + return (System.currentTimeMillis() - t0); + } + + /** + * Test C source indexation + * @throws Exception + */ + public void testC() throws Exception { + long t0 = indexFiles(unzip("perf1", ".c")); + timeC += t0; countC++; + System.out.println("Index performance: " + t0 + " ms on C source[" + countC + "]"); + if (countC == MAXCOUNT) { + System.out.println("Average performance on " + MAXCOUNT + " C passes: " + (timeC/MAXCOUNT)); + } + } + + /** + * Test C++ source indexation + * @throws Exception + */ + public void testCPP() throws Exception { + long t0 = indexFiles(unzip("perf2", ".cpp")); + timeCPP += t0; countCPP++; + System.out.println("Index performance: " + t0 + " ms on C++ source[" + countCPP + "]"); + if (countCPP == MAXCOUNT) { + System.out.println("Average performance on " + MAXCOUNT + " C++ passes: " + (timeCPP/MAXCOUNT)); + } + } +}