Logo Search packages:      
Sourcecode: visualvm version File versions  Download package

TimingAdjuster.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 *
 * 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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun 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.
 */

package org.netbeans.lib.profiler.results.cpu;


//import org.netbeans.lib.profiler.global.Platform;
//import org.netbeans.lib.profiler.global.ProfilingSessionStatus;
//import org.netbeans.lib.profiler.utils.StringUtils;

/**
 *
 * @author Jaroslav Bachorik
 */
00052 public class TimingAdjuster {
    //  // @GuardedBy this
    //  private InstrTimingData timingData;
    //  
    //  public TimingAdjuster(final ProfilingSessionStatus status, final boolean collectingTwoTimeStamps) {
    //    calculateTimingData(status, collectingTwoTimeStamps);
    //  }
    //  
    //  final public synchronized TimeStamp adjustTime(TimeStamp time, int incommingInv, int outgoingInv) {
    //    TimeStamp result = null;
    //    
    //    long timeExCleansed = timingData.timerCountsInSecond1 == 0 ? 0 : (long)((double) time.getExtendedTime() - incommingInv * timingData.methodEntryExitInnerTime1 - outgoingInv * timingData.methodEntryExitOuterTime1) * 1000000 / timingData.timerCountsInSecond1;
    //    long timeCleansed = timingData.timerCountsInSecond0 == 0 ? 0 : (long)((double) time.getTime() - incommingInv * timingData.methodEntryExitInnerTime0 - outgoingInv * timingData.methodEntryExitOuterTime0) * 1000000 / timingData.timerCountsInSecond0;
    //
    //    timeCleansed = timeCleansed < 0 ? 0 : timeCleansed;
    //    timeExCleansed = timeExCleansed < 0 ? 0 : timeExCleansed;
    //    
    //    result = TimeStamp.createTimeStamp(timeCleansed, timeExCleansed);
    //    
    //    return result;
    //  }
    //  
    //  final public synchronized double delta(int incommingInv, int outgoingInv, boolean secondTimestamp) {
    //    double adjusted = 0;
    //    if (secondTimestamp) {
    //      adjusted = ((double) incommingInv * timingData.methodEntryExitInnerTime1 - outgoingInv * timingData.methodEntryExitOuterTime1) * 1000000 / timingData.timerCountsInSecond1;
    //    } else {
    //      adjusted = ((double) incommingInv * timingData.methodEntryExitInnerTime0 - outgoingInv * timingData.methodEntryExitOuterTime0) * 1000000 / timingData.timerCountsInSecond0;
    //    }
    //    
    //    if (adjusted < 0) adjusted = 0;
    //    return adjusted;
    //  }
    //  
    //  final public synchronized boolean isAdjustible(long time, int incommingInv, int outgoingInv, boolean secondTimestamp) {
    //    if (secondTimestamp) {
    //      return time > (incommingInv * timingData.methodEntryExitInnerTime1 + outgoingInv * timingData.methodEntryExitOuterTime1);
    //    } else {
    //      return time > (incommingInv * timingData.methodEntryExitInnerTime0 + outgoingInv * timingData.methodEntryExitOuterTime0);
    //    }
    //  }
    //  
    //  public synchronized void calculateTimingData(final ProfilingSessionStatus status, final boolean collectingTwoTimeStamps) {
    //    timingData = new InstrTimingData();
    //    // We use the following "safety margins" to artificially decrease the time spent in instrumentation.
    //    // That's because it looks like due to various CPU level speed optimizations the execution time for some code with
    //    // added instrumentation may be pretty much equal to the execution time of the instrumentation itself. The profiled
    //    // code, esp. if it's just one or two lines, is effectively executed in parallel with instrumentation.
    //    // Furthermore, highly optimizing CPU plus possibly smth. like rounding errors may occasionally result in the
    //    // measured time that is even *smaller* than the execution time of the instrumentation. This will result in
    //    // *negative* cleansed times presented to the user.
    //    // This safety margin is rough, but probably most reliable way to deal with these issues. The value has been
    //    // chosen experimentally, and seems to result in reasonable compromise between data accuracy and no occurrences
    //    // of zero time results.
    //    double safetyMargin0 = 0.88;
    //    double safetyMargin1 = 0.88;
    //    double safetyMargin2 = 0.88;
    //    if (collectingTwoTimeStamps) {
    //      // Note that all methodEntryExitXXX times are measured in status in absolute timer counts.
    //      // For usage in factor-out operations, we need to convert those that are used with thread CPU time values
    //      // into thread CPU time units.
    //      timingData.methodEntryExitCallTime0 = status.methodEntryExitCallTime[2] * safetyMargin2;
    //      timingData.methodEntryExitCallTime1 =
    //        status.methodEntryExitCallTime[3] * status.timerCountsInSecond[1] / status.timerCountsInSecond[0]
    //        * safetyMargin2;
    //      timingData.methodEntryExitInnerTime0 = status.methodEntryExitInnerTime[2] * safetyMargin2;
    //      timingData.methodEntryExitOuterTime0 = status.methodEntryExitOuterTime[2] * safetyMargin2;
    //      timingData.methodEntryExitInnerTime1 =
    //        status.methodEntryExitInnerTime[3] * status.timerCountsInSecond[1] / status.timerCountsInSecond[0]
    //        * safetyMargin2;
    //      timingData.methodEntryExitOuterTime1 =
    //        status.methodEntryExitOuterTime[3] * status.timerCountsInSecond[1] / status.timerCountsInSecond[0]
    //        * safetyMargin2;
    //      timingData.timerCountsInSecond0 = status.timerCountsInSecond[0];
    //      timingData.timerCountsInSecond1 = status.timerCountsInSecond[1];
    //    } else {
    //      if (status.absoluteTimerOn) {
    //        timingData.methodEntryExitCallTime0 = status.methodEntryExitCallTime[0] * safetyMargin0;
    //        timingData.methodEntryExitInnerTime0 = status.methodEntryExitInnerTime[0] * safetyMargin0;
    //        timingData.methodEntryExitOuterTime0 = status.methodEntryExitOuterTime[0] * safetyMargin0;
    //        timingData.timerCountsInSecond0 = status.timerCountsInSecond[0];
    //      } else {
    //        // Thread CPU only timer used. On Windows and Linux, with extremely low (10 ms or even worse) resolution of
    //        // this timer, it doesn't make sense to use cleansing - it introduces negative figures for short-running
    //        // methods, for which I didn't find any graceful way to deal with.
    //        // Also, cleansing is needed to make results sensible for short-running methods - but here for such methods
    //        // they are already non-sensible, with 0 as a most typical result.
    //        String targetMachineOSName = status.targetMachineOSName;
    //        if (targetMachineOSName == null) return; // dont calculate timings for an undefined OS
    //        if (Platform.isWindows(targetMachineOSName) || Platform.isLinux(targetMachineOSName)) {
    //          safetyMargin1 = 0;
    //        }
    //        timingData.methodEntryExitCallTime0 =
    //          status.methodEntryExitCallTime[1] * status.timerCountsInSecond[1] / status.timerCountsInSecond[0]
    //          * safetyMargin1;
    //        timingData.methodEntryExitInnerTime0 =
    //          status.methodEntryExitInnerTime[1] * status.timerCountsInSecond[1] / status.timerCountsInSecond[0]
    //          * safetyMargin1;
    //        timingData.methodEntryExitOuterTime0 =
    //          status.methodEntryExitOuterTime[1] * status.timerCountsInSecond[1] / status.timerCountsInSecond[0]
    //          * safetyMargin1;
    //        timingData.timerCountsInSecond0 = status.timerCountsInSecond[1];
    //      }
    //    }
    //    System.out.println(timingData);
    //  }
}

Generated by  Doxygen 1.6.0   Back to index