Attachment #114571 for bug #206859

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 206859
Collapse All | Expand All




                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.sampler</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.spi.quicksearch</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                        <code-name-base>org.netbeans.libs.junit4</code-name-base>
                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.netbeans.modules.nbjunit</code-name-base>
                        <recursive/>
                        <compile-dependency/>
                    </test-dependency>
                </test-type>
            </test-dependencies>
            <public-packages/>

Lines 46-50 Link Here

(-)a/core.ui/src/org/netbeans/core/ui/sampler/Bundle.properties (-2 lines)
46	SelfSamplerAction_ActionNameStop=Stop Application Profiling and Take a Snapshot	46	SelfSamplerAction_ActionNameStop=Stop Application Profiling and Take a Snapshot
47	SelfSamplerAction_ActionDescription=Will take a snapshot based on the thread dump	47	SelfSamplerAction_ActionDescription=Will take a snapshot based on the thread dump
48	SelfSamplerAction_NotSupported=Self Sampler is not available.	48	SelfSamplerAction_NotSupported=Self Sampler is not available.
49	SelfSamplerAction_SavedFile=Snapshot was saved to {0}
50	Save_Progress=Saving snapshot




package org.netbeans.core.ui.sampler;

import java.awt.AWTEvent;
import java.awt.EventQueue;
import java.awt.Toolkit;
import java.awt.event.AWTEventListener;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.lang.management.ThreadMXBean;
import java.text.MessageFormat;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.SwingWorker;
import org.netbeans.modules.sampler.Sampler;
import org.netbeans.api.progress.ProgressHandleFactory;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.awt.ActionID;
import org.openide.awt.ActionReference;
import org.openide.awt.ActionReferences;
import org.openide.awt.ActionRegistration;
import org.openide.cookies.OpenCookie;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;

/**

    private static final String ACTION_NAME_STOP = NbBundle.getMessage(SelfSamplerAction.class, "SelfSamplerAction_ActionNameStop");
//    private static final String ACTION_DESCR = NbBundle.getMessage(SelfSamplerAction.class, "SelfSamplerAction_ActionDescription");
    private static final String NOT_SUPPORTED = NbBundle.getMessage(SelfSamplerAction.class, "SelfSamplerAction_NotSupported");
    private static final String SAVE_MSG = NbBundle.getMessage(SelfSamplerAction.class, "SelfSamplerAction_SavedFile");
    private static final String DEBUG_ARG = "-Xdebug"; // NOI18N
    private static final Logger LOGGER = Logger.getLogger(SelfSamplerAction.class.getName());
    private final AtomicReference<Sampler> RUNNING = new AtomicReference<Sampler>();
    private static Boolean debugMode;
    private static String lastReason;
    private static Class defaultDataObject;
    static {
        try {
            defaultDataObject = Class.forName("org.openide.loaders.DefaultDataObject"); // NOI18N
        } catch (ClassNotFoundException ex) {
            Exceptions.printStackTrace(ex);
        }
    }

    //~ Constructors -------------------------------------------------------------------------------------------------------------
    public SelfSamplerAction() {

     */
    @Override
    public void actionPerformed(final ActionEvent e) {
        Sampler c = Sampler.getGenericSampler("Self Sampler");  // NOI18N
        if (c != null) {
            if (RUNNING.compareAndSet(null, c)) {
                putValue(Action.NAME, ACTION_NAME_STOP);
                putValue(Action.SHORT_DESCRIPTION, ACTION_NAME_STOP);
                putValue ("iconBase", "org/netbeans/core/ui/sampler/selfSamplerRunning.png"); // NOI18N
                c.start();
            } else if ((c = RUNNING.getAndSet(null)) != null) {
                final Sampler controller = c;



                    @Override
                    protected Object doInBackground() throws Exception {
                        controller.stop();
                        return null;
                    }


            }
        } else {
            NotifyDescriptor d = new NotifyDescriptor.Message(NOT_SUPPORTED, NotifyDescriptor.INFORMATION_MESSAGE);
            DialogDisplayer.getDefault().notify(d);
        }
    }


        }
    }

    @Override
    public Object getValue(String key) {
        Object o = super.getValue(key);
        if (o == null && key.startsWith("logger-") && SamplesOutputStream.isSupported() && isRunMode()) { // NOI18N
            return new InternalSampler(key);
        }
        return o;
    }

    final boolean isProfileMe(Sampler c) {
        return c == RUNNING.get();
    }
    
    private static synchronized boolean isDebugged() {
        if (debugMode == null) {
            debugMode = Boolean.FALSE;

            // check if we are debugged
            RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
            List<String> args = runtime.getInputArguments();
            if (args.contains(DEBUG_ARG)) {
                debugMode = Boolean.TRUE;
            }
        }
        return debugMode.booleanValue();
    }

    private static boolean isRunMode() {
        boolean runMode = true;
        String reason = null;

        if (isDebugged()) {
            reason = "running in debug mode";   // NOI18N
            runMode = false;
        }
        if (runMode) {
            // check if netbeans is profiled
            try {
                Class.forName("org.netbeans.lib.profiler.server.ProfilerServer", false, ClassLoader.getSystemClassLoader()); // NO18N
                reason = "running under profiler";   // NOI18N
                runMode = false;
            } catch (ClassNotFoundException ex) {
            }
        }
        if (!runMode && !reason.equals(lastReason)) {
            LOGGER.log(Level.INFO, "Slowness detector disabled - {0}", reason); // NOI18N
        }
        lastReason = reason;
        return runMode;
    }
    
    private static final class InternalSampler extends Sampler {
        private ProgressHandle progress;
        
        InternalSampler(String thread) {
            super(thread);
        }

        @Override
        protected void printStackTrace(Throwable ex) {
            Exceptions.printStackTrace(ex);
        }

        @Override
        protected void saveSnapshot(byte[] arr) throws IOException {
            // save snapshot
            File outFile = File.createTempFile("selfsampler", SamplesOutputStream.FILE_EXT); // NOI18N
            outFile = FileUtil.normalizeFile(outFile);
            writeToFile(outFile, arr);
            
            File gestures = new File(new File(new File(
                new File(System.getProperty("netbeans.user")), // NOI18N
                "var"), "log"), "uigestures"); // NOI18N
            
            SelfSampleVFS fs;
            if (gestures.exists()) {
                fs = new SelfSampleVFS(
                    new String[] { "selfsampler.npss", "selfsampler.log" }, 
                    new File[] { outFile, gestures }
                );
            } else {
                fs = new SelfSampleVFS(
                    new String[] { "selfsampler.npss" }, 
                    new File[] { outFile }
                );
            }
            
            // open snapshot
            FileObject fo = fs.findResource("selfsampler.npss");
            DataObject dobj = DataObject.find(fo);
            // ugly test for DefaultDataObject
            if (defaultDataObject.isAssignableFrom(dobj.getClass())) {
                String msg = MessageFormat.format(SelfSamplerAction.SAVE_MSG, outFile.getAbsolutePath());
                DialogDisplayer.getDefault().notify(new NotifyDescriptor.Message(msg));
            } else {
                dobj.getCookie(OpenCookie.class).open();
            }
        }

        private void writeToFile(File file, byte[] arr) {
            try {
                FileOutputStream fstream = new FileOutputStream(file);
                fstream.write(arr);
                fstream.close();
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
        }

        @Override
        protected ThreadMXBean getThreadMXBean() {
            return ManagementFactory.getThreadMXBean();
        }
        
        protected void openProgress(final int steps) {
            if (EventQueue.isDispatchThread()) {
                // log warnining
                return;
            }
            progress = ProgressHandleFactory.createHandle(NbBundle.getMessage(SelfSamplerAction.class, "Save_Progress"));
            progress.start(steps);
        }
        
        protected void closeProgress() {
            if (EventQueue.isDispatchThread()) {
                return;
            }
            progress.finish();
            progress = null;
        }
        
        protected void progress(int i) {
            if (EventQueue.isDispatchThread()) {
                return;
            }
            if (progress != null) {
                progress.progress(i);
            }
        }
    }
}

Lines 104-109 Link Here

(-)a/editor.completion/nbproject/project.xml (+8 lines)
104	</run-dependency>	104	</run-dependency>
105	</dependency>	105	</dependency>
106	<dependency>	106	<dependency>
		107	<code-name-base>org.netbeans.modules.sampler</code-name-base>
		108	<build-prerequisite/>
		109	<compile-dependency/>
		110	<run-dependency>
		111	<specification-version>1.0</specification-version>
		112	</run-dependency>
		113	</dependency>
		114	<dependency>
107	<code-name-base>org.openide.awt</code-name-base>	115	<code-name-base>org.openide.awt</code-name-base>
108	<build-prerequisite/>	116	<build-prerequisite/>
109	<compile-dependency/>	117	<compile-dependency/>




 */
package org.netbeans.modules.editor.completion;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.modules.sampler.Sampler;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;
import org.openide.util.RequestProcessor;


    private static final Logger LOG = Logger.getLogger(CompletionImplProfile.class.getName());
    static final RequestProcessor RP = new RequestProcessor("Completion Slowness"); // NOI18N

    private final Sampler profiler;
    private boolean profiling;
    private final long time;

    CompletionImplProfile(long when) {
        time = when;

        this.profiler = Sampler.getSampler("logger-completion");  // NOI18N
        FileObject fo = FileUtil.getConfigFile("Actions/Profile/org-netbeans-modules-profiler-actions-SelfSamplerAction.instance"); // NOI18N
        if (fo != null) {
            Action a = (Action) fo.getAttribute("delegate"); // NOI18N
            if (a != null) {
                p = a.getValue("logger-completion"); // NOI18N
            }
        }
        this.profiler = p;
        this.profiling = true;
        
        if (profiler != null) {
            profiler.start();
            r.run();
            LOG.log(Level.FINE, "Profiling started {0} at {1}", new Object[] { profiler, time });
        }
    }

    private void stopImpl(long now) throws Exception {
        long delta = now - time;
        LOG.log(Level.FINE, "Profiling stopped at {0}", now);
        ActionListener ss = (ActionListener) profiler;
        int report = Integer.getInteger("org.netbeans.modules.editor.completion.slowness.report", 2000); // NOI18N
        if (delta < report) {
            LOG.log(Level.FINE, "Cancel profiling of {0}. Profiling {1}. Time {2} ms.", new Object[] { profiler, profiling, delta });
            if (profiler != null) {
                profiler.cancel();
            }
            return;
        }

            LOG.log(Level.FINE, "Obtaining snapshot for {0} ms.", delta);
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            DataOutputStream dos = new DataOutputStream(out);
            if (profiler != null) {
                profiler.stopAndWriteTo(dos);
            }
            dos.close();
            if (dos.size() > 0) {




                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.netbeans.core.ui</code-name-base>
                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.netbeans.libs.junit4</code-name-base>
                        <compile-dependency/>
                    </test-dependency>

                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.netbeans.modules.sampler</code-name-base>
                        <compile-dependency/>
                        <test/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.openide.modules</code-name-base>
                        <compile-dependency/>
                    </test-dependency>




import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import org.netbeans.modules.sampler.CustomSamplesStream;
import org.openide.util.Exceptions;

/**

    private String newWhitelistFileName;
    private String previousWhitelistFileName = null;
    private File whitelistStorageDir = null;
    private CustomSamplesStream samples;
    private ByteArrayOutputStream stream;
    private ThreadMXBean threadBean;
    private long start;

        start = System.currentTimeMillis();
        stream = new ByteArrayOutputStream();
        try {
            samples = new CustomSamplesStream(stream, 5000);
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }

Lines 104-109 Link Here

(-)a/jumpto/nbproject/project.xml (+8 lines)
104	</run-dependency>	104	</run-dependency>
105	</dependency>	105	</dependency>
106	<dependency>	106	<dependency>
		107	<code-name-base>org.netbeans.modules.sampler</code-name-base>
		108	<build-prerequisite/>
		109	<compile-dependency/>
		110	<run-dependency>
		111	<specification-version>1.0</specification-version>
		112	</run-dependency>
		113	</dependency>
		114	<dependency>
107	<code-name-base>org.netbeans.spi.quicksearch</code-name-base>	115	<code-name-base>org.netbeans.spi.quicksearch</code-name-base>
108	<build-prerequisite/>	116	<build-prerequisite/>
109	<compile-dependency/>	117	<compile-dependency/>




import java.util.logging.Logger;
import java.util.regex.Pattern;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.ListCellRenderer;

import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.modules.jumpto.EntitiesListCellRenderer;
import org.netbeans.modules.jumpto.file.LazyListModel;
import org.netbeans.modules.sampler.Sampler;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;
import org.openide.ErrorManager;

            return null;
        }

        Sampler profiler = Sampler.getSampler("logger-jumpto"); //NOI18N
        if (fo == null) {
            return null;
        }
        Action a = (Action)fo.getAttribute("delegate"); // NOI18N
        if (a == null) {
            return null;
        }
        Object profiler = a.getValue("logger-jumpto"); //NOI18N
        if (profiler == null) {
            return null;
        }


    private class Profile implements Runnable {
        private final long time;
        private volatile  Sampler profiler;
        private volatile boolean profiling;

        public Profile(Sampler profiler) {
            time = System.currentTimeMillis();
            this.profiler = profiler;
        }

        @Override
        public synchronized void run() {
            profiling = true;
            profiler.start();
                Runnable r = (Runnable)profiler;
                r.run();
            }
        }

        private synchronized void stop() throws Exception {
            long delta = System.currentTimeMillis() - time;

            Sampler ss = profiler;
            profiler = null;
            if (!profiling) {
                return;

            try {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                DataOutputStream dos = new DataOutputStream(out);
                ss.stopAndWriteTo(dos);
                dos.close();
                if (dos.size() > 0) {
                    Object[] params = new Object[]{out.toByteArray(), delta, "GoToType" };      //NOI18N

Lines 209-214 Link Here

(-)a/nbbuild/cluster.properties (+1 lines)
209	print,\	209	print,\
210	progress.ui,\	210	progress.ui,\
211	queries,\	211	queries,\
		212	sampler,\
212	sendopts,\	213	sendopts,\
213	settings,\	214	settings,\
214	spi.actions,\	215	spi.actions,\

Lines 76-81 Link Here

(-)a/o.n.core/nbproject/project.xml (+8 lines)
76	</run-dependency>	76	</run-dependency>
77	</dependency>	77	</dependency>
78	<dependency>	78	<dependency>
		79	<code-name-base>org.netbeans.modules.sampler</code-name-base>
		80	<build-prerequisite/>
		81	<compile-dependency/>
		82	<run-dependency>
		83	<specification-version>1.0</specification-version>
		84	</run-dependency>
		85	</dependency>
		86	<dependency>
79	<code-name-base>org.netbeans.swing.plaf</code-name-base>	87	<code-name-base>org.netbeans.swing.plaf</code-name-base>
80	<build-prerequisite/>	88	<build-prerequisite/>
81	<compile-dependency/>	89	<compile-dependency/>




import java.awt.KeyboardFocusManager;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Action;
import javax.swing.JFrame;
import javax.swing.JRootPane;
import javax.swing.SwingUtilities;
import org.netbeans.modules.sampler.Sampler;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.Mutex;

    private final RequestProcessor.Task WAIT_CURSOR_CHECKER;
    private volatile long ignoreTill;
    private volatile long start;
    private volatile Sampler stoppable;
    private volatile boolean isWaitCursor;
    static volatile Thread eq;
    private final Frame mainWindow;

        } else {
            LOG.log(Level.FINEST, "done, timer stopped, took {0}", time);
        }
        Sampler ss = stoppable;
        if (ss != null) {
            ss.cancel();
            stoppable = null;
        }
        return;

            LOG.log(Level.WARNING, "Still previous controller {0}", stoppable);
            return;
        }
        Sampler selfSampler = createSelfSampler();
        if (selfSampler != null) {
            selfSampler.start();
            stoppable = selfSampler;
        }
        isWaitCursor |= isWaitCursor();
        if (!isWaitCursor) {

        }
    }

    private static void report(final Sampler ss, final long time) {
        if (ss == null) {
            return;
        }

                try {
                    ByteArrayOutputStream out = new ByteArrayOutputStream();
                    DataOutputStream dos = new DataOutputStream(out);
                    ss.stopAndWriteTo(dos);
                    dos.close();
                    if (dos.size() > 0) {
                        Object[] params = new Object[]{out.toByteArray(), time};

        RP.post(new R());
    }

    private static Sampler createSelfSampler() {
        return Sampler.getSampler("logger-awt"); // NOI18N
        if (fo == null) {
            return null;
        }
        Action a = (Action)fo.getAttribute("delegate"); // NOI18N
        if (a == null) {
            return null;
        }
        return a.getValue("logger-awt"); // NOI18N
    }

    private static boolean isWaitCursor() {

Lines 141-146 Link Here

(-)a/parsing.api/nbproject/project.xml (+8 lines)
141	</run-dependency>	141	</run-dependency>
142	</dependency>	142	</dependency>
143	<dependency>	143	<dependency>
		144	<code-name-base>org.netbeans.modules.sampler</code-name-base>
		145	<build-prerequisite/>
		146	<compile-dependency/>
		147	<run-dependency>
		148	<specification-version>1.0</specification-version>
		149	</run-dependency>
		150	</dependency>
		151	<dependency>
144	<code-name-base>org.netbeans.spi.tasklist</code-name-base>	152	<code-name-base>org.netbeans.spi.tasklist</code-name-base>
145	<build-prerequisite/>	153	<build-prerequisite/>
146	<compile-dependency/>	154	<compile-dependency/>




 */
package org.netbeans.modules.parsing.impl;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.modules.sampler.Sampler;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;

/**

 */
final class SelfProfile {
    private static final Logger LOG = Logger.getLogger(SelfProfile.class.getName());
    
    private final Sampler profiler;
    private final long time;
    private volatile boolean profiling;

    SelfProfile (long when) {
        time = when;
        this.profiler = Sampler.getSampler("logger-taskcancel"); // NOI18N;
        final FileObject fo = FileUtil.getConfigFile("Actions/Profile/org-netbeans-modules-profiler-actions-SelfSamplerAction.instance"); // NOI18N
        if (fo != null) {
            final Action a = (Action) fo.getAttribute("delegate"); // NOI18N
            if (a != null) {
                p = a.getValue("logger-taskcancel"); // NOI18N
            }
        }
        this.profiler = p;
        this.profiling = true;

        if (profiler != null) {
            profiler.start();
            final Runnable r = (Runnable) profiler;
            r.run();
            LOG.log(Level.FINE, "Profiling started {0} at {1}", new Object[] { profiler, time });   //NOI18N
        }
    }

        final long now = System.currentTimeMillis();
        long delta = now - time;
        LOG.log(Level.FINE, "Profiling stopped at {0}", now);
        ActionListener ss = (ActionListener) profiler;
        int report = Integer.getInteger("org.netbeans.modules.parsing.api.taskcancel.slowness.report", 1000); // NOI18N
        if (delta < report) {
            LOG.log(Level.FINE, "Cancel profiling of {0}. Profiling {1}. Time {2} ms.", new Object[] { profiler, profiling, delta });
            if (profiler != null) {
                profiler.cancel();
                LOG.log(Level.FINE, "Cancel profiling of {0}. Profiling {1}. Time {2} ms.", new Object[] { ss, profiling, delta });
            }
            return;
        }
        try {
            LOG.log(Level.FINE, "Obtaining snapshot for {0} ms.", delta);
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            DataOutputStream dos = new DataOutputStream(out);
            if (profiler != null) {
                profiler.stopAndWriteTo(dos);
                ss.actionPerformed(new ActionEvent(dos, 0, "write")); // NOI18N
                LOG.log(Level.FINE, "Obtaining snapshot for {0} ms.", delta);   //NOI18N
            }
            dos.close();
            if (dos.size() > 0) {




<?xml version="1.0" encoding="UTF-8"?>
<!--
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

Oracle and Java are registered trademarks of Oracle and/or its affiliates.
Other names may be trademarks of their respective owners.


The contents of this file are subject to the terms of either the GNU
General Public License Version 2 only ("GPL") or the Common
Development and Distribution License("CDDL") (collectively, the
"License"). You may not use this file except in compliance with the
License. You can obtain a copy of the License at
http://www.netbeans.org/cddl-gplv2.html
or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
specific language governing permissions and limitations under the
License.  When distributing the software, include this License Header
Notice in each file and include the License file at
nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
particular file as subject to the "Classpath" exception as provided
by Oracle in the GPL Version 2 section of the License file that
accompanied this code. If applicable, add the following below the
License Header, with the fields enclosed by brackets [] replaced by
your own identifying information:
"Portions Copyrighted [year] [name of copyright owner]"

Contributor(s):

The Original Software is NetBeans. The Initial Developer of the Original
Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
Microsystems, Inc. All Rights Reserved.

If you wish your version of this file to be governed by only the CDDL
or only the GPL Version 2, indicate your decision by adding
"[Contributor] elects to include this software in this distribution
under the [CDDL or GPL Version 2] license." If you do not indicate a
single choice of license, a recipient has the option to distribute
your version of this file under either the CDDL, the GPL Version 2 or
to extend the choice of license to its licensees as provided above.
However, if you add GPL Version 2 code and therefore, elected the GPL
Version 2 license, then the option applies only if the new code is
made subject to such option by the copyright holder.
-->

<!DOCTYPE apichanges PUBLIC "-//NetBeans//DTD API changes list 1.0//EN" "../nbbuild/javadoctools/apichanges.dtd">

<apichanges>
<apidefs>
    <apidef name="sampler">Sampler API</apidef>
</apidefs>
<changes>
</changes>
<htmlcontents>
<head>
<title>Change History for the Sampler API</title>
<link rel="stylesheet" href="prose.css" type="text/css"/>
</head>
<body>
<p class="overviewlink">
<a href="overview-summary.html">Overview</a>
</p>
<h1>Introduction</h1>
<h2>What do the Dates Mean?</h2>
<p>The supplied dates indicate when the API change was made, on the HG 
default branch. From this you can generally tell whether the change should be
present in a given build or not; for trunk builds, simply whether it
was made before or after the change; for builds on a stabilization
branch, whether the branch was made before or after the given date. In
some cases corresponding API changes have been made both in the trunk
and in an in-progress stabilization branch, if they were needed for a
bug fix; this ought to be marked in this list.</p>
<hr/>
<standard-changelists module-code-name="$codebase"/>
<hr/>
<p>@FOOTER@</p>
</body>
</htmlcontents>
</apichanges>




<?xml version="1.0" encoding="UTF-8"?>
<!--
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

Oracle and Java are registered trademarks of Oracle and/or its affiliates.
Other names may be trademarks of their respective owners.


The contents of this file are subject to the terms of either the GNU
General Public License Version 2 only ("GPL") or the Common
Development and Distribution License("CDDL") (collectively, the
"License"). You may not use this file except in compliance with the
License. You can obtain a copy of the License at
http://www.netbeans.org/cddl-gplv2.html
or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
specific language governing permissions and limitations under the
License.  When distributing the software, include this License Header
Notice in each file and include the License file at
nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
particular file as subject to the "Classpath" exception as provided
by Oracle in the GPL Version 2 section of the License file that
accompanied this code. If applicable, add the following below the
License Header, with the fields enclosed by brackets [] replaced by
your own identifying information:
"Portions Copyrighted [year] [name of copyright owner]"

Contributor(s):

The Original Software is NetBeans. The Initial Developer of the Original
Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
Microsystems, Inc. All Rights Reserved.

If you wish your version of this file to be governed by only the CDDL
or only the GPL Version 2, indicate your decision by adding
"[Contributor] elects to include this software in this distribution
under the [CDDL or GPL Version 2] license." If you do not indicate a
single choice of license, a recipient has the option to distribute
your version of this file under either the CDDL, the GPL Version 2 or
to extend the choice of license to its licensees as provided above.
However, if you add GPL Version 2 code and therefore, elected the GPL
Version 2 license, then the option applies only if the new code is
made subject to such option by the copyright holder.
-->
<!DOCTYPE api-answers PUBLIC "-//NetBeans//DTD Arch Answers//EN" "../nbbuild/antsrc/org/netbeans/nbbuild/Arch.dtd" [
  <!ENTITY api-questions SYSTEM "../nbbuild/antsrc/org/netbeans/nbbuild/Arch-api-questions.xml">
]>

<api-answers
  question-version="1.28"
  module="Sampling API"
  author="thurka@netbeans.org"
>

  &api-questions;


<!--
        <question id="arch-overall" when="init">
            Describe the overall architecture.
            <hint>
            What will be API for 
            <a href="http://openide.netbeans.org/tutorial/api-design.html#design.apiandspi">
                clients and what support API</a>? 
            What parts will be pluggable?
            How will plug-ins be registered? Please use <code>&lt;api type="export"/&gt;</code>
            to describe your general APIs.
            If possible please provide 
            simple diagrams. 
            </hint>
        </question>
-->
 <answer id="arch-overall">
  <p>
   <api name="SamplerAPI" category="official" group="java" type="export" url="@TOP@/org/netbeans/modules/sampler/package-summary.html"/>
   allows anyone to self-sample NetBeans Platform based application. 
  </p>
  
 </answer>



<!--
        <question id="arch-quality" when="init">
            How will the <a href="http://www.netbeans.org/community/guidelines/q-evangelism.html">quality</a>
            of your code be tested and 
            how are future regressions going to be prevented?
            <hint>
            What kind of testing do
            you want to use? How much functionality, in which areas,
            should be covered by the tests? 
            </hint>
        </question>
-->
 <answer id="arch-quality">
  <p>
   There will be tests to verify that the API works
   as advertised.
  </p>
 </answer>



<!--
        <question id="arch-time" when="init">
            What are the time estimates of the work?
            <hint>
            Please express your estimates of how long the design, implementation,
            stabilization are likely to last. How many people will be needed to
            implement this and what is the expected milestone by which the work should be 
            ready?
            </hint>
        </question>
-->
 <answer id="arch-time">
  <p>
   Currently NetBeans has sampling code part of core.ui module. There is
   semi-API used by other modules like core, jumpto, editor.completion, 
   but it would be desirable to have real API in separate module. 
   So let's target this for inclusion in NetBeans 7.2 releases.
  </p>
 </answer>



<!--
        <question id="arch-usecases" when="init">
            <hint>
                Content of this answer will be displayed as part of page at
                http://www.netbeans.org/download/dev/javadoc/usecases.html 
                You can use tags &lt;usecase name="name&gt; regular html description &lt;/usecase&gt;
                and if you want to use an URL you can prefix if with @TOP@ to begin
                at the root of your javadoc
            </hint>
        
            Describe the main <a href="http://openide.netbeans.org/tutorial/api-design.html#usecase">
            use cases</a> of the new API. Who will use it under
            what circumstances? What kind of code would typically need to be written
            to use the module?
        </question>
-->
 <answer id="arch-usecases">
  <p>
   <usecase id="user-sampling" name="User controlled sampling" >
       There needs to be a simple API for someone who wants to create simple user 
       action which starts and stops self-sampling and presents user with sampled
       results.
       <p></p>
       The correct way to achieve this is to call 
        <code><a href="@TOP@/org/netbeans/modules/sampler/Sampler.html">Sampler</a>.getGenericSampler()</code>,
        followed by
        <code><a href="@TOP@/org/netbeans/modules/sampler/Sampler.html">Sampler</a>.start()</code> and
        <code><a href="@TOP@/org/netbeans/modules/sampler/Sampler.html">Sampler</a>.stop()</code>.
        
   </usecase>
   <usecase id="code-sampling" name="Sampling of the slow operation" >
       Second major use-case of the Sampling API is sampling of the slow operation.
       
       <p></p>
       The correct way to achieve this is to call 
        <code><a href="@TOP@/org/netbeans/modules/sampler/Sampler.html">Sampler</a>.getSampler()</code>,
        followed by
        <code><a href="@TOP@/org/netbeans/modules/sampler/Sampler.html">Sampler</a>.start()</code> and
        <code><a href="@TOP@/org/netbeans/modules/sampler/Sampler.html">Sampler</a>.stopAndWriteTo(DataOutputStream dos)</code>.
   </usecase>
  </p>
 </answer>



<!--
        <question id="arch-what" when="init">
            What is this project good for?
            <hint>
            Please provide here a few lines describing the project, 
            what problem it should solve, provide links to documentation, 
            specifications, etc.
            </hint>
        </question>
-->
 <answer id="arch-what">
  <p>
   It allows NetBeans Platform developer to self-sample their application,
   which should provide them with a valuable information about CPU 
   performance problems.
  </p>
 </answer>



<!--
        <question id="arch-where" when="init">
            Where one can find sources for your module?
            <hint>
                Please provide link to the CVS web client at
                http://www.netbeans.org/download/source_browse.html
                or just use tag defaultanswer generate='here'
            </hint>
        </question>
-->
 <answer id="arch-where">
  <defaultanswer generate='here' />
 </answer>



<!--
        <question id="compat-i18n" when="impl">
            Is your module correctly internationalized?
            <hint>
            Correct internationalization means that it obeys instructions 
            at <a href="http://www.netbeans.org/download/dev/javadoc/org-openide-modules/org/openide/modules/doc-files/i18n-branding.html">
            NetBeans I18N pages</a>.
            </hint>
        </question>
-->
 <answer id="compat-i18n">
  <p>
   Yes, it is.
  </p>
 </answer>

<answer id="compat-deprecation">
  <p>
   This module replaces the previous semi-API
   offered by <code>core.ui</code> module. Modules are now adviced
   to depend just on the API exported by this module. 
  </p>
 </answer>


<!--
        <question id="compat-standards" when="init">
            Does the module implement or define any standards? Is the 
            implementation exact or does it deviate somehow?
        </question>
-->
 <answer id="compat-standards">
  <p>
   No standard is implemented by this module.
  </p>
 </answer>



<!--
        <question id="compat-version" when="impl">
            Can your module coexist with earlier and future
            versions of itself? Can you correctly read all old settings? Will future
            versions be able to read your current settings? Can you read
            or politely ignore settings stored by a future version?
            
            <hint>
            Very helpful for reading settings is to store version number
            there, so future versions can decide whether how to read/convert
            the settings and older versions can ignore the new ones.
            </hint>
        </question>
-->
 <answer id="compat-version">
  <p>
   XXX no answer for compat-version
  </p>
 </answer>



<!--
        <question id="dep-jre" when="final">
            Which version of JRE do you need (1.2, 1.3, 1.4, etc.)?
            <hint>
            It is expected that if your module runs on 1.x that it will run 
            on 1.x+1 if no, state that please. Also describe here cases where
            you run different code on different versions of JRE and why.
            </hint>
        </question>
-->
 <answer id="dep-jre">
  <p>
   XXX no answer for dep-jre
  </p>
 </answer>



<!--
        <question id="dep-jrejdk" when="final">
            Do you require the JDK or is the JRE enough?
        </question>
-->
 <answer id="dep-jrejdk">
  <p>
   XXX no answer for dep-jrejdk
  </p>
 </answer>



<!--
        <question id="dep-nb" when="init">
            What other NetBeans projects and modules does this one depend on?
            <hint>
            If you want, describe such projects as imported APIs using
            the <code>&lt;api name="identification" type="import or export" category="stable" url="where is the description" /&gt;</code>
            </hint>
        </question>
-->
 <answer id="dep-nb">
  <defaultanswer generate='here' />
 </answer>



<!--
        <question id="dep-non-nb" when="init">
            What other projects outside NetBeans does this one depend on?
            
            <hint>
            Some non-NetBeans projects are packaged as NetBeans modules
            (see <a href="http://libs.netbeans.org/">libraries</a>) and
            it is preferred to use this approach when more modules may
            depend on such third-party library.
            </hint>
        </question>
-->
 <answer id="dep-non-nb">
  <p>
   None.
  </p>
 </answer>



<!--
        <question id="dep-platform" when="init">
            On which platforms does your module run? Does it run in the same
            way on each?
            <hint>
            If your module is using JNI or deals with special differences of
            OSes like filesystems, etc. please describe here what they are.
            </hint>
        </question>
-->
 <answer id="dep-platform">
  <p>
   There is no platform dependency.
  </p>
 </answer>



 <answer id="deploy-dependencies">
  <p>
   Nothing.
  </p>
 </answer>



<!--
        <question id="deploy-jar" when="impl">
            Do you deploy just module JAR file(s) or other files as well?
            <hint>
            Usually a module consist of one JAR file (perhaps with Class-Path
            extensions) and also a configuration file that enables it. If you
            have any other files, use
            &lt;api group="java.io.File" name="yourname" type="export" category="friend"&gt;...&lt;/api&gt;
            to define the location, name and stability of your files (of course
            changing "yourname" and "friend" to suit your needs).
            
            If it uses more than one JAR, describe where they are located, how
            they refer to each other. 
            If it consist of module JAR(s) and other files, please describe
            what is their purpose, why other files are necessary. Please 
            make sure that installation/uninstallation leaves the system 
            in state as it was before installation.
            </hint>
        </question>
-->
 <answer id="deploy-jar">
  <p>
   XXX no answer for deploy-jar
  </p>
 </answer>



<!--
        <question id="deploy-nbm" when="impl">
            Can you deploy an NBM via the Update Center?
            <hint>
            If not why?
            </hint>
        </question>
-->
 <answer id="deploy-nbm">
  <p>
   Yes, it can be deployed as NBM.
  </p>
 </answer>



<!--
        <question id="deploy-packages" when="init">
            Are packages of your module made inaccessible by not declaring them
            public?
            
            <hint>
            NetBeans module system allows restriction of access rights to
            public classes of your module from other modules. This prevents
            unwanted dependencies of others on your code and should be used
            whenever possible (<a href="http://www.netbeans.org/download/javadoc/OpenAPIs/org/openide/doc-files/upgrade.html#3.4-public-packages">
            public packages
            </a>). If you do not restrict access to your classes you are
            making it too easy for other people to misuse your implementation
            details, that is why you should have good reason for not 
            restricting package access.
            </hint>
        </question>
-->
 <answer id="deploy-packages">
  <p>
   XXX no answer for deploy-packages
  </p>
 </answer>



<!--
        <question id="deploy-shared" when="final">
            Do you need to be installed in the shared location only, or in the user directory only,
            or can your module be installed anywhere?
            <hint>
            Installation location shall not matter, if it does explain why.
            Consider also whether <code>InstalledFileLocator</code> can help.
            </hint>
        </question>
-->
 <answer id="deploy-shared">
  <p>
   XXX no answer for deploy-shared
  </p>
 </answer>



<!--
        <question id="exec-ant-tasks" when="impl">
            Do you define or register any ant tasks that other can use?
            
            <hint>
            If you provide an ant task that users can use, you need to be very
            careful about its syntax and behaviour, as it most likely forms an
	          API for end users and as there is a lot of end users, their reaction
            when such API gets broken can be pretty strong.
            </hint>
        </question>
-->
 <answer id="exec-ant-tasks">
  <p>
   XXX no answer for exec-ant-tasks
  </p>
 </answer>



<!--
        <question id="exec-classloader" when="impl">
            Does your code create its own class loader(s)?
            <hint>
            A bit unusual. Please explain why and what for.
            </hint>
        </question>
-->
 <answer id="exec-classloader">
  <p>
   XXX no answer for exec-classloader
  </p>
 </answer>



<!--
        <question id="exec-component" when="impl">
            Is execution of your code influenced by any (string) property
            of any of your components?
            
            <hint>
            Often <code>JComponent.getClientProperty</code>, <code>Action.getValue</code>
            or <code>PropertyDescriptor.getValue</code>, etc. are used to influence
            a behavior of some code. This of course forms an interface that should
            be documented. Also if one depends on some interface that an object
            implements (<code>component instanceof Runnable</code>) that forms an
            API as well.
            </hint>
        </question>
-->
 <answer id="exec-component">
  <p>
   XXX no answer for exec-component
  </p>
 </answer>



<!--
        <question id="exec-introspection" when="impl">
            Does your module use any kind of runtime type information (<code>instanceof</code>,
            work with <code>java.lang.Class</code>, etc.)?
            <hint>
            Check for cases when you have an object of type A and you also
            expect it to (possibly) be of type B and do some special action. That
            should be documented. The same applies on operations in meta-level
            (Class.isInstance(...), Class.isAssignableFrom(...), etc.).
            </hint>
        </question>
-->
 <answer id="exec-introspection">
  <p>
   XXX no answer for exec-introspection
  </p>
 </answer>



<!--
        <question id="exec-privateaccess" when="final">
            Are you aware of any other parts of the system calling some of 
            your methods by reflection?
            <hint>
            If so, describe the "contract" as an API. Likely private or friend one, but
            still API and consider rewrite of it.
            </hint>
        </question>
-->
 <answer id="exec-privateaccess">
  <p>
   XXX no answer for exec-privateaccess
  </p>
 </answer>



<!--
        <question id="exec-process" when="impl">
            Do you execute an external process from your module? How do you ensure
            that the result is the same on different platforms? Do you parse output?
            Do you depend on result code?
            <hint>
            If you feed an input, parse the output please declare that as an API.
            </hint>
        </question>
-->
 <answer id="exec-process">
  <p>
   XXX no answer for exec-process
  </p>
 </answer>



<!--
        <question id="exec-property" when="impl">
            Is execution of your code influenced by any environment or
            Java system (<code>System.getProperty</code>) property?
            
            <hint>
            If there is a property that can change the behavior of your 
            code, somebody will likely use it. You should describe what it does 
            and the <a href="http://openide.netbeans.org/tutorial/api-design.html#life">stability category</a>
            of this API. You may use
            <pre>
                &lt;api type="export" group="property" name="id" category="private" url="http://..."&gt;
                    description of the property, where it is used, what it influence, etc.
                &lt;/api&gt;            
            </pre>
            </hint>
        </question>
-->
 <answer id="exec-property">
  <p>
   XXX no answer for exec-property
  </p>
 </answer>



<!--
        <question id="exec-reflection" when="impl">
            Does your code use Java Reflection to execute other code?
            <hint>
            This usually indicates a missing or insufficient API in the other
            part of the system. If the other side is not aware of your dependency
            this contract can be easily broken.
            </hint>
        </question>
-->
 <answer id="exec-reflection">
  <p>
   XXX no answer for exec-reflection
  </p>
 </answer>



<!--
        <question id="exec-threading" when="impl">
            What threading models, if any, does your module adhere to?
            <hint>
                If your module calls foreign APIs which have a specific threading model,
                indicate how you comply with the requirements for multithreaded access
                (synchronization, mutexes, etc.) applicable to those APIs.
                If your module defines any APIs, or has complex internal structures
                that might be used from multiple threads, declare how you protect
                data against concurrent access, race conditions, deadlocks, etc.,
                and whether such rules are enforced by runtime warnings, errors, assertions, etc.
                Examples: a class might be non-thread-safe (like Java Collections); might
                be fully thread-safe (internal locking); might require access through a mutex
                (and may or may not automatically acquire that mutex on behalf of a client method);
                might be able to run only in the event queue; etc.
                Also describe when any events are fired: synchronously, asynchronously, etc.
                Ideas: <a href="http://core.netbeans.org/proposals/threading/index.html#recommendations">Threading Recommendations</a> (in progress)
            </hint>
        </question>
-->
 <answer id="exec-threading">
  <p>
   XXX no answer for exec-threading
  </p>
 </answer>



<!--
        <question id="format-clipboard" when="impl">
            Which data flavors (if any) does your code read from or insert to
            the clipboard (by access to clipboard on means calling methods on <code>java.awt.datatransfer.Transferable</code>?
            
            <hint>
            Often Node's deal with clipboard by usage of <code>Node.clipboardCopy, Node.clipboardCut and Node.pasteTypes</code>.
            Check your code for overriding these methods.
            </hint>
        </question>
-->
 <answer id="format-clipboard">
  <p>
   XXX no answer for format-clipboard
  </p>
 </answer>



<!--
        <question id="format-dnd" when="impl">
            Which protocols (if any) does your code understand during Drag &amp; Drop?
            <hint>
            Often Node's deal with clipboard by usage of <code>Node.drag, Node.getDropType</code>. 
            Check your code for overriding these methods. Btw. if they are not overridden, they
            by default delegate to <code>Node.clipboardCopy, Node.clipboardCut and Node.pasteTypes</code>.
            </hint>
        </question>
-->
 <answer id="format-dnd">
  <p>
   XXX no answer for format-dnd
  </p>
 </answer>



<!--
        <question id="format-types" when="impl">
            Which protocols and file formats (if any) does your module read or write on disk,
            or transmit or receive over the network? Do you generate an ant build script?
            Can it be edited and modified? 
            
            <hint>
            <p>
            Files can be read and written by other programs, modules and users. If they influence
            your behaviour, make sure you either document the format or claim that it is a private
            api (using the &lt;api&gt; tag). 
            </p>
            
            <p>
            If you generate an ant build file, this is very likely going to be seen by end users and
            they will be attempted to edit it. You should be ready for that and provide here a link
            to documentation that you have for such purposes and also describe how you are going to
            understand such files during next release, when you (very likely) slightly change the 
            format.
            </p>
            </hint>
        </question>
-->
 <answer id="format-types">
  <p>
   XXX no answer for format-types
  </p>
 </answer>



<!--
        <question id="lookup-lookup" when="init">
            Does your module use <code>org.openide.util.Lookup</code>
            or any similar technology to find any components to communicate with? Which ones?
            
            <hint>
            Please describe the interfaces you are searching for, where 
            are defined, whether you are searching for just one or more of them,
            if the order is important, etc. Also classify the stability of such
            API contract. For that use &lt;api group=&amp;lookup&amp; /&gt; tag.
            </hint>
        </question>
-->
 <answer id="lookup-lookup">
  <p>
   XXX no answer for format-types
  </p>
 </answer>



<!--
        <question id="lookup-register" when="final">
            Do you register anything into lookup for other code to find?
            <hint>
            Do you register using layer file or using <code>META-INF/services</code>?
            Who is supposed to find your component?
            </hint>
        </question>
-->
 <answer id="lookup-register">
  <p>
   XXX no answer for lookup-register
  </p>
 </answer>



<!--
        <question id="lookup-remove" when="final">
            Do you remove entries of other modules from lookup?
            <hint>
            Why? Of course, that is possible, but it can be dangerous. Is the module
            your are masking resource from aware of what you are doing?
            </hint>
        </question>
-->
 <answer id="lookup-remove">
  <p>
   XXX no answer for lookup-remove
  </p>
 </answer>



<!--
        <question id="perf-exit" when="final">
            Does your module run any code on exit?
        </question>
-->
 <answer id="perf-exit">
  <p>
   XXX no answer for perf-exit
  </p>
 </answer>



<!--
        <question id="perf-huge_dialogs" when="final">
            Does your module contain any dialogs or wizards with a large number of
            GUI controls such as combo boxes, lists, trees, or text areas?
        </question>
-->
 <answer id="perf-huge_dialogs">
  <p>
   XXX no answer for perf-huge_dialogs
  </p>
 </answer>



<!--
        <question id="perf-limit" when="init">
            Are there any hard-coded or practical limits in the number or size of
            elements your code can handle?
        </question>
-->
 <answer id="perf-limit">
  <p>
   XXX no answer for perf-limit
  </p>
 </answer>



<!--
        <question id="perf-mem" when="final">
            How much memory does your component consume? Estimate
            with a relation to the number of windows, etc.
        </question>
-->
 <answer id="perf-mem">
  <p>
   XXX no answer for perf-mem
  </p>
 </answer>



<!--
        <question id="perf-menus" when="final">
            Does your module use dynamically updated context menus, or
            context-sensitive actions with complicated and slow enablement logic?
            <hint>
                If you do a lot of tricks when adding actions to regular or context menus, you can significantly
                slow down display of the menu, even when the user is not using your action. Pay attention to
                actions you add to the main menu bar, and to context menus of foreign nodes or components. If
                the action is conditionally enabled, or changes its display dynamically, you need to check the
                impact on performance. In some cases it may be more appropriate to make a simple action that is
                always enabled but does more detailed checks in a dialog if it is actually run.
            </hint>
        </question>
-->
 <answer id="perf-menus">
  <p>
   XXX no answer for perf-menus
  </p>
 </answer>



<!--
        <question id="perf-progress" when="final">
            Does your module execute any long-running tasks?
            
            <hint>Long running tasks should never block 
            AWT thread as it badly hurts the UI
            <a href="http://performance.netbeans.org/responsiveness/issues.html">
            responsiveness</a>.
            Tasks like connecting over
            network, computing huge amount of data, compilation
            be done asynchronously (for example
            using <code>RequestProcessor</code>), definitively it should 
            not block AWT thread.
            </hint>
        </question>
-->
 <answer id="perf-progress">
  <p>
   XXX no answer for perf-progress
  </p>
 </answer>



<!--
        <question id="perf-scale" when="init">
            Which external criteria influence the performance of your
            program (size of file in editor, number of files in menu, 
            in source directory, etc.) and how well your code scales?
            <hint>
            Please include some estimates, there are other more detailed 
            questions to answer in later phases of implementation. 
            </hint>
        </question>
-->
 <answer id="perf-scale">
  <p>
   XXX no answer for perf-scale
  </p>
 </answer>



<!--
        <question id="perf-spi" when="init">
            How the performance of the plugged in code will be enforced?
            <hint>
            If you allow foreign code to be plugged into your own module, how
            do you enforce that it will behave correctly and quickly and will not
            negatively influence the performance of your own module?
            </hint>
        </question>
-->
 <answer id="perf-spi">
  <p>
   XXX no answer for perf-spi
  </p>
 </answer>



<!--
        <question id="perf-startup" when="final">
            Does your module run any code on startup?
        </question>
-->
 <answer id="perf-startup">
  <p>
   XXX no answer for perf-startup
  </p>
 </answer>



<!--
        <question id="perf-wakeup" when="final">
            Does any piece of your code wake up periodically and do something
            even when the system is otherwise idle (no user interaction)?
        </question>
-->
 <answer id="perf-wakeup">
  <p>
   XXX no answer for perf-wakeup
  </p>
 </answer>



<!--
        <question id="resources-file" when="final">
            Does your module use <code>java.io.File</code> directly?
            
            <hint>
            NetBeans provide a logical wrapper over plain files called 
            <code>org.openide.filesystems.FileObject</code> that
            provides uniform access to such resources and is the preferred
            way that should be used. But of course there can be situations when
            this is not suitable.
            </hint>
        </question>
-->
 <answer id="resources-file">
  <p>
   XXX no answer for resources-file
  </p>
 </answer>



<!--
        <question id="resources-layer" when="final">
            Does your module provide own layer? Does it create any files or
            folders in it? What it is trying to communicate by that and with which 
            components?
            
            <hint>
            NetBeans allows automatic and declarative installation of resources 
            by module layers. Module register files into appropriate places
            and other components use that information to perform their task
            (build menu, toolbar, window layout, list of templates, set of
            options, etc.). 
            </hint>
        </question>
-->
 <answer id="resources-layer">
  <p>
   XXX no answer for resources-layer
  </p>
 </answer>



<!--
        <question id="resources-mask" when="final">
            Does your module mask/hide/override any resources provided by other modules in
            their layers?
            
            <hint>
            If you mask a file provided by another module, you probably depend
            on that and do not want the other module to (for example) change
            the file's name. That module shall thus make that file available as an API
            of some stability category.
            </hint>
        </question>
-->
 <answer id="resources-mask">
  <p>
   XXX no answer for resources-mask
  </p>
 </answer>



<!--
        <question id="resources-read" when="final">
            Does your module read any resources from layers? For what purpose?
            
            <hint>
            As this is some kind of intermodule dependency, it is a kind of API.
            Please describe it and classify according to 
            <a href="http://openide.netbeans.org/tutorial/api-design.html#categories">
            common stability categories</a>.
            </hint>
        </question>
-->
 <answer id="resources-read">
  <p>
   XXX no answer for resources-read
  </p>
 </answer>



<!--
        <question id="security-grant" when="final">
            Does your code grant additional rights to some other code?
            <hint>Avoid using a class loader that adds extra
            permissions to loaded code unless really necessary.
            Also note that your API implementation
            can also expose unneeded permissions to enemy code by
            calling AccessController.doPrivileged().</hint>
        </question>
-->
 <answer id="security-grant">
  <p>
   XXX no answer for security-grant
  </p>
 </answer>



<!--
        <question id="security-policy" when="final">
            Does your functionality require modifications to the standard policy file?
            <hint>Your code might pass control to third-party code not
            coming from trusted domains. This could be code downloaded over the
            network or code coming from libraries that are not bundled
            with NetBeans. Which permissions need to be granted to which domains?</hint>
        </question>
-->
 <answer id="security-policy">
  <p>
   XXX no answer for security-policy
  </p>
 </answer>




<!--
        <question id="resources-preferences" when="final">
            Does your module uses preferences via Preferences API? Does your module use NbPreferences or
            or regular JDK Preferences ? Does it read, write or both ? 
            Does it share preferences with other modules ? If so, then why ?
            <hint>
                You may use
                    &lt;api type="export" group="preferences"
                    name="preference node name" category="private"&gt;
                    description of individual keys, where it is used, what it
                    influences, whether the module reads/write it, etc.
                    &lt;/api&gt;
                Due to XML ID restrictions, rather than /org/netbeans/modules/foo give the "name" as org.netbeans.modules.foo.
                Note that if you use NbPreferences this name will then be the same as the code name base of the module.
            </hint>
        </question>
-->
 <answer id="resources-preferences">
  <p>
   XXX no answer for resources-preferences
  </p>
 </answer>

</api-answers>

Line 0 Link Here

(-)a/sampler/build.xml (+5 lines)
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<project basedir="." default="netbeans" name="sampler">
	3	<description>Builds, tests, and runs the project org.netbeans.modules.sampler</description>
	4	<import file="../nbbuild/templates/projectized.xml"/>
	5	</project>

Line 0 Link Here

(-)a/sampler/manifest.mf (+5 lines)
	1	Manifest-Version: 1.0
	2	OpenIDE-Module: org.netbeans.modules.sampler
	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/sampler/Bundle.properties
	4	OpenIDE-Module-Specification-Version: 1.0
	5

Line 0 Link Here

(-)a/sampler/nbproject/project.properties (+4 lines)
	1	is.autoload=true
	2	javac.source=1.6
	3	javac.compilerargs=-Xlint -Xlint:-serial
	4	javadoc.arch=${basedir}/arch.xml




<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
    <type>org.netbeans.modules.apisupport.project</type>
    <configuration>
        <data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
            <code-name-base>org.netbeans.modules.sampler</code-name-base>
            <module-dependencies>
                <dependency>
                    <code-name-base>org.netbeans.api.annotations.common</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.13</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.api.progress</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>1</release-version>
                        <specification-version>1.27</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.awt</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>7.40</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.dialogs</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>7.24</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.filesystems</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>7.55</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.loaders</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>7.33</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.nodes</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>7.26</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>8.20</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.openide.util.lookup</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>8.12</specification-version>
                    </run-dependency>
                </dependency>
            </module-dependencies>
            <test-dependencies>
                <test-type>
                    <name>unit</name>
                    <test-dependency>
                        <code-name-base>org.netbeans.insane</code-name-base>
                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.netbeans.libs.junit4</code-name-base>
                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.netbeans.modules.nbjunit</code-name-base>
                        <compile-dependency/>
                    </test-dependency>
                    <test-dependency>
                        <code-name-base>org.openide.dialogs</code-name-base>
                        <compile-dependency/>
                    </test-dependency>
                </test-type>
            </test-dependencies>
            <public-packages>
                <package>org.netbeans.modules.sampler</package>
            </public-packages>
        </data>
    </configuration>
</project>

Line 0 Link Here

(-)a/sampler/src/org/netbeans/modules/sampler/Bundle.properties (+3 lines)
	1	OpenIDE-Module-Name=Sampler
	2	SelfSamplerAction_SavedFile=Snapshot was saved to {0}
	3	Save_Progress=Saving snapshot




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.sampler;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import javax.management.MBeanServerConnection;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

/**
 * Support for sampling from command line
 *
 * @author Tomas Hurka, Jaroslav Tulach
 *
 */
class CLISampler extends Sampler {
    
    private final ThreadMXBean threadMXBean;
    private final File output;

    public static void main(String... args) throws Exception {
        if (args.length != 2) {
            System.out.println("Usage: <port> <snapshot.npss>");
            System.out.println();
            System.out.println("First of all start your application with following parameters:");
            System.out.println("  -Dcom.sun.management.jmxremote.authenticate=false");
            System.out.println("  -Dcom.sun.management.jmxremote.ssl=false");
            System.out.println("  -Dcom.sun.management.jmxremote.port=<port>");
            System.out.println("Then you can start this sampler with correct port and file to write snapshot to.");
            System.exit(1);
        }
        if (!SamplesOutputStream.isSupported()) {
            System.err.println("Sampling is not supported by JVM");
            System.exit(2);
        }

        String u = args[0];
        try {
            u = "service:jmx:rmi:///jndi/rmi://localhost:" + Integer.parseInt(args[0]) + "/jmxrmi";
        } catch (NumberFormatException ex) {
            // OK, use args[0]
        }

        System.err.println("Connecting to " + u);
        JMXServiceURL url = new JMXServiceURL(u);
        JMXConnector jmxc = null;
        Exception ex = null;
        for (int i = 0; i < 100; i++) {
            try {
                jmxc = JMXConnectorFactory.connect(url, null);
                break;
            } catch (IOException e) {
                ex = e;
                System.err.println("Connection failed. Will retry in 300ms.");
                Thread.sleep(300);
            }
        }
        if (jmxc == null) {
            ex.printStackTrace();
            System.err.println("Cannot connect to " + u);
            System.exit(3);
        }
        MBeanServerConnection server = jmxc.getMBeanServerConnection();

        final ThreadMXBean threadMXBean = ManagementFactory.newPlatformMXBeanProxy(
                server, ManagementFactory.THREAD_MXBEAN_NAME, ThreadMXBean.class);
        final File output = new File(args[1]);


        CLISampler s = new CLISampler(threadMXBean, output);
        s.start();
        System.out.println("Press enter to generate sample into " + output);
        System.in.read();
        s.stop();
        System.out.println();
        System.out.println("Sample written to " + output);
        System.exit(0);
    }

    private CLISampler(ThreadMXBean threadBean, File out) {
        super("CLISampler");
        threadMXBean = threadBean;
        output = out;
    }

    @Override
    protected ThreadMXBean getThreadMXBean() {
        return threadMXBean;
    }

    @Override
    protected void saveSnapshot(byte[] arr) throws IOException {
        FileOutputStream os = new FileOutputStream(output);
        os.write(arr);
        os.close();
    }

    @Override
    protected void printStackTrace(Throwable ex) {
        ex.printStackTrace();
        System.exit(2);
    }

    @Override
    protected void openProgress(int steps) {
    }

    @Override
    protected void closeProgress() {
    }

    @Override
    protected void progress(int i) {
        System.out.print("#");
        System.out.flush();
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.sampler;

import java.awt.EventQueue;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.lang.management.ThreadMXBean;
import java.text.MessageFormat;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.api.actions.Openable;
import org.netbeans.api.progress.ProgressHandle;
import org.netbeans.api.progress.ProgressHandleFactory;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;

/**
 *
 * @author Tomas Hurka
 */
final class InternalSampler extends Sampler {
    private static final String SAVE_MSG = NbBundle.getMessage(InternalSampler.class, "SelfSamplerAction_SavedFile");  // NOI18N
    private static Class defaultDataObject;
    private static final String DEBUG_ARG = "-Xdebug"; // NOI18N
    private static final Logger LOGGER = Logger.getLogger(InternalSampler.class.getName());
    private static Boolean debugMode;
    private static String lastReason;

    private ProgressHandle progress;
    static {
        try {
            defaultDataObject = Class.forName("org.openide.loaders.DefaultDataObject"); // NOI18N
        } catch (ClassNotFoundException ex) {
            Exceptions.printStackTrace(ex);
        }
    }

    static InternalSampler getInternalSampler(String key) {
        if (SamplesOutputStream.isSupported() && isRunMode()) {
            return new InternalSampler(key);
        }
        return null;
    }

    private static synchronized boolean isDebugged() {
        if (debugMode == null) {
            debugMode = Boolean.FALSE;

            // check if we are debugged
            RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
            List<String> args = runtime.getInputArguments();
            if (args.contains(DEBUG_ARG)) {
                debugMode = Boolean.TRUE;
            }
        }
        return debugMode.booleanValue();
    }

    private static boolean isRunMode() {
        boolean runMode = true;
        String reason = null;

        if (isDebugged()) {
            reason = "running in debug mode";   // NOI18N
            runMode = false;
        }
        if (runMode) {
            // check if netbeans is profiled
            try {
                Class.forName("org.netbeans.lib.profiler.server.ProfilerServer", false, ClassLoader.getSystemClassLoader()); // NO18N
                reason = "running under profiler";   // NOI18N
                runMode = false;
            } catch (ClassNotFoundException ex) {
            }
        }
        if (!runMode && !reason.equals(lastReason)) {
            LOGGER.log(Level.INFO, "Slowness detector disabled - {0}", reason); // NOI18N
        }
        lastReason = reason;
        return runMode;
    }
    
    InternalSampler(String thread) {
        super(thread);
    }

    @Override
    protected void printStackTrace(Throwable ex) {
        Exceptions.printStackTrace(ex);
    }

    @Override
    protected void saveSnapshot(byte[] arr) throws IOException { // save snapshot
        File outFile = File.createTempFile("selfsampler", SamplesOutputStream.FILE_EXT); // NOI18N
        String userDir = System.getProperty("netbeans.user");
        File gestures = null;
        SelfSampleVFS fs;
        
        outFile = FileUtil.normalizeFile(outFile);
        writeToFile(outFile, arr);
        if (userDir != null) {
            gestures = new File(new File(new File(new File(userDir), "var"), "log"), "uigestures"); // NOI18N
        }
        if (gestures != null && gestures.exists()) {
            fs = new SelfSampleVFS(new String[]{"selfsampler.npss", "selfsampler.log"}, new File[]{outFile, gestures});
        } else {
            fs = new SelfSampleVFS(new String[]{"selfsampler.npss"}, new File[]{outFile});
        }
        // open snapshot
        FileObject fo = fs.findResource("selfsampler.npss");
        DataObject dobj = DataObject.find(fo);
        // ugly test for DefaultDataObject
        if (defaultDataObject.isAssignableFrom(dobj.getClass())) {
            String msg = MessageFormat.format(SAVE_MSG, outFile.getAbsolutePath());
            DialogDisplayer.getDefault().notify(new NotifyDescriptor.Message(msg));
        } else {
            dobj.getLookup().lookup(Openable.class).open();
        }
    }

    private void writeToFile(File file, byte[] arr) {
        try {
            FileOutputStream fstream = new FileOutputStream(file);
            fstream.write(arr);
            fstream.close();
        } catch (IOException ex) {
            Exceptions.printStackTrace(ex);
        }
    }

    @Override
    ThreadMXBean getThreadMXBean() {
        return ManagementFactory.getThreadMXBean();
    }

    @Override
    void openProgress(final int steps) {
        if (EventQueue.isDispatchThread()) {
            // log warnining
            return;
        }
        progress = ProgressHandleFactory.createHandle(NbBundle.getMessage(InternalSampler.class, "Save_Progress"));
        progress.start(steps);
    }

    @Override
    void closeProgress() {
        if (EventQueue.isDispatchThread()) {
            return;
        }
        progress.finish();
        progress = null;
    }

    @Override
    void progress(int i) {
        if (EventQueue.isDispatchThread()) {
            return;
        }
        if (progress != null) {
            progress.progress(i);
        }
    }
    
}




 *
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */
package org.netbeans.modules.sampler;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import javax.management.remote.JMXServiceURL;

/**
 * Sampler class provides API for self-sampling of NetBeans
 * platform application. The self-sampling should be used for
 * diagnostic purposes and should help NetBeans platform developers
 * with solving CPU related performance problems. Sampled data are
 * stored in NPSS file, which can be opened by NetBeans Profiler or
 * Java VisualVM for later analysis of sampled data.
 * 
 * @author Jaroslav Bachorik, Tomas Hurka, Jaroslav Tulach
 */
public abstract class Sampler {
    private static final int SAMPLER_RATE = 10;
    private static final double MAX_AVERAGE = SAMPLER_RATE * 3;
    private static final double MAX_STDDEVIATION = SAMPLER_RATE * 4;

    private volatile boolean stopped;
    private volatile boolean running;

    /**
     * Factory method for creating Sampler suitable for automatic reporting
     * of the slow operation (i.e. AWT blocked for some time). This method can
     * return <code>null</code> if the sampled application is in nonstandard mode
     * which will produce unrealistic data - for example application is  
     * running under debugger or profiler. 
     * @param name which identifies the sampler thread
     * @return instance of the {@link Sampler} or <code>null</code> if application
     * is in nonstandard mode.
     */
    public static @CheckForNull Sampler getSampler(@NonNull String name) {
        return InternalSampler.getInternalSampler(name);
    }
    
    /**
     * Factory method for creating Sampler suitable for manual or user invoked
     * scanning. This method can return <code>null</code> if it is running on 
     * some exotic variant of JDK, where sampling is not supported.
     * @param name which identifies the sampler thread 
     * @return instance of the {@link Sampler} or <code>null</code> if sampling 
     * is not supported.
     */
    public static @CheckForNull Sampler getGenericSampler(@NonNull String name) {
        if (SamplesOutputStream.isSupported()) {
            return new InternalSampler(name);
        }
        return null;
    }
    
    Sampler(String n) {
        name = n;
    }

    /** Returns the bean to use for sampling.
     * @return instance of the bean to take thread dumps from
     */
    abstract ThreadMXBean getThreadMXBean();

    /** Allows subclasses to handle created snapshot
     * @param arr the content of the snapshot
     * @throws IOException thrown in case of I/O error
     */
    abstract void saveSnapshot(byte[] arr) throws IOException;
    
    /** How to report an exception.
     * 
     * @param ex exception
     */
    abstract void printStackTrace(Throwable ex);
    
    /** Methods for displaying progress.
     */
    abstract void openProgress(int steps);
    abstract void closeProgress();
    abstract void progress(int i);
    
    private void updateStats(long timestamp) {
        if (laststamp != 0) {

        laststamp = timestamp;
    }

    /**
     * Start self-sampling. This method starts timer identified by <code>name</code>
     * for actual sampling and returns immediately.
     */
    public synchronized void start() {
        if (running) throw new IllegalStateException("sampling is already running");    // NOI18N
        if (stopped) throw new IllegalStateException("it is not possible to restart sampling");   // NOI18N
        running = true;
        final ThreadMXBean threadBean = getThreadMXBean();
        out = new ByteArrayOutputStream(64 * 1024);

        }, SAMPLER_RATE, SAMPLER_RATE);
    }

    /**
     * Cancels the self-sampling. All sampled data are discarded.
     */
    public void cancel() {
        stopSampling(true, null);
    }
    
    /**
     * Stop the self-sampling started by {@link #start()} method and writes the data to 
     * {@link DataOutputStream}. If the internal sampling logic detects that
     * the data are distorted for example due to heavy system I/O, collected 
     * samples are discarded and nothing is written to {@link DataOutputStream}.
     * <br>
     * This method can take a long time and should not be invoked from EDT.
     * @param dos {@link DataOutputStream} where sampled data is written to.
     */
    public void stopAndWriteTo(@NonNull DataOutputStream dos) {
        stopSampling(false, dos);
    }
    
    /**
     * Stop the self-sampling, save and open gathered data. If there is no
     * sampled data, this method does nothing and returns immediately.
     * <br>
     * This method can take a long time and should not be invoked from EDT.
     */
    public void stop() {
        stopSampling(false, null);
    }
    
    private synchronized void stopSampling(boolean cancel, DataOutputStream dos) {
        try {
            if (!running) throw new IllegalStateException("sampling was not started"); // NOI18N
            if (stopped) throw new IllegalStateException("sampling is not running");    // NOI18N
            stopped = true;
            timer.cancel();
            if (cancel || samples < 1) {
                return;
            }
            if (SwingUtilities.isEventDispatchThread()) throw new IllegalStateException("sampling cannot be stopped from EDT");
            double average = sum / samples;
            double std_deviation = Math.sqrt(devSquaresSum / samples);
            boolean writeCommand = dos != null;
            if (writeCommand) {
                Object[] params = new Object[]{startTime, "Samples", samples, "Average", average, "Minimum", min, "Maximum", max, "Std. deviation", std_deviation};  // NOI18N
                Logger.getLogger("org.netbeans.ui.performance").log(Level.CONFIG, "Snapshot statistics", params); // NOI18N
                if (average > MAX_AVERAGE || std_deviation > MAX_STDDEVIATION || samples < MIN_SAMPLES) {
                    // do not take snapshot if the sampling was not regular enough

            samplesStream.close();
            samplesStream = null;
            if (writeCommand) {
                DataOutputStream dos = (DataOutputStream) e.getSource();
                dos.write(out.toByteArray());
                dos.close();
                return;

            out = null;
            samplesStream = null;
        }
    }    
    
    //
    // Support for sampling from command line
    //
    
    public static void main(String... args) throws Exception {
        if (args.length != 2) {
            System.out.println("Usage: <port> <snapshot.npss>");
            System.out.println();
            System.out.println("First of all start your application with following parameters:");
            System.out.println("  -Dcom.sun.management.jmxremote.authenticate=false");
            System.out.println("  -Dcom.sun.management.jmxremote.ssl=false");
            System.out.println("  -Dcom.sun.management.jmxremote.port=<port>");
            System.out.println("Then you can start this sampler with correct port and file to write snapshot to.");
            System.exit(1);
        }
        
        String u = args[0];
        try {
            u = "service:jmx:rmi:///jndi/rmi://localhost:" + Integer.parseInt(args[0]) + "/jmxrmi";
        } catch (NumberFormatException ex) {
            // OK, use args[0]
        }
        
        System.err.println("Connecting to " + u);
        JMXServiceURL url = new JMXServiceURL(u);
        JMXConnector jmxc = null;
        Exception ex = null;
        for (int i = 0; i < 100; i++) {
            try {
                jmxc = JMXConnectorFactory.connect(url, null);
                break;
            } catch (IOException e) {
                ex = e;
                System.err.println("Connection failed. Will retry in 300ms.");
                Thread.sleep(300);
            }
        }
        if (jmxc == null) {
            ex.printStackTrace();
            System.err.println("Cannot connect to " + u);
            System.exit(3);
        }
        MBeanServerConnection server = jmxc.getMBeanServerConnection();
        
        final ThreadMXBean threadMXBean = ManagementFactory.newPlatformMXBeanProxy(
            server,ManagementFactory.THREAD_MXBEAN_NAME,ThreadMXBean.class
        );
        final File output = new File(args[1]);
        class CLISampler extends Sampler {
            CLISampler() {
                super("");
            }
            
            @Override
            protected ThreadMXBean getThreadMXBean() {
                return threadMXBean;
            }

            @Override
            protected void saveSnapshot(byte[] arr) throws IOException {
                FileOutputStream os = new FileOutputStream(output);
                os.write(arr);
                os.close();
            }

            @Override
            protected void printStackTrace(Throwable ex) {
                ex.printStackTrace();
                System.exit(2);
            }

            @Override
            protected void openProgress(int steps) {
            }

            @Override
            protected void closeProgress() {
            }

            @Override
            protected void progress(int i) {
                System.out.print("#");
                System.out.flush();
            }
        }
        
        CLISampler s = new CLISampler();
        s.run();
        System.out.println("Press enter to generate sample into " + output);
        System.in.read();
        s.actionPerformed(new ActionEvent(s, 0, ""));
        System.out.println();
        System.out.println("Sample written to " + output);
        System.exit(0);
    }
}




 * Portions Copyrighted 2010 Sun Microsystems, Inc.
 */

package org.netbeans.modules.sampler;

import java.io.IOException;
import java.io.ObjectOutputStream;

 *
 * @author Tomas Hurka
 */
class SamplesOutputStream {

    private static final String[][] methods = new String[][]{
        {"sun.management.ThreadInfoCompositeData", "toCompositeData"}, // NOI18N Sun JVM
        {"com.ibm.lang.management.ManagementUtils", "toThreadInfoCompositeData"} // NOI18N IBM J9
    };
    static final String ID = "NPSS"; // NetBeans Profiler samples stream
    public static final String FILE_EXT = ".npss"; // NOI18N
    static final int RESET_THRESHOLD = 5000;
    static final int STEPS = 1000;
    static byte version = 2;

    int maxSamples;
    int offset;

    public static boolean isSupported() {
        return toCompositeDataMethod != null;
    }

    SamplesOutputStream(OutputStream os, Sampler progress, int max) throws IOException {
        maxSamples = max;
        this.progress = progress;
        outStream = os;

        samples = new ArrayList(1024);
    }

    void writeSample(ThreadInfo[] infos, long time, long selfThreadId) throws IOException {
        List<Long> sameT = new ArrayList();
        List<ThreadInfo> newT = new ArrayList();
        List<Long> tids = new ArrayList();

        }
    }

    void close() throws IOException {
        steCache = null;
        GZIPOutputStream stream = new GZIPOutputStream(outStream, 64 * 1024);
        ObjectOutputStream out = new ObjectOutputStream(stream);

Lines 40-46 Link Here

(-)a/core.ui/src/org/netbeans/core/ui/sampler/SelfSampleVFS.java (-1 / +1 lines)
40	* Portions Copyrighted 2010 Sun Microsystems, Inc.	40	* Portions Copyrighted 2010 Sun Microsystems, Inc.
41	*/	41	*/
42		42
43	package org.netbeans.core.ui.sampler;	43	package org.netbeans.modules.sampler;
44		44
45	import java.io.File;	45	import java.io.File;
46	import java.io.FileInputStream;	46	import java.io.FileInputStream;




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.sampler;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.management.ThreadInfo;

/**
 *
 * @author Tomas Hurka
 */
public class CustomSamplesStream extends SamplesOutputStream {

    public CustomSamplesStream(OutputStream os, int max) throws IOException {
        super(os, null, max);
    }

    @Override
    public void writeSample(ThreadInfo[] infos, long time, long selfThreadId) throws IOException {
        super.writeSample(infos, time, selfThreadId);
    }
    
    @Override
    public void close() throws IOException {
        super.close();
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.sampler;

import java.awt.Dialog;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import org.junit.*;
import static org.junit.Assert.*;
import org.netbeans.junit.MockServices;
import org.netbeans.junit.NbTestCase;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;
import org.openide.NotifyDescriptor;
import org.openide.util.Exceptions;

/**
 *
 * @author Tomas Hurka
 */
public class SamplerTest {

    @BeforeClass
    public static void setUpClass() throws Exception {
        //register DialogDisplayer which "pushes" Yes option in the document save dialog
        MockServices.setServices(DD.class);
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }
    
    @After
    public void tearDown() {
    }

    /**
     * Test of getSampler method, of class Sampler.
     */
    @Test
    public void testGetSampler() {
        System.out.println("getSampler");
        String name = "test";
        Sampler result = Sampler.getSampler(name);
        assertNotNull(result);
    }

    /**
     * Test of getGenericSampler method, of class Sampler.
     */
    @Test
    public void testGetGenericSampler() {
        System.out.println("getGenericSampler");
        String name = "gentest";
        Sampler result = Sampler.getGenericSampler(name);
        assertNotNull(result);
    }

    /**
     * Test of cancel method, of class Sampler.
     */
    @Test
    public void testCancel() {
        System.out.println("cancel");
        Sampler instance = Sampler.getGenericSampler("cancel");
        instance.start();
        instance.cancel();
    }

    /**
     * Test of stopAndWriteTo method, of class Sampler.
     */
    @Test
    public void testStopAndWriteTo() throws IOException {
        System.out.println("stopAndWriteTo");
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(out);
        Sampler instance = Sampler.getSampler("cancel");
        instance.start();
        instance.stopAndWriteTo(dos);
        dos.close();
        // there should no data in out, since stopAndWriteTo is 
        // invoked immediately after start
        assertTrue(out.size() == 0);
    }
   /**
     * Test of stopAndWriteTo method, of class Sampler.
     */
    @Test
    public void testStopAndWriteTo1() throws IOException {
        System.out.println("stopAndWriteTo1");
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(out);
        Sampler instance = Sampler.getSampler("cancel");
        instance.start();
        longRunningMethod();
        instance.stopAndWriteTo(dos);
        dos.close();
        // make sure we have some sampling data
        assertTrue(out.size() > 0);
    }

    private void longRunningMethod() {
        for (int i=0; i<100;i++) {
            try {
                Thread.sleep(30);
            } catch (InterruptedException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }

    /**
     * Test of stop method, of class Sampler.
     */
    @Test
    public void testStop() {
        System.out.println("stop");
        Sampler instance = Sampler.getGenericSampler("stop");
        DD.hasData = false;
        instance.start();
        longRunningMethod();
        instance.stop();
        assert(DD.hasData);
    }

    /** Our own dialog displayer.
     */
    public static final class DD extends DialogDisplayer {
        static boolean hasData;
        
        @Override
        public Dialog createDialog(DialogDescriptor descriptor) {
            throw new IllegalStateException ("Not implemented");
        }
        
        @Override
        public Object notify(NotifyDescriptor descriptor) {
           hasData = true;
           return null;
        }
        
    } // end of DD    
    
}

Lines 40-46 Link Here

(-)a/core.ui/test/unit/src/org/netbeans/core/ui/sampler/SelfSampleVFSTest.java (-1 / +1 lines)
40	* Portions Copyrighted 2010 Sun Microsystems, Inc.	40	* Portions Copyrighted 2010 Sun Microsystems, Inc.
41	*/	41	*/
42		42
43	package org.netbeans.core.ui.sampler;	43	package org.netbeans.modules.sampler;
44		44
45	import java.io.File;	45	import java.io.File;
46	import java.io.FileOutputStream;	46	import java.io.FileOutputStream;

Return to bug 206859

Lines 230-239 Link Here

(-)a/ide.kit/nbproject/project.xml (-4 / +5 lines)
230	<compile-dependency/>	230	<compile-dependency/>
231	</test-dependency>	231	</test-dependency>
232	<test-dependency>	232	<test-dependency>
233	<code-name-base>org.netbeans.core.ui</code-name-base>
234	<compile-dependency/>
235	</test-dependency>
236	<test-dependency>
237	<code-name-base>org.netbeans.libs.junit4</code-name-base>	233	<code-name-base>org.netbeans.libs.junit4</code-name-base>
238	<compile-dependency/>	234	<compile-dependency/>
239	</test-dependency>	235	</test-dependency>
Lines 264-269 Link Here
264	<compile-dependency/>	260	<compile-dependency/>
265	</test-dependency>	261	</test-dependency>
266	<test-dependency>	262	<test-dependency>
		263	<code-name-base>org.netbeans.modules.sampler</code-name-base>
		264	<compile-dependency/>
		265	<test/>
		266	</test-dependency>
		267	<test-dependency>
267	<code-name-base>org.openide.modules</code-name-base>	268	<code-name-base>org.openide.modules</code-name-base>
268	<compile-dependency/>	269	<compile-dependency/>
269	</test-dependency>	270	</test-dependency>

Lines 71-77 Link Here

(-)a/jumpto/src/org/netbeans/modules/jumpto/type/GoToTypeAction.java (-18 / +7 lines)
71	import java.util.logging.Logger;	71	import java.util.logging.Logger;
72	import java.util.regex.Pattern;	72	import java.util.regex.Pattern;
73	import javax.swing.AbstractAction;	73	import javax.swing.AbstractAction;
74	import javax.swing.Action;
75	import javax.swing.DefaultListModel;	74	import javax.swing.DefaultListModel;
76	import javax.swing.JButton;	75	import javax.swing.JButton;
77	import javax.swing.ListCellRenderer;	76	import javax.swing.ListCellRenderer;
Lines 87-92 Link Here
87	import org.netbeans.api.project.ui.OpenProjects;	86	import org.netbeans.api.project.ui.OpenProjects;
88	import org.netbeans.modules.jumpto.EntitiesListCellRenderer;	87	import org.netbeans.modules.jumpto.EntitiesListCellRenderer;
89	import org.netbeans.modules.jumpto.file.LazyListModel;	88	import org.netbeans.modules.jumpto.file.LazyListModel;
		89	import org.netbeans.modules.sampler.Sampler;
90	import org.openide.DialogDescriptor;	90	import org.openide.DialogDescriptor;
91	import org.openide.DialogDisplayer;	91	import org.openide.DialogDisplayer;
92	import org.openide.ErrorManager;	92	import org.openide.ErrorManager;
Lines 774-788 Link Here
774	return null;	774	return null;
775	}	775	}
776		776
777	FileObject fo = FileUtil.getConfigFile("Actions/Profile/org-netbeans-modules-profiler-actions-SelfSamplerAction.instance"); //NOI18N	777	Sampler profiler = Sampler.getSampler("logger-jumpto"); //NOI18N
778	if (fo == null) {
779	return null;
780	}
781	Action a = (Action)fo.getAttribute("delegate"); // NOI18N
782	if (a == null) {
783	return null;
784	}
785	Object profiler = a.getValue("logger-jumpto"); //NOI18N
786	if (profiler == null) {	778	if (profiler == null) {
787	return null;	779	return null;
788	}	780	}
Lines 791-800 Link Here
791		783
792	private class Profile implements Runnable {	784	private class Profile implements Runnable {
793	private final long time;	785	private final long time;
794	private volatile Object profiler;	786	private volatile Sampler profiler;
795	private volatile boolean profiling;	787	private volatile boolean profiling;
796		788
797	public Profile(Object profiler) {	789	public Profile(Sampler profiler) {
798	time = System.currentTimeMillis();	790	time = System.currentTimeMillis();
799	this.profiler = profiler;	791	this.profiler = profiler;
800	}	792	}
Lines 807-822 Link Here
807	@Override	799	@Override
808	public synchronized void run() {	800	public synchronized void run() {
809	profiling = true;	801	profiling = true;
810	if (profiler instanceof Runnable) {	802	profiler.start();
811	Runnable r = (Runnable)profiler;
812	r.run();
813	}
814	}	803	}
815		804
816	private synchronized void stop() throws Exception {	805	private synchronized void stop() throws Exception {
817	long delta = System.currentTimeMillis() - time;	806	long delta = System.currentTimeMillis() - time;
818		807
819	ActionListener ss = (ActionListener)profiler;	808	Sampler ss = profiler;
820	profiler = null;	809	profiler = null;
821	if (!profiling) {	810	if (!profiling) {
822	return;	811	return;
Lines 824-830 Link Here
824	try {	813	try {
825	ByteArrayOutputStream out = new ByteArrayOutputStream();	814	ByteArrayOutputStream out = new ByteArrayOutputStream();
826	DataOutputStream dos = new DataOutputStream(out);	815	DataOutputStream dos = new DataOutputStream(out);
827	ss.actionPerformed(new ActionEvent(dos, 0, "write")); // NOI18N	816	ss.stopAndWriteTo(dos);
828	dos.close();	817	dos.close();
829	if (dos.size() > 0) {	818	if (dos.size() > 0) {
830	Object[] params = new Object[]{out.toByteArray(), delta, "GoToType" }; //NOI18N	819	Object[] params = new Object[]{out.toByteArray(), delta, "GoToType" }; //NOI18N

Lines 77-82 Link Here

(-)a/core.ui/nbproject/project.xml (-5 / +8 lines)
77	</run-dependency>	77	</run-dependency>
78	</dependency>	78	</dependency>
79	<dependency>	79	<dependency>
		80	<code-name-base>org.netbeans.modules.sampler</code-name-base>
		81	<build-prerequisite/>
		82	<compile-dependency/>
		83	<run-dependency>
		84	<specification-version>1.0</specification-version>
		85	</run-dependency>
		86	</dependency>
		87	<dependency>
80	<code-name-base>org.netbeans.spi.quicksearch</code-name-base>	88	<code-name-base>org.netbeans.spi.quicksearch</code-name-base>
81	<build-prerequisite/>	89	<build-prerequisite/>
82	<compile-dependency/>	90	<compile-dependency/>
Lines 180-190 Link Here
180	<code-name-base>org.netbeans.libs.junit4</code-name-base>	188	<code-name-base>org.netbeans.libs.junit4</code-name-base>
181	<compile-dependency/>	189	<compile-dependency/>
182	</test-dependency>	190	</test-dependency>
183	<test-dependency>
184	<code-name-base>org.netbeans.modules.nbjunit</code-name-base>
185	<recursive/>
186	<compile-dependency/>
187	</test-dependency>
188	</test-type>	191	</test-type>
189	</test-dependencies>	192	</test-dependencies>
190	<public-packages/>	193	<public-packages/>

Lines 43-57 Link Here

(-)a/editor.completion/src/org/netbeans/modules/editor/completion/CompletionImplProfile.java (-24 / +10 lines)
43	*/	43	*/
44	package org.netbeans.modules.editor.completion;	44	package org.netbeans.modules.editor.completion;
45		45
46	import java.awt.event.ActionEvent;
47	import java.awt.event.ActionListener;
48	import java.io.ByteArrayOutputStream;	46	import java.io.ByteArrayOutputStream;
49	import java.io.DataOutputStream;	47	import java.io.DataOutputStream;
50	import java.util.logging.Level;	48	import java.util.logging.Level;
51	import java.util.logging.Logger;	49	import java.util.logging.Logger;
52	import javax.swing.Action;	50	import org.netbeans.modules.sampler.Sampler;
53	import org.openide.filesystems.FileObject;
54	import org.openide.filesystems.FileUtil;
55	import org.openide.util.Exceptions;	51	import org.openide.util.Exceptions;
56	import org.openide.util.RequestProcessor;	52	import org.openide.util.RequestProcessor;
57		53
Lines 59-85 Link Here
59	private static final Logger LOG = Logger.getLogger(CompletionImplProfile.class.getName());	55	private static final Logger LOG = Logger.getLogger(CompletionImplProfile.class.getName());
60	static final RequestProcessor RP = new RequestProcessor("Completion Slowness"); // NOI18N	56	static final RequestProcessor RP = new RequestProcessor("Completion Slowness"); // NOI18N
61		57
62	private final Object profiler;	58	private final Sampler profiler;
63	private boolean profiling;	59	private boolean profiling;
64	private final long time;	60	private final long time;
65		61
66	CompletionImplProfile(long when) {	62	CompletionImplProfile(long when) {
67	time = when;	63	time = when;
68		64
69	Object p = null;	65	this.profiler = Sampler.getSampler("logger-completion"); // NOI18N
70	FileObject fo = FileUtil.getConfigFile("Actions/Profile/org-netbeans-modules-profiler-actions-SelfSamplerAction.instance"); // NOI18N
71	if (fo != null) {
72	Action a = (Action) fo.getAttribute("delegate"); // NOI18N
73	if (a != null) {
74	p = a.getValue("logger-completion"); // NOI18N
75	}
76	}
77	this.profiler = p;
78	this.profiling = true;	66	this.profiling = true;
79		67
80	if (profiler instanceof Runnable) {	68	if (profiler != null) {
81	Runnable r = (Runnable) profiler;	69	profiler.start();
82	r.run();
83	LOG.log(Level.FINE, "Profiling started {0} at {1}", new Object[] { profiler, time });	70	LOG.log(Level.FINE, "Profiling started {0} at {1}", new Object[] { profiler, time });
84	}	71	}
85	}	72	}
Lines 106-117 Link Here
106	private void stopImpl(long now) throws Exception {	93	private void stopImpl(long now) throws Exception {
107	long delta = now - time;	94	long delta = now - time;
108	LOG.log(Level.FINE, "Profiling stopped at {0}", now);	95	LOG.log(Level.FINE, "Profiling stopped at {0}", now);
109	ActionListener ss = (ActionListener) profiler;
110	int report = Integer.getInteger("org.netbeans.modules.editor.completion.slowness.report", 2000); // NOI18N	96	int report = Integer.getInteger("org.netbeans.modules.editor.completion.slowness.report", 2000); // NOI18N
111	if (delta < report) {	97	if (delta < report) {
112	LOG.log(Level.FINE, "Cancel profiling of {0}. Profiling {1}. Time {2} ms.", new Object[] { ss, profiling, delta });	98	LOG.log(Level.FINE, "Cancel profiling of {0}. Profiling {1}. Time {2} ms.", new Object[] { profiler, profiling, delta });
113	if (ss != null) {	99	if (profiler != null) {
114	ss.actionPerformed(new ActionEvent(this, 0, "cancel"));	100	profiler.cancel();
115	}	101	}
116	return;	102	return;
117	}	103	}
Lines 119-126 Link Here
119	LOG.log(Level.FINE, "Obtaining snapshot for {0} ms.", delta);	105	LOG.log(Level.FINE, "Obtaining snapshot for {0} ms.", delta);
120	ByteArrayOutputStream out = new ByteArrayOutputStream();	106	ByteArrayOutputStream out = new ByteArrayOutputStream();
121	DataOutputStream dos = new DataOutputStream(out);	107	DataOutputStream dos = new DataOutputStream(out);
122	if (ss != null) {	108	if (profiler != null) {
123	ss.actionPerformed(new ActionEvent(dos, 0, "write")); // NOI18N	109	profiler.stopAndWriteTo(dos);
124	}	110	}
125	dos.close();	111	dos.close();
126	if (dos.size() > 0) {	112	if (dos.size() > 0) {

Lines 77-83 Link Here

(-)a/ide.kit/test/qa-functional/src/org/netbeans/test/ide/BlacklistedClassesHandlerSingleton.java (-3 / +3 lines)
77	import java.util.logging.Level;	77	import java.util.logging.Level;
78	import java.util.logging.LogRecord;	78	import java.util.logging.LogRecord;
79	import java.util.logging.Logger;	79	import java.util.logging.Logger;
80	import org.netbeans.core.ui.sampler.SamplesOutputStream;	80	import org.netbeans.modules.sampler.CustomSamplesStream;
81	import org.openide.util.Exceptions;	81	import org.openide.util.Exceptions;
82		82
83	/**	83	/**
Lines 114-120 Link Here
114	private String newWhitelistFileName;	114	private String newWhitelistFileName;
115	private String previousWhitelistFileName = null;	115	private String previousWhitelistFileName = null;
116	private File whitelistStorageDir = null;	116	private File whitelistStorageDir = null;
117	private SamplesOutputStream samples;	117	private CustomSamplesStream samples;
118	private ByteArrayOutputStream stream;	118	private ByteArrayOutputStream stream;
119	private ThreadMXBean threadBean;	119	private ThreadMXBean threadBean;
120	private long start;	120	private long start;
Lines 176-182 Link Here
176	start = System.currentTimeMillis();	176	start = System.currentTimeMillis();
177	stream = new ByteArrayOutputStream();	177	stream = new ByteArrayOutputStream();
178	try {	178	try {
179	samples = new SamplesOutputStream(stream, null, 5000);	179	samples = new CustomSamplesStream(stream, 5000);
180	} catch (IOException ex) {	180	} catch (IOException ex) {
181	throw new RuntimeException(ex);	181	throw new RuntimeException(ex);
182	}	182	}

Lines 50-67 Link Here

(-)a/o.n.core/src/org/netbeans/core/TimableEventQueue.java (-23 / +11 lines)
50	import java.awt.KeyboardFocusManager;	50	import java.awt.KeyboardFocusManager;
51	import java.awt.Toolkit;	51	import java.awt.Toolkit;
52	import java.awt.Window;	52	import java.awt.Window;
53	import java.awt.event.ActionEvent;
54	import java.awt.event.ActionListener;
55	import java.io.ByteArrayOutputStream;	53	import java.io.ByteArrayOutputStream;
56	import java.io.DataOutputStream;	54	import java.io.DataOutputStream;
57	import java.util.logging.Level;	55	import java.util.logging.Level;
58	import java.util.logging.Logger;	56	import java.util.logging.Logger;
59	import javax.swing.Action;
60	import javax.swing.JFrame;	57	import javax.swing.JFrame;
61	import javax.swing.JRootPane;	58	import javax.swing.JRootPane;
62	import javax.swing.SwingUtilities;	59	import javax.swing.SwingUtilities;
63	import org.openide.filesystems.FileObject;	60	import org.netbeans.modules.sampler.Sampler;
64	import org.openide.filesystems.FileUtil;
65	import org.openide.util.Exceptions;	61	import org.openide.util.Exceptions;
66	import org.openide.util.Lookup;	62	import org.openide.util.Lookup;
67	import org.openide.util.Mutex;	63	import org.openide.util.Mutex;
Lines 97-103 Link Here
97	private final RequestProcessor.Task WAIT_CURSOR_CHECKER;	93	private final RequestProcessor.Task WAIT_CURSOR_CHECKER;
98	private volatile long ignoreTill;	94	private volatile long ignoreTill;
99	private volatile long start;	95	private volatile long start;
100	private volatile ActionListener stoppable;	96	private volatile Sampler stoppable;
101	private volatile boolean isWaitCursor;	97	private volatile boolean isWaitCursor;
102	static volatile Thread eq;	98	static volatile Thread eq;
103	private final Frame mainWindow;	99	private final Frame mainWindow;
Lines 197-205 Link Here
197	} else {	193	} else {
198	LOG.log(Level.FINEST, "done, timer stopped, took {0}", time);	194	LOG.log(Level.FINEST, "done, timer stopped, took {0}", time);
199	}	195	}
200	ActionListener ss = stoppable;	196	Sampler ss = stoppable;
201	if (ss != null) {	197	if (ss != null) {
202	ss.actionPerformed(new ActionEvent(this, 0, "cancel")); // NOI18N	198	ss.cancel();
203	stoppable = null;	199	stoppable = null;
204	}	200	}
205	return;	201	return;
Lines 225-234 Link Here
225	LOG.log(Level.WARNING, "Still previous controller {0}", stoppable);	221	LOG.log(Level.WARNING, "Still previous controller {0}", stoppable);
226	return;	222	return;
227	}	223	}
228	Runnable selfSampler = (Runnable)createSelfSampler();	224	Sampler selfSampler = createSelfSampler();
229	if (selfSampler != null) {	225	if (selfSampler != null) {
230	selfSampler.run();	226	selfSampler.start();
231	stoppable = (ActionListener)selfSampler;	227	stoppable = selfSampler;
232	}	228	}
233	isWaitCursor \|= isWaitCursor();	229	isWaitCursor \|= isWaitCursor();
234	if (!isWaitCursor) {	230	if (!isWaitCursor) {
Lines 236-242 Link Here
236	}	232	}
237	}	233	}
238		234
239	private static void report(final ActionListener ss, final long time) {	235	private static void report(final Sampler ss, final long time) {
240	if (ss == null) {	236	if (ss == null) {
241	return;	237	return;
242	}	238	}
Lines 246-252 Link Here
246	try {	242	try {
247	ByteArrayOutputStream out = new ByteArrayOutputStream();	243	ByteArrayOutputStream out = new ByteArrayOutputStream();
248	DataOutputStream dos = new DataOutputStream(out);	244	DataOutputStream dos = new DataOutputStream(out);
249	ss.actionPerformed(new ActionEvent(dos, 0, "write")); // NOI18N	245	ss.stopAndWriteTo(dos);
250	dos.close();	246	dos.close();
251	if (dos.size() > 0) {	247	if (dos.size() > 0) {
252	Object[] params = new Object[]{out.toByteArray(), time};	248	Object[] params = new Object[]{out.toByteArray(), time};
Lines 262-277 Link Here
262	RP.post(new R());	258	RP.post(new R());
263	}	259	}
264		260
265	private static Object createSelfSampler() {	261	private static Sampler createSelfSampler() {
266	FileObject fo = FileUtil.getConfigFile("Actions/Profile/org-netbeans-modules-profiler-actions-SelfSamplerAction.instance");	262	return Sampler.getSampler("logger-awt"); // NOI18N
267	if (fo == null) {
268	return null;
269	}
270	Action a = (Action)fo.getAttribute("delegate"); // NOI18N
271	if (a == null) {
272	return null;
273	}
274	return a.getValue("logger-awt"); // NOI18N
275	}	263	}
276		264
277	private static boolean isWaitCursor() {	265	private static boolean isWaitCursor() {

Lines 41-55 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/SelfProfile.java (-29 / +12 lines)
41	*/	41	*/
42	package org.netbeans.modules.parsing.impl;	42	package org.netbeans.modules.parsing.impl;
43		43
44	import java.awt.event.ActionEvent;
45	import java.awt.event.ActionListener;
46	import java.io.ByteArrayOutputStream;	44	import java.io.ByteArrayOutputStream;
47	import java.io.DataOutputStream;	45	import java.io.DataOutputStream;
48	import java.util.logging.Level;	46	import java.util.logging.Level;
49	import java.util.logging.Logger;	47	import java.util.logging.Logger;
50	import javax.swing.Action;	48	import org.netbeans.modules.sampler.Sampler;
51	import org.openide.filesystems.FileObject;
52	import org.openide.filesystems.FileUtil;
53	import org.openide.util.Exceptions;	49	import org.openide.util.Exceptions;
54		50
55	/**	51	/**
Lines 58-85 Link Here
58	*/	54	*/
59	final class SelfProfile {	55	final class SelfProfile {
60	private static final Logger LOG = Logger.getLogger(SelfProfile.class.getName());	56	private static final Logger LOG = Logger.getLogger(SelfProfile.class.getName());
61		57
62	private final Object profiler;	58	private final Sampler profiler;
63	private final long time;	59	private final long time;
64	private volatile boolean profiling;	60	private volatile boolean profiling;
65		61
66	SelfProfile (long when) {	62	SelfProfile (long when) {
67	time = when;	63	time = when;
68	Object p = null;	64	this.profiler = Sampler.getSampler("logger-taskcancel"); // NOI18N;
69	final FileObject fo = FileUtil.getConfigFile("Actions/Profile/org-netbeans-modules-profiler-actions-SelfSamplerAction.instance"); // NOI18N
70	if (fo != null) {
71	final Action a = (Action) fo.getAttribute("delegate"); // NOI18N
72	if (a != null) {
73	p = a.getValue("logger-taskcancel"); // NOI18N
74	}
75	}
76	this.profiler = p;
77	this.profiling = true;	65	this.profiling = true;
78		66
79	LOG.finest("STARTED"); //NOI18N	67	if (profiler != null) {
80	if (profiler instanceof Runnable) {	68	profiler.start();
81	final Runnable r = (Runnable) profiler;
82	r.run();
83	LOG.log(Level.FINE, "Profiling started {0} at {1}", new Object[] { profiler, time }); //NOI18N	69	LOG.log(Level.FINE, "Profiling started {0} at {1}", new Object[] { profiler, time }); //NOI18N
84	}	70	}
85	}	71	}
Lines 101-123 Link Here
101	final long now = System.currentTimeMillis();	87	final long now = System.currentTimeMillis();
102	long delta = now - time;	88	long delta = now - time;
103	LOG.log(Level.FINE, "Profiling stopped at {0}", now);	89	LOG.log(Level.FINE, "Profiling stopped at {0}", now);
104	ActionListener ss = (ActionListener) profiler;
105	int report = Integer.getInteger("org.netbeans.modules.parsing.api.taskcancel.slowness.report", 1000); // NOI18N	90	int report = Integer.getInteger("org.netbeans.modules.parsing.api.taskcancel.slowness.report", 1000); // NOI18N
106	if (delta < report) {	91	if (delta < report) {
107	LOG.finest("CANCEL"); //NOI18N	92	LOG.log(Level.FINE, "Cancel profiling of {0}. Profiling {1}. Time {2} ms.", new Object[] { profiler, profiling, delta });
108	if (ss != null) {	93	if (profiler != null) {
109	ss.actionPerformed(new ActionEvent(this, 0, "cancel"));	94	profiler.cancel();
110	LOG.log(Level.FINE, "Cancel profiling of {0}. Profiling {1}. Time {2} ms.", new Object[] { ss, profiling, delta });
111	}	95	}
112	return;	96	return;
113	}	97	}
114	try {	98	try {
		99	LOG.log(Level.FINE, "Obtaining snapshot for {0} ms.", delta);
115	ByteArrayOutputStream out = new ByteArrayOutputStream();	100	ByteArrayOutputStream out = new ByteArrayOutputStream();
116	DataOutputStream dos = new DataOutputStream(out);	101	DataOutputStream dos = new DataOutputStream(out);
117	LOG.finest("LOGGED"); //NOI18N	102	if (profiler != null) {
118	if (ss != null) {	103	profiler.stopAndWriteTo(dos);
119	ss.actionPerformed(new ActionEvent(dos, 0, "write")); // NOI18N
120	LOG.log(Level.FINE, "Obtaining snapshot for {0} ms.", delta); //NOI18N
121	}	104	}
122	dos.close();	105	dos.close();
123	if (dos.size() > 0) {	106	if (dos.size() > 0) {

Line 0 Link Here

(-)a/sampler/apichanges.xml (+80 lines)
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<!--
		3	DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		4
		5	Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
		6
		7	Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		8	Other names may be trademarks of their respective owners.
		9
		10
		11	The contents of this file are subject to the terms of either the GNU
		12	General Public License Version 2 only ("GPL") or the Common
		13	Development and Distribution License("CDDL") (collectively, the
		14	"License"). You may not use this file except in compliance with the
		15	License. You can obtain a copy of the License at
		16	http://www.netbeans.org/cddl-gplv2.html
		17	or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		18	specific language governing permissions and limitations under the
		19	License. When distributing the software, include this License Header
		20	Notice in each file and include the License file at
		21	nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		22	particular file as subject to the "Classpath" exception as provided
		23	by Oracle in the GPL Version 2 section of the License file that
		24	accompanied this code. If applicable, add the following below the
		25	License Header, with the fields enclosed by brackets [] replaced by
		26	your own identifying information:
		27	"Portions Copyrighted [year] [name of copyright owner]"
		28
		29	Contributor(s):
		30
		31	The Original Software is NetBeans. The Initial Developer of the Original
		32	Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
		33	Microsystems, Inc. All Rights Reserved.
		34
		35	If you wish your version of this file to be governed by only the CDDL
		36	or only the GPL Version 2, indicate your decision by adding
		37	"[Contributor] elects to include this software in this distribution
		38	under the [CDDL or GPL Version 2] license." If you do not indicate a
		39	single choice of license, a recipient has the option to distribute
		40	your version of this file under either the CDDL, the GPL Version 2 or
		41	to extend the choice of license to its licensees as provided above.
		42	However, if you add GPL Version 2 code and therefore, elected the GPL
		43	Version 2 license, then the option applies only if the new code is
		44	made subject to such option by the copyright holder.
		45	-->
		46
		47	<!DOCTYPE apichanges PUBLIC "-//NetBeans//DTD API changes list 1.0//EN" "../nbbuild/javadoctools/apichanges.dtd">
		48
		49	<apichanges>
		50	<apidefs>
		51	<apidef name="sampler">Sampler API</apidef>
		52	</apidefs>
		53	<changes>
		54	</changes>
		55	<htmlcontents>
		56	<head>
		57	<title>Change History for the Sampler API</title>
		58	<link rel="stylesheet" href="prose.css" type="text/css"/>
		59	</head>
		60	<body>
		61	<p class="overviewlink">
		62	<a href="overview-summary.html">Overview</a>
		63	</p>
		64	<h1>Introduction</h1>
65	<h2>What do the Dates Mean?</h2>
66	<p>The supplied dates indicate when the API change was made, on the HG
67	default branch. From this you can generally tell whether the change should be
68	present in a given build or not; for trunk builds, simply whether it
69	was made before or after the change; for builds on a stabilization
70	branch, whether the branch was made before or after the given date. In
71	some cases corresponding API changes have been made both in the trunk
72	and in an in-progress stabilization branch, if they were needed for a
73	bug fix; this ought to be marked in this list.</p>
74	<hr/>
75	<standard-changelists module-code-name="$codebase"/>
76	<hr/>
77	<p>@FOOTER@</p>
78	</body>
79	</htmlcontents>
80	</apichanges>

Line 0 Link Here

(-)a/sampler/nbproject/project.xml (+109 lines)
		1	<?xml version="1.0" encoding="UTF-8"?>
		2	<project xmlns="http://www.netbeans.org/ns/project/1">
		3	<type>org.netbeans.modules.apisupport.project</type>
		4	<configuration>
		5	<data xmlns="http://www.netbeans.org/ns/nb-module-project/3">
		6	<code-name-base>org.netbeans.modules.sampler</code-name-base>
		7	<module-dependencies>
		8	<dependency>
		9	<code-name-base>org.netbeans.api.annotations.common</code-name-base>
		10	<build-prerequisite/>
		11	<compile-dependency/>
		12	<run-dependency>
		13	<release-version>1</release-version>
		14	<specification-version>1.13</specification-version>
		15	</run-dependency>
		16	</dependency>
		17	<dependency>
		18	<code-name-base>org.netbeans.api.progress</code-name-base>
		19	<build-prerequisite/>
		20	<compile-dependency/>
		21	<run-dependency>
		22	<release-version>1</release-version>
		23	<specification-version>1.27</specification-version>
		24	</run-dependency>
		25	</dependency>
		26	<dependency>
		27	<code-name-base>org.openide.awt</code-name-base>
		28	<build-prerequisite/>
		29	<compile-dependency/>
		30	<run-dependency>
		31	<specification-version>7.40</specification-version>
		32	</run-dependency>
		33	</dependency>
		34	<dependency>
		35	<code-name-base>org.openide.dialogs</code-name-base>
		36	<build-prerequisite/>
		37	<compile-dependency/>
		38	<run-dependency>
		39	<specification-version>7.24</specification-version>
		40	</run-dependency>
		41	</dependency>
		42	<dependency>
		43	<code-name-base>org.openide.filesystems</code-name-base>
		44	<build-prerequisite/>
		45	<compile-dependency/>
		46	<run-dependency>
		47	<specification-version>7.55</specification-version>
		48	</run-dependency>
		49	</dependency>
		50	<dependency>
		51	<code-name-base>org.openide.loaders</code-name-base>
		52	<build-prerequisite/>
		53	<compile-dependency/>
		54	<run-dependency>
		55	<specification-version>7.33</specification-version>
		56	</run-dependency>
		57	</dependency>
		58	<dependency>
		59	<code-name-base>org.openide.nodes</code-name-base>
		60	<build-prerequisite/>
		61	<compile-dependency/>
		62	<run-dependency>
		63	<specification-version>7.26</specification-version>
		64	</run-dependency>
65	</dependency>
66	<dependency>
67	<code-name-base>org.openide.util</code-name-base>
68	<build-prerequisite/>
69	<compile-dependency/>
70	<run-dependency>
71	<specification-version>8.20</specification-version>
72	</run-dependency>
73	</dependency>
74	<dependency>
75	<code-name-base>org.openide.util.lookup</code-name-base>
76	<build-prerequisite/>
77	<compile-dependency/>
78	<run-dependency>
79	<specification-version>8.12</specification-version>
80	</run-dependency>
81	</dependency>
82	</module-dependencies>
83	<test-dependencies>
84	<test-type>
85	<name>unit</name>
86	<test-dependency>
87	<code-name-base>org.netbeans.insane</code-name-base>
88	<compile-dependency/>
89	</test-dependency>
90	<test-dependency>
91	<code-name-base>org.netbeans.libs.junit4</code-name-base>
92	<compile-dependency/>
93	</test-dependency>
94	<test-dependency>
95	<code-name-base>org.netbeans.modules.nbjunit</code-name-base>
96	<compile-dependency/>
97	</test-dependency>
98	<test-dependency>
99	<code-name-base>org.openide.dialogs</code-name-base>
100	<compile-dependency/>
101	</test-dependency>
102	</test-type>
103	</test-dependencies>
104	<public-packages>
105	<package>org.netbeans.modules.sampler</package>
106	</public-packages>
107	</data>
108	</configuration>
109	</project>

Line 0 Link Here

(-)a/sampler/src/org/netbeans/modules/sampler/CLISampler.java (+161 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.sampler;
		43
		44	import java.io.File;
		45	import java.io.FileOutputStream;
		46	import java.io.IOException;
		47	import java.lang.management.ManagementFactory;
		48	import java.lang.management.ThreadMXBean;
		49	import javax.management.MBeanServerConnection;
		50	import javax.management.remote.JMXConnector;
		51	import javax.management.remote.JMXConnectorFactory;
		52	import javax.management.remote.JMXServiceURL;
		53
		54	/**
		55	* Support for sampling from command line
		56	*
		57	* @author Tomas Hurka, Jaroslav Tulach
		58	*
		59	*/
		60	class CLISampler extends Sampler {
		61
		62	private final ThreadMXBean threadMXBean;
		63	private final File output;
		64
65	public static void main(String... args) throws Exception {
66	if (args.length != 2) {
67	System.out.println("Usage: <port> <snapshot.npss>");
68	System.out.println();
69	System.out.println("First of all start your application with following parameters:");
70	System.out.println(" -Dcom.sun.management.jmxremote.authenticate=false");
71	System.out.println(" -Dcom.sun.management.jmxremote.ssl=false");
72	System.out.println(" -Dcom.sun.management.jmxremote.port=<port>");
73	System.out.println("Then you can start this sampler with correct port and file to write snapshot to.");
74	System.exit(1);
75	}
76	if (!SamplesOutputStream.isSupported()) {
77	System.err.println("Sampling is not supported by JVM");
78	System.exit(2);
79	}
80
81	String u = args[0];
82	try {
83	u = "service:jmx:rmi:///jndi/rmi://localhost:" + Integer.parseInt(args[0]) + "/jmxrmi";
84	} catch (NumberFormatException ex) {
85	// OK, use args[0]
86	}
87
88	System.err.println("Connecting to " + u);
89	JMXServiceURL url = new JMXServiceURL(u);
90	JMXConnector jmxc = null;
91	Exception ex = null;
92	for (int i = 0; i < 100; i++) {
93	try {
94	jmxc = JMXConnectorFactory.connect(url, null);
95	break;
96	} catch (IOException e) {
97	ex = e;
98	System.err.println("Connection failed. Will retry in 300ms.");
99	Thread.sleep(300);
100	}
101	}
102	if (jmxc == null) {
103	ex.printStackTrace();
104	System.err.println("Cannot connect to " + u);
105	System.exit(3);
106	}
107	MBeanServerConnection server = jmxc.getMBeanServerConnection();
108
109	final ThreadMXBean threadMXBean = ManagementFactory.newPlatformMXBeanProxy(
110	server, ManagementFactory.THREAD_MXBEAN_NAME, ThreadMXBean.class);
111	final File output = new File(args[1]);
112
113
114	CLISampler s = new CLISampler(threadMXBean, output);
115	s.start();
116	System.out.println("Press enter to generate sample into " + output);
117	System.in.read();
118	s.stop();
119	System.out.println();
120	System.out.println("Sample written to " + output);
121	System.exit(0);
122	}
123
124	private CLISampler(ThreadMXBean threadBean, File out) {
125	super("CLISampler");
126	threadMXBean = threadBean;
127	output = out;
128	}
129
130	@Override
131	protected ThreadMXBean getThreadMXBean() {
132	return threadMXBean;
133	}
134
135	@Override
136	protected void saveSnapshot(byte[] arr) throws IOException {
137	FileOutputStream os = new FileOutputStream(output);
138	os.write(arr);
139	os.close();
140	}
141
142	@Override
143	protected void printStackTrace(Throwable ex) {
144	ex.printStackTrace();
145	System.exit(2);
146	}
147
148	@Override
149	protected void openProgress(int steps) {
150	}
151
152	@Override
153	protected void closeProgress() {
154	}
155
156	@Override
157	protected void progress(int i) {
158	System.out.print("#");
159	System.out.flush();
160	}
161	}

Lines 39-70 Link Here

(-)a/core.ui/src/org/netbeans/core/ui/sampler/Sampler.java (-126 / +92 lines)
39	*	39	*
40	* Portions Copyrighted 2008 Sun Microsystems, Inc.	40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
41	*/	41	*/
42	package org.netbeans.core.ui.sampler;	42	package org.netbeans.modules.sampler;
43		43
44	import java.awt.event.ActionEvent;
45	import java.awt.event.ActionListener;
46	import java.io.ByteArrayOutputStream;	44	import java.io.ByteArrayOutputStream;
47	import java.io.DataOutputStream;	45	import java.io.DataOutputStream;
48	import java.io.File;
49	import java.io.FileOutputStream;
50	import java.io.IOException;	46	import java.io.IOException;
51	import java.lang.management.ManagementFactory;
52	import java.lang.management.ThreadInfo;	47	import java.lang.management.ThreadInfo;
53	import java.lang.management.ThreadMXBean;	48	import java.lang.management.ThreadMXBean;
54	import java.util.Timer;	49	import java.util.Timer;
55	import java.util.TimerTask;	50	import java.util.TimerTask;
56	import java.util.logging.Level;	51	import java.util.logging.Level;
57	import java.util.logging.Logger;	52	import java.util.logging.Logger;
58	import javax.management.MBeanServerConnection;	53	import javax.swing.SwingUtilities;
59	import javax.management.remote.JMXConnector;	54	import org.netbeans.api.annotations.common.CheckForNull;
60	import javax.management.remote.JMXConnectorFactory;	55	import org.netbeans.api.annotations.common.NonNull;
61	import javax.management.remote.JMXServiceURL;
62		56
63	/**	57	/**
64	*	58	* Sampler class provides API for self-sampling of NetBeans
		59	* platform application. The self-sampling should be used for
		60	* diagnostic purposes and should help NetBeans platform developers
		61	* with solving CPU related performance problems. Sampled data are
		62	* stored in NPSS file, which can be opened by NetBeans Profiler or
		63	* Java VisualVM for later analysis of sampled data.
		64	*
65	* @author Jaroslav Bachorik, Tomas Hurka, Jaroslav Tulach	65	* @author Jaroslav Bachorik, Tomas Hurka, Jaroslav Tulach
66	*/	66	*/
67	abstract class Sampler implements Runnable, ActionListener {	67	public abstract class Sampler {
68	private static final int SAMPLER_RATE = 10;	68	private static final int SAMPLER_RATE = 10;
69	private static final double MAX_AVERAGE = SAMPLER_RATE * 3;	69	private static final double MAX_AVERAGE = SAMPLER_RATE * 3;
70	private static final double MAX_STDDEVIATION = SAMPLER_RATE * 4;	70	private static final double MAX_STDDEVIATION = SAMPLER_RATE * 4;
Lines 87-92 Link Here
87	private volatile boolean stopped;	87	private volatile boolean stopped;
88	private volatile boolean running;	88	private volatile boolean running;
89		89
		90	/**
		91	* Factory method for creating Sampler suitable for automatic reporting
		92	* of the slow operation (i.e. AWT blocked for some time). This method can
		93	* return <code>null</code> if the sampled application is in nonstandard mode
		94	* which will produce unrealistic data - for example application is
		95	* running under debugger or profiler.
		96	* @param name which identifies the sampler thread
		97	* @return instance of the {@link Sampler} or <code>null</code> if application
		98	* is in nonstandard mode.
		99	*/
		100	public static @CheckForNull Sampler getSampler(@NonNull String name) {
		101	return InternalSampler.getInternalSampler(name);
		102	}
		103
		104	/**
		105	* Factory method for creating Sampler suitable for manual or user invoked
		106	* scanning. This method can return <code>null</code> if it is running on
		107	* some exotic variant of JDK, where sampling is not supported.
		108	* @param name which identifies the sampler thread
		109	* @return instance of the {@link Sampler} or <code>null</code> if sampling
		110	* is not supported.
		111	*/
		112	public static @CheckForNull Sampler getGenericSampler(@NonNull String name) {
		113	if (SamplesOutputStream.isSupported()) {
		114	return new InternalSampler(name);
		115	}
		116	return null;
		117	}
		118
90	Sampler(String n) {	119	Sampler(String n) {
91	name = n;	120	name = n;
92	}	121	}
Lines 94-118 Link Here
94	/** Returns the bean to use for sampling.	123	/** Returns the bean to use for sampling.
95	* @return instance of the bean to take thread dumps from	124	* @return instance of the bean to take thread dumps from
96	*/	125	*/
97	protected abstract ThreadMXBean getThreadMXBean();	126	abstract ThreadMXBean getThreadMXBean();
98		127
99	/** Allows subclasses to handle created snapshot	128	/** Allows subclasses to handle created snapshot
100	* @param arr the content of the snapshot	129	* @param arr the content of the snapshot
101	* @throws IOException thrown in case of I/O error	130	* @throws IOException thrown in case of I/O error
102	*/	131	*/
103	protected abstract void saveSnapshot(byte[] arr) throws IOException;	132	abstract void saveSnapshot(byte[] arr) throws IOException;
104		133
105	/** How to report an exception.	134	/** How to report an exception.
106	*	135	*
107	* @param ex exception	136	* @param ex exception
108	*/	137	*/
109	protected abstract void printStackTrace(Throwable ex);	138	abstract void printStackTrace(Throwable ex);
110		139
111	/** Methods for displaying progress.	140	/** Methods for displaying progress.
112	*/	141	*/
113	protected abstract void openProgress(int steps);	142	abstract void openProgress(int steps);
114	protected abstract void closeProgress();	143	abstract void closeProgress();
115	protected abstract void progress(int i);	144	abstract void progress(int i);
116		145
117	private void updateStats(long timestamp) {	146	private void updateStats(long timestamp) {
118	if (laststamp != 0) {	147	if (laststamp != 0) {
Lines 129-137 Link Here
129	laststamp = timestamp;	158	laststamp = timestamp;
130	}	159	}
131		160
132	@Override	161	/**
133	public synchronized void run() {	162	* Start self-sampling. This method starts timer identified by <code>name</code>
134	assert !running;	163	* for actual sampling and returns immediately.
		164	*/
		165	public synchronized void start() {
		166	if (running) throw new IllegalStateException("sampling is already running"); // NOI18N
		167	if (stopped) throw new IllegalStateException("it is not possible to restart sampling"); // NOI18N
135	running = true;	168	running = true;
136	final ThreadMXBean threadBean = getThreadMXBean();	169	final ThreadMXBean threadBean = getThreadMXBean();
137	out = new ByteArrayOutputStream(64 * 1024);	170	out = new ByteArrayOutputStream(64 * 1024);
Lines 165-185 Link Here
165	}, SAMPLER_RATE, SAMPLER_RATE);	198	}, SAMPLER_RATE, SAMPLER_RATE);
166	}	199	}
167		200
168	@Override	201	/**
169	public synchronized void actionPerformed(ActionEvent e) {	202	* Cancels the self-sampling. All sampled data are discarded.
		203	*/
		204	public void cancel() {
		205	stopSampling(true, null);
		206	}
		207
		208	/**
		209	* Stop the self-sampling started by {@link #start()} method and writes the data to
		210	* {@link DataOutputStream}. If the internal sampling logic detects that
		211	* the data are distorted for example due to heavy system I/O, collected
		212	* samples are discarded and nothing is written to {@link DataOutputStream}.
		213	* <br>
		214	* This method can take a long time and should not be invoked from EDT.
		215	* @param dos {@link DataOutputStream} where sampled data is written to.
		216	*/
		217	public void stopAndWriteTo(@NonNull DataOutputStream dos) {
		218	stopSampling(false, dos);
		219	}
		220
		221	/**
		222	* Stop the self-sampling, save and open gathered data. If there is no
		223	* sampled data, this method does nothing and returns immediately.
		224	* <br>
		225	* This method can take a long time and should not be invoked from EDT.
		226	*/
		227	public void stop() {
		228	stopSampling(false, null);
		229	}
		230
		231	private synchronized void stopSampling(boolean cancel, DataOutputStream dos) {
170	try {	232	try {
171	assert running;	233	if (!running) throw new IllegalStateException("sampling was not started"); // NOI18N
172	assert !stopped;	234	if (stopped) throw new IllegalStateException("sampling is not running"); // NOI18N
173	stopped = true;	235	stopped = true;
174	timer.cancel();	236	timer.cancel();
175	if ("cancel".equals(e.getActionCommand()) \|\| samples < 1) { // NOi18N	237	if (cancel \|\| samples < 1) {
176	return;	238	return;
177	}	239	}
		240	if (SwingUtilities.isEventDispatchThread()) throw new IllegalStateException("sampling cannot be stopped from EDT");
178	double average = sum / samples;	241	double average = sum / samples;
179	double std_deviation = Math.sqrt(devSquaresSum / samples);	242	double std_deviation = Math.sqrt(devSquaresSum / samples);
180	boolean writeCommand = "write".equals(e.getActionCommand()); // NOI18N	243	boolean writeCommand = dos != null;
181	if (writeCommand) {	244	if (writeCommand) {
182	Object[] params = new Object[]{startTime, "Samples", samples, "Average", average, "Minimum", min, "Maximum", max, "Std. deviation", std_deviation};	245	Object[] params = new Object[]{startTime, "Samples", samples, "Average", average, "Minimum", min, "Maximum", max, "Std. deviation", std_deviation}; // NOI18N
183	Logger.getLogger("org.netbeans.ui.performance").log(Level.CONFIG, "Snapshot statistics", params); // NOI18N	246	Logger.getLogger("org.netbeans.ui.performance").log(Level.CONFIG, "Snapshot statistics", params); // NOI18N
184	if (average > MAX_AVERAGE \|\| std_deviation > MAX_STDDEVIATION \|\| samples < MIN_SAMPLES) {	247	if (average > MAX_AVERAGE \|\| std_deviation > MAX_STDDEVIATION \|\| samples < MIN_SAMPLES) {
185	// do not take snapshot if the sampling was not regular enough	248	// do not take snapshot if the sampling was not regular enough
Lines 189-195 Link Here
189	samplesStream.close();	252	samplesStream.close();
190	samplesStream = null;	253	samplesStream = null;
191	if (writeCommand) {	254	if (writeCommand) {
192	DataOutputStream dos = (DataOutputStream) e.getSource();
193	dos.write(out.toByteArray());	255	dos.write(out.toByteArray());
194	dos.close();	256	dos.close();
195	return;	257	return;
Lines 202-302 Link Here
202	out = null;	264	out = null;
203	samplesStream = null;	265	samplesStream = null;
204	}	266	}
205	}	267	}
206
207	//
208	// Support for sampling from command line
209	//
210
211	public static void main(String... args) throws Exception {
212	if (args.length != 2) {
213	System.out.println("Usage: <port> <snapshot.npss>");
214	System.out.println();
215	System.out.println("First of all start your application with following parameters:");
216	System.out.println(" -Dcom.sun.management.jmxremote.authenticate=false");
217	System.out.println(" -Dcom.sun.management.jmxremote.ssl=false");
218	System.out.println(" -Dcom.sun.management.jmxremote.port=<port>");
219	System.out.println("Then you can start this sampler with correct port and file to write snapshot to.");
220	System.exit(1);
221	}
222
223	String u = args[0];
224	try {
225	u = "service:jmx:rmi:///jndi/rmi://localhost:" + Integer.parseInt(args[0]) + "/jmxrmi";
226	} catch (NumberFormatException ex) {
227	// OK, use args[0]
228	}
229
230	System.err.println("Connecting to " + u);
231	JMXServiceURL url = new JMXServiceURL(u);
232	JMXConnector jmxc = null;
233	Exception ex = null;
234	for (int i = 0; i < 100; i++) {
235	try {
236	jmxc = JMXConnectorFactory.connect(url, null);
237	break;
238	} catch (IOException e) {
239	ex = e;
240	System.err.println("Connection failed. Will retry in 300ms.");
241	Thread.sleep(300);
242	}
243	}
244	if (jmxc == null) {
245	ex.printStackTrace();
246	System.err.println("Cannot connect to " + u);
247	System.exit(3);
248	}
249	MBeanServerConnection server = jmxc.getMBeanServerConnection();
250
251	final ThreadMXBean threadMXBean = ManagementFactory.newPlatformMXBeanProxy(
252	server,ManagementFactory.THREAD_MXBEAN_NAME,ThreadMXBean.class
253	);
254	final File output = new File(args[1]);
255	class CLISampler extends Sampler {
256	CLISampler() {
257	super("");
258	}
259
260	@Override
261	protected ThreadMXBean getThreadMXBean() {
262	return threadMXBean;
263	}
264
265	@Override
266	protected void saveSnapshot(byte[] arr) throws IOException {
267	FileOutputStream os = new FileOutputStream(output);
268	os.write(arr);
269	os.close();
270	}
271
272	@Override
273	protected void printStackTrace(Throwable ex) {
274	ex.printStackTrace();
275	System.exit(2);
276	}
277
278	@Override
279	protected void openProgress(int steps) {
280	}
281
282	@Override
283	protected void closeProgress() {
284	}
285
286	@Override
287	protected void progress(int i) {
288	System.out.print("#");
289	System.out.flush();
290	}
291	}
292
293	CLISampler s = new CLISampler();
294	s.run();
295	System.out.println("Press enter to generate sample into " + output);
296	System.in.read();
297	s.actionPerformed(new ActionEvent(s, 0, ""));
298	System.out.println();
299	System.out.println("Sample written to " + output);
300	System.exit(0);
301	}
302	}	268	}

Line 0 Link Here

(-)a/sampler/test/unit/src/org/netbeans/modules/sampler/CustomSamplesStream.java (+68 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.sampler;
		43
		44	import java.io.IOException;
		45	import java.io.OutputStream;
		46	import java.lang.management.ThreadInfo;
		47
		48	/**
		49	*
		50	* @author Tomas Hurka
		51	*/
		52	public class CustomSamplesStream extends SamplesOutputStream {
		53
		54	public CustomSamplesStream(OutputStream os, int max) throws IOException {
		55	super(os, null, max);
		56	}
		57
		58	@Override
		59	public void writeSample(ThreadInfo[] infos, long time, long selfThreadId) throws IOException {
		60	super.writeSample(infos, time, selfThreadId);
		61	}
		62
		63	@Override
		64	public void close() throws IOException {
65	super.close();
66	}
67
68	}