You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
261 lines
10 KiB
261 lines
10 KiB
#!/bin/sh |
|
|
|
# Copyright (c) 2005, Google Inc. |
|
# All rights reserved. |
|
# |
|
# Redistribution and use in source and binary forms, with or without |
|
# modification, are permitted provided that the following conditions are |
|
# met: |
|
# |
|
# * Redistributions of source code must retain the above copyright |
|
# notice, this list of conditions and the following disclaimer. |
|
# * Redistributions in binary form must reproduce the above |
|
# copyright notice, this list of conditions and the following disclaimer |
|
# in the documentation and/or other materials provided with the |
|
# distribution. |
|
# * Neither the name of Google Inc. nor the names of its |
|
# contributors may be used to endorse or promote products derived from |
|
# this software without specific prior written permission. |
|
# |
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
|
|
# --- |
|
# Author: Craig Silverstein |
|
# |
|
# Runs the 4 profiler unittests and makes sure their profiles look |
|
# appropriate. We expect two commandline args, as described below. |
|
# |
|
# We run under the assumption that if $PROFILER1 is run with no |
|
# arguments, it prints a usage line of the form |
|
# USAGE: <actual executable being run> [...] |
|
# |
|
# This is because libtool sometimes turns the 'executable' into a |
|
# shell script which runs an actual binary somewhere else. |
|
|
|
# We expect BINDIR and PPROF_PATH to be set in the environment. |
|
# If not, we set them to some reasonable values |
|
BINDIR="${BINDIR:-.}" |
|
PPROF_PATH="${PPROF_PATH:-$BINDIR/src/pprof}" |
|
|
|
if [ "x$1" = "x-h" -o "x$1" = "x--help" ]; then |
|
echo "USAGE: $0 [unittest dir] [path to pprof]" |
|
echo " By default, unittest_dir=$BINDIR, pprof_path=$PPROF_PATH" |
|
exit 1 |
|
fi |
|
|
|
TMPDIR=/tmp/profile_info |
|
|
|
UNITTEST_DIR=${1:-$BINDIR} |
|
PPROF=${2:-$PPROF_PATH} |
|
|
|
# We test the sliding-window functionality of the cpu-profile reader |
|
# by using a small stride, forcing lots of reads. |
|
PPROF_FLAGS="--test_stride=128" |
|
|
|
PROFILER1="$UNITTEST_DIR/profiler1_unittest" |
|
PROFILER2="$UNITTEST_DIR/profiler2_unittest" |
|
PROFILER3="$UNITTEST_DIR/profiler3_unittest" |
|
PROFILER4="$UNITTEST_DIR/profiler4_unittest" |
|
|
|
# Unfortunately, for us, libtool can replace executables with a shell |
|
# script that does some work before calling the 'real' executable |
|
# under a different name. We need the 'real' executable name to run |
|
# pprof on it. We've constructed all the binaries used in this |
|
# unittest so when they are called with no arguments, they report |
|
# their argv[0], which is the real binary name. |
|
Realname() { |
|
"$1" 2>&1 | awk '{print $2; exit;}' |
|
} |
|
|
|
PROFILER1_REALNAME=`Realname "$PROFILER1"` |
|
PROFILER2_REALNAME=`Realname "$PROFILER2"` |
|
PROFILER3_REALNAME=`Realname "$PROFILER3"` |
|
PROFILER4_REALNAME=`Realname "$PROFILER4"` |
|
|
|
# It's meaningful to the profiler, so make sure we know its state |
|
unset CPUPROFILE |
|
|
|
rm -rf "$TMPDIR" |
|
mkdir "$TMPDIR" || exit 2 |
|
|
|
num_failures=0 |
|
|
|
RegisterFailure() { |
|
num_failures=`expr $num_failures + 1` |
|
} |
|
|
|
# Takes two filenames representing profiles, with their executable scripts, |
|
# and a multiplier, and verifies that the 'contentful' functions in |
|
# each profile take the same time (possibly scaled by the given |
|
# multiplier). It used to be "same" meant within 50%, after adding an |
|
# noise-reducing X units to each value. But even that would often |
|
# spuriously fail, so now it's "both non-zero". We're pretty forgiving. |
|
VerifySimilar() { |
|
prof1="$TMPDIR/$1" |
|
exec1="$2" |
|
prof2="$TMPDIR/$3" |
|
exec2="$4" |
|
mult="$5" |
|
|
|
# We are careful not to put exec1 and exec2 in quotes, because if |
|
# they are the empty string, it means we want to use the 1-arg |
|
# version of pprof. |
|
mthread1=`"$PPROF" $PPROF_FLAGS $exec1 "$prof1" | grep test_main_thread | awk '{print $1}'` |
|
mthread2=`"$PPROF" $PPROF_FLAGS $exec2 "$prof2" | grep test_main_thread | awk '{print $1}'` |
|
mthread1_plus=`expr $mthread1 + 5` |
|
mthread2_plus=`expr $mthread2 + 5` |
|
if [ -z "$mthread1" ] || [ -z "$mthread2" ] || \ |
|
[ "$mthread1" -le 0 -o "$mthread2" -le 0 ] |
|
# || [ `expr $mthread1_plus \* $mult` -gt `expr $mthread2_plus \* 2` -o \ |
|
# `expr $mthread1_plus \* $mult \* 2` -lt `expr $mthread2_plus` ] |
|
then |
|
echo |
|
echo ">>> profile on $exec1 vs $exec2 with multiplier $mult failed:" |
|
echo "Actual times (in profiling units) were '$mthread1' vs. '$mthread2'" |
|
echo |
|
RegisterFailure |
|
fi |
|
} |
|
|
|
# Takes two filenames representing profiles, and optionally their |
|
# executable scripts (these may be empty if the profiles include |
|
# symbols), and verifies that the two profiles are identical. |
|
VerifyIdentical() { |
|
prof1="$TMPDIR/$1" |
|
exec1="$2" |
|
prof2="$TMPDIR/$3" |
|
exec2="$4" |
|
|
|
# We are careful not to put exec1 and exec2 in quotes, because if |
|
# they are the empty string, it means we want to use the 1-arg |
|
# version of pprof. |
|
"$PPROF" $PPROF_FLAGS $exec1 "$prof1" > "$TMPDIR/out1" |
|
"$PPROF" $PPROF_FLAGS $exec2 "$prof2" > "$TMPDIR/out2" |
|
diff=`diff "$TMPDIR/out1" "$TMPDIR/out2"` |
|
|
|
if [ ! -z "$diff" ]; then |
|
echo |
|
echo ">>> profile doesn't match, args: $exec1 $prof1 vs. $exec2 $prof2" |
|
echo ">>> Diff:" |
|
echo "$diff" |
|
echo |
|
RegisterFailure |
|
fi |
|
} |
|
|
|
# Takes a filename representing a profile, with its executable, |
|
# and a multiplier, and verifies that the main-thread function takes |
|
# the same amount of time as the other-threads function (possibly scaled |
|
# by the given multiplier). Figuring out the multiplier can be tricky, |
|
# since by design the main thread runs twice as long as each of the |
|
# 'other' threads! It used to be "same" meant within 50%, after adding an |
|
# noise-reducing X units to each value. But even that would often |
|
# spuriously fail, so now it's "both non-zero". We're pretty forgiving. |
|
VerifyAcrossThreads() { |
|
prof1="$TMPDIR/$1" |
|
# We need to run the script with no args to get the actual exe name |
|
exec1="$2" |
|
mult="$3" |
|
|
|
# We are careful not to put exec1 in quotes, because if it is the |
|
# empty string, it means we want to use the 1-arg version of pprof. |
|
mthread=`$PPROF $PPROF_FLAGS $exec1 "$prof1" | grep test_main_thread | awk '{print $1}'` |
|
othread=`$PPROF $PPROF_FLAGS $exec1 "$prof1" | grep test_other_thread | awk '{print $1}'` |
|
if [ -z "$mthread" ] || [ -z "$othread" ] || \ |
|
[ "$mthread" -le 0 -o "$othread" -le 0 ] |
|
# || [ `expr $mthread \* $mult \* 3` -gt `expr $othread \* 10` -o \ |
|
# `expr $mthread \* $mult \* 10` -lt `expr $othread \* 3` ] |
|
then |
|
echo |
|
echo ">>> profile on $exec1 (main vs thread) with multiplier $mult failed:" |
|
echo "Actual times (in profiling units) were '$mthread' vs. '$othread'" |
|
echo |
|
RegisterFailure |
|
fi |
|
} |
|
|
|
echo |
|
echo ">>> WARNING <<<" |
|
echo "This test looks at timing information to determine correctness." |
|
echo "If your system is loaded, the test may spuriously fail." |
|
echo "If the test does fail with an 'Actual times' error, try running again." |
|
echo |
|
|
|
# profiler1 is a non-threaded version |
|
"$PROFILER1" 50 1 "$TMPDIR/p1" || RegisterFailure |
|
"$PROFILER1" 100 1 "$TMPDIR/p2" || RegisterFailure |
|
VerifySimilar p1 "$PROFILER1_REALNAME" p2 "$PROFILER1_REALNAME" 2 |
|
|
|
# Verify the same thing works if we statically link |
|
"$PROFILER2" 50 1 "$TMPDIR/p3" || RegisterFailure |
|
"$PROFILER2" 100 1 "$TMPDIR/p4" || RegisterFailure |
|
VerifySimilar p3 "$PROFILER2_REALNAME" p4 "$PROFILER2_REALNAME" 2 |
|
|
|
# Verify the same thing works if we specify via CPUPROFILE |
|
CPUPROFILE="$TMPDIR/p5" "$PROFILER2" 50 || RegisterFailure |
|
CPUPROFILE="$TMPDIR/p6" "$PROFILER2" 100 || RegisterFailure |
|
VerifySimilar p5 "$PROFILER2_REALNAME" p6 "$PROFILER2_REALNAME" 2 |
|
|
|
CPUPROFILE="$TMPDIR/p5b" "$PROFILER3" 30 || RegisterFailure |
|
CPUPROFILE="$TMPDIR/p5c" "$PROFILER3" 60 || RegisterFailure |
|
VerifySimilar p5b "$PROFILER3_REALNAME" p5c "$PROFILER3_REALNAME" 2 |
|
|
|
# Now try what happens when we use threads |
|
"$PROFILER3" 30 2 "$TMPDIR/p7" || RegisterFailure |
|
"$PROFILER3" 60 2 "$TMPDIR/p8" || RegisterFailure |
|
VerifySimilar p7 "$PROFILER3_REALNAME" p8 "$PROFILER3_REALNAME" 2 |
|
|
|
"$PROFILER4" 30 2 "$TMPDIR/p9" || RegisterFailure |
|
"$PROFILER4" 60 2 "$TMPDIR/p10" || RegisterFailure |
|
VerifySimilar p9 "$PROFILER4_REALNAME" p10 "$PROFILER4_REALNAME" 2 |
|
|
|
# More threads! |
|
"$PROFILER4" 25 3 "$TMPDIR/p9" || RegisterFailure |
|
"$PROFILER4" 50 3 "$TMPDIR/p10" || RegisterFailure |
|
VerifySimilar p9 "$PROFILER4_REALNAME" p10 "$PROFILER4_REALNAME" 2 |
|
|
|
# Compare how much time the main thread takes compared to the other threads |
|
# Recall the main thread runs twice as long as the other threads, by design. |
|
"$PROFILER4" 20 4 "$TMPDIR/p11" || RegisterFailure |
|
VerifyAcrossThreads p11 "$PROFILER4_REALNAME" 2 |
|
|
|
# Test symbol save and restore |
|
"$PROFILER1" 50 1 "$TMPDIR/p12" || RegisterFailure |
|
"$PPROF" $PPROF_FLAGS "$PROFILER1_REALNAME" "$TMPDIR/p12" --raw \ |
|
>"$TMPDIR/p13" 2>/dev/null || RegisterFailure |
|
VerifyIdentical p12 "$PROFILER1_REALNAME" p13 "" || RegisterFailure |
|
|
|
"$PROFILER3" 30 2 "$TMPDIR/p14" || RegisterFailure |
|
"$PPROF" $PPROF_FLAGS "$PROFILER3_REALNAME" "$TMPDIR/p14" --raw \ |
|
>"$TMPDIR/p15" 2>/dev/null || RegisterFailure |
|
VerifyIdentical p14 "$PROFILER3_REALNAME" p15 "" || RegisterFailure |
|
|
|
# Test using ITIMER_REAL instead of ITIMER_PROF. |
|
env CPUPROFILE_REALTIME=1 "$PROFILER3" 30 2 "$TMPDIR/p16" || RegisterFailure |
|
env CPUPROFILE_REALTIME=1 "$PROFILER3" 60 2 "$TMPDIR/p17" || RegisterFailure |
|
VerifySimilar p16 "$PROFILER3_REALNAME" p17 "$PROFILER3_REALNAME" 2 |
|
|
|
|
|
# Make sure that when we have a process with a fork, the profiles don't |
|
# clobber each other |
|
CPUPROFILE="$TMPDIR/pfork" "$PROFILER1" 1 -2 || RegisterFailure |
|
n=`ls $TMPDIR/pfork* | wc -l` |
|
if [ $n != 3 ]; then |
|
echo "FORK test FAILED: expected 3 profiles (for main + 2 children), found $n" |
|
num_failures=`expr $num_failures + 1` |
|
fi |
|
|
|
rm -rf "$TMPDIR" # clean up |
|
|
|
echo "Tests finished with $num_failures failures" |
|
exit $num_failures
|
|
|