385 lines
13 KiB
Bash
Executable File
385 lines
13 KiB
Bash
Executable File
#
|
|
# Copyright (C) 2018 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
#################################################################
|
|
###
|
|
### DO NOT MODIFY THIS FILE
|
|
### This is a copy of androidx's benchmark/lockClocks.sh
|
|
### Make changes there instead then copy here!
|
|
###
|
|
#################################################################
|
|
|
|
# This script can be used to lock device clocks to stable levels for comparing
|
|
# different versions of software. Since the clock levels are not necessarily
|
|
# indicative of real world behavior, this should **never** be used to compare
|
|
# performance between different device models.
|
|
|
|
# Fun notes for maintaining this file:
|
|
# $((arithmetic expressions)) can deal with ints > INT32_MAX, but if compares cannot. This is
|
|
# why we use MHz.
|
|
# $((arithmetic expressions)) can sometimes evaluate right-to-left. This is why we use parens.
|
|
# Everything below the initial host-check isn't bash - Android uses mksh
|
|
# mksh allows `\n` in an echo, bash doesn't
|
|
# can't use `awk`
|
|
# can't use `sed`
|
|
# can't use `cut` on < L
|
|
# can't use `expr` on < L
|
|
|
|
ARG_CORES=${1:-big}
|
|
|
|
CPU_TARGET_FREQ_PERCENT=50
|
|
GPU_TARGET_FREQ_PERCENT=50
|
|
|
|
if [ "`command -v getprop`" == "" ]; then
|
|
if [ -n "`command -v adb`" ]; then
|
|
echo ""
|
|
echo "Pushing $0 and running it on device..."
|
|
dest=/data/local/tmp/`basename $0`
|
|
adb push $0 ${dest}
|
|
adb shell ${dest} $@
|
|
adb shell rm ${dest}
|
|
exit
|
|
else
|
|
echo "Could not find adb. Options are:"
|
|
echo " 1. Ensure adb is on your \$PATH"
|
|
echo " 2. Use './gradlew lockClocks'"
|
|
echo " 3. Manually adb push this script to your device, and run it there"
|
|
exit -1
|
|
fi
|
|
fi
|
|
|
|
# require root
|
|
if [[ `id` != "uid=0"* ]]; then
|
|
echo "Not running as root, cannot lock clocks, aborting"
|
|
exit -1
|
|
fi
|
|
|
|
DEVICE=`getprop ro.product.device`
|
|
MODEL=`getprop ro.product.model`
|
|
|
|
if [ "$ARG_CORES" == "big" ]; then
|
|
CPU_IDEAL_START_FREQ_KHZ=0
|
|
elif [ "$ARG_CORES" == "little" ]; then
|
|
CPU_IDEAL_START_FREQ_KHZ=100000000 ## finding min of max freqs, so start at 100M KHz (100 GHz)
|
|
else
|
|
echo "Invalid argument \$1 for ARG_CORES, should be 'big' or 'little', but was $ARG_CORES"
|
|
exit -1
|
|
fi
|
|
|
|
function_core_check() {
|
|
if [ "$ARG_CORES" == "big" ]; then
|
|
[ $1 -gt $2 ]
|
|
elif [ "$ARG_CORES" == "little" ]; then
|
|
[ $1 -lt $2 ]
|
|
else
|
|
echo "Invalid argument \$1 for ARG_CORES, should be 'big' or 'little', but was $ARG_CORES"
|
|
exit -1
|
|
fi
|
|
}
|
|
|
|
function_setup_go() {
|
|
if [ -f /d/fpsgo/common/force_onoff ]; then
|
|
# Disable fpsgo
|
|
echo 0 > /d/fpsgo/common/force_onoff
|
|
fpsgoState=`cat /d/fpsgo/common/force_onoff`
|
|
if [ "$fpsgoState" != "0" ] && [ "$fpsgoState" != "force off" ]; then
|
|
echo "Failed to disable fpsgo"
|
|
exit -1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Find the min or max (little vs big) of CPU max frequency, and lock cores of the selected type to
|
|
# an available frequency that's >= $CPU_TARGET_FREQ_PERCENT% of max. Disable other cores.
|
|
function_lock_cpu() {
|
|
CPU_BASE=/sys/devices/system/cpu
|
|
GOV=cpufreq/scaling_governor
|
|
|
|
# Options to make clock locking on go devices more sticky.
|
|
function_setup_go
|
|
|
|
# Find max CPU freq, and associated list of available freqs
|
|
cpuIdealFreq=$CPU_IDEAL_START_FREQ_KHZ
|
|
cpuAvailFreqCmpr=0
|
|
cpuAvailFreq=0
|
|
enableIndices=''
|
|
disableIndices=''
|
|
cpu=0
|
|
while [ -d ${CPU_BASE}/cpu${cpu}/cpufreq ]; do
|
|
# Try to enable core, so we can find its frequencies.
|
|
# Note: In cases where the online file is inaccessible, it represents a
|
|
# core which cannot be turned off, so we simply assume it is enabled if
|
|
# this command fails.
|
|
if [ -f "$CPU_BASE/cpu$cpu/online" ]; then
|
|
echo 1 > ${CPU_BASE}/cpu${cpu}/online || true
|
|
fi
|
|
|
|
# set userspace governor on all CPUs to ensure freq scaling is disabled
|
|
echo userspace > ${CPU_BASE}/cpu${cpu}/${GOV}
|
|
|
|
maxFreq=`cat ${CPU_BASE}/cpu$cpu/cpufreq/cpuinfo_max_freq`
|
|
availFreq=`cat ${CPU_BASE}/cpu$cpu/cpufreq/scaling_available_frequencies`
|
|
availFreqCmpr=${availFreq// /-}
|
|
|
|
if (function_core_check $maxFreq $cpuIdealFreq); then
|
|
# new min/max of max freq, look for cpus with same max freq and same avail freq list
|
|
cpuIdealFreq=${maxFreq}
|
|
cpuAvailFreq=${availFreq}
|
|
cpuAvailFreqCmpr=${availFreqCmpr}
|
|
|
|
if [ -z "$disableIndices" ]; then
|
|
disableIndices="$enableIndices"
|
|
else
|
|
disableIndices="$disableIndices $enableIndices"
|
|
fi
|
|
enableIndices=${cpu}
|
|
elif [ ${maxFreq} == ${cpuIdealFreq} ] && [ ${availFreqCmpr} == ${cpuAvailFreqCmpr} ]; then
|
|
enableIndices="$enableIndices $cpu"
|
|
else
|
|
if [ -z "$disableIndices" ]; then
|
|
disableIndices="$cpu"
|
|
else
|
|
disableIndices="$disableIndices $cpu"
|
|
fi
|
|
fi
|
|
|
|
cpu=$(($cpu + 1))
|
|
done
|
|
|
|
# check that some CPUs will be enabled
|
|
if [ -z "$enableIndices" ]; then
|
|
echo "Failed to find any $ARG_CORES cores to enable, aborting."
|
|
exit -1
|
|
fi
|
|
|
|
# Chose a frequency to lock to that's >= $CPU_TARGET_FREQ_PERCENT% of max
|
|
# (below, 100M = 1K for KHz->MHz * 100 for %)
|
|
TARGET_FREQ_MHZ=$(( ($cpuIdealFreq * $CPU_TARGET_FREQ_PERCENT) / 100000 ))
|
|
chosenFreq=0
|
|
chosenFreqDiff=100000000
|
|
for freq in ${cpuAvailFreq}; do
|
|
freqMhz=$(( ${freq} / 1000 ))
|
|
if [ ${freqMhz} -ge ${TARGET_FREQ_MHZ} ]; then
|
|
newChosenFreqDiff=$(( $freq - $TARGET_FREQ_MHZ ))
|
|
if [ $newChosenFreqDiff -lt $chosenFreqDiff ]; then
|
|
chosenFreq=${freq}
|
|
chosenFreqDiff=$(( $chosenFreq - $TARGET_FREQ_MHZ ))
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Lock wembley clocks using high-priority op code method.
|
|
# This block depends on the shell utility awk, which is only available on API 27+
|
|
if [ "$DEVICE" == "wembley" ]; then
|
|
# Get list of available frequencies to lock to by parsing the op-code list.
|
|
AVAIL_OP_FREQS=`cat /proc/cpufreq/MT_CPU_DVFS_LL/cpufreq_oppidx \
|
|
| awk '{print $2}' \
|
|
| tail -n +3 \
|
|
| while read line; do
|
|
echo "${line:1:${#line}-2}"
|
|
done`
|
|
|
|
# Compute the closest available frequency to the desired frequency, $chosenFreq.
|
|
# This assumes the op codes listen in /proc/cpufreq/MT_CPU_DVFS_LL/cpufreq_oppidx are listed
|
|
# in order and 0-indexed.
|
|
opCode=-1
|
|
opFreq=0
|
|
currOpCode=-1
|
|
for currOpFreq in $AVAIL_OP_FREQS; do
|
|
currOpCode=$((currOpCode + 1))
|
|
|
|
prevDiff=$((chosenFreq-opFreq))
|
|
prevDiff=`function_abs $prevDiff`
|
|
currDiff=$((chosenFreq-currOpFreq))
|
|
currDiff=`function_abs $currDiff`
|
|
if [ $currDiff -lt $prevDiff ]; then
|
|
opCode="$currOpCode"
|
|
opFreq="$currOpFreq"
|
|
fi
|
|
done
|
|
|
|
echo "$opCode" > /proc/ppm/policy/ut_fix_freq_idx
|
|
fi
|
|
|
|
# enable 'big' CPUs
|
|
for cpu in ${enableIndices}; do
|
|
freq=${CPU_BASE}/cpu$cpu/cpufreq
|
|
|
|
# Try to enable core, so we can find its frequencies.
|
|
# Note: In cases where the online file is inaccessible, it represents a
|
|
# core which cannot be turned off, so we simply assume it is enabled if
|
|
# this command fails.
|
|
if [ -f "$CPU_BASE/cpu$cpu/online" ]; then
|
|
echo 1 > ${CPU_BASE}/cpu${cpu}/online || true
|
|
fi
|
|
|
|
# scaling_max_freq must be set before scaling_min_freq
|
|
echo ${chosenFreq} > ${freq}/scaling_max_freq
|
|
echo ${chosenFreq} > ${freq}/scaling_min_freq
|
|
echo ${chosenFreq} > ${freq}/scaling_setspeed
|
|
|
|
# Give system a bit of time to propagate the change to scaling_setspeed.
|
|
sleep 0.1
|
|
|
|
# validate setting the freq worked
|
|
obsCur=`cat ${freq}/scaling_cur_freq`
|
|
obsMin=`cat ${freq}/scaling_min_freq`
|
|
obsMax=`cat ${freq}/scaling_max_freq`
|
|
if [ "$obsCur" -ne "$chosenFreq" ] || [ "$obsMin" -ne "$chosenFreq" ] || [ "$obsMax" -ne "$chosenFreq" ]; then
|
|
echo "Failed to set CPU$cpu to $chosenFreq Hz! Aborting..."
|
|
echo "scaling_cur_freq = $obsCur"
|
|
echo "scaling_min_freq = $obsMin"
|
|
echo "scaling_max_freq = $obsMax"
|
|
exit -1
|
|
fi
|
|
done
|
|
|
|
# disable other CPUs (Note: important to enable big cores first!)
|
|
for cpu in ${disableIndices}; do
|
|
echo 0 > ${CPU_BASE}/cpu${cpu}/online
|
|
done
|
|
|
|
echo "=================================="
|
|
echo "Locked CPUs ${enableIndices// /,} to $chosenFreq / $cpuIdealFreq KHz"
|
|
echo "Disabled CPUs ${disableIndices// /,}"
|
|
echo "=================================="
|
|
}
|
|
|
|
# Returns the absolute value of the first arg passed to this helper.
|
|
function_abs() {
|
|
n=$1
|
|
if [ $n -lt 0 ]; then
|
|
echo "$((n * -1 ))"
|
|
else
|
|
echo "$n"
|
|
fi
|
|
}
|
|
|
|
# If we have a Qualcomm GPU, find its max frequency, and lock to
|
|
# an available frequency that's >= GPU_TARGET_FREQ_PERCENT% of max.
|
|
function_lock_gpu_kgsl() {
|
|
if [ ! -d /sys/class/kgsl/kgsl-3d0/ ]; then
|
|
# not kgsl, abort
|
|
echo "Currently don't support locking GPU clocks of $MODEL ($DEVICE)"
|
|
return -1
|
|
fi
|
|
if [ ${DEVICE} == "walleye" ] || [ ${DEVICE} == "taimen" ]; then
|
|
# Workaround crash
|
|
echo "Unable to lock GPU clocks of $MODEL ($DEVICE)"
|
|
return -1
|
|
fi
|
|
|
|
GPU_BASE=/sys/class/kgsl/kgsl-3d0
|
|
|
|
gpuMaxFreq=0
|
|
gpuAvailFreq=`cat $GPU_BASE/devfreq/available_frequencies`
|
|
for freq in ${gpuAvailFreq}; do
|
|
if [ ${freq} -gt ${gpuMaxFreq} ]; then
|
|
gpuMaxFreq=${freq}
|
|
fi
|
|
done
|
|
|
|
# (below, 100M = 1M for MHz * 100 for %)
|
|
TARGET_FREQ_MHZ=$(( (${gpuMaxFreq} * ${GPU_TARGET_FREQ_PERCENT}) / 100000000 ))
|
|
|
|
chosenFreq=${gpuMaxFreq}
|
|
index=0
|
|
chosenIndex=0
|
|
for freq in ${gpuAvailFreq}; do
|
|
freqMhz=$(( ${freq} / 1000000 ))
|
|
if [ ${freqMhz} -ge ${TARGET_FREQ_MHZ} ] && [ ${chosenFreq} -ge ${freq} ]; then
|
|
# note avail freq are generally in reverse order, so we don't break out of this loop
|
|
chosenFreq=${freq}
|
|
chosenIndex=${index}
|
|
fi
|
|
index=$(($index + 1))
|
|
done
|
|
lastIndex=$(($index - 1))
|
|
|
|
firstFreq=`function_cut_first_from_space_seperated_list $gpuAvailFreq`
|
|
|
|
if [ ${gpuMaxFreq} != ${firstFreq} ]; then
|
|
# pwrlevel is index of desired freq among available frequencies, from highest to lowest.
|
|
# If gpuAvailFreq appears to be in-order, reverse the index
|
|
chosenIndex=$(($lastIndex - $chosenIndex))
|
|
fi
|
|
|
|
echo 0 > ${GPU_BASE}/bus_split
|
|
echo 1 > ${GPU_BASE}/force_clk_on
|
|
echo 10000 > ${GPU_BASE}/idle_timer
|
|
|
|
echo performance > ${GPU_BASE}/devfreq/governor
|
|
|
|
# NOTE: we store in min/max twice, because we don't know if we're increasing
|
|
# or decreasing, and it's invalid to try and set min > max, or max < min
|
|
echo ${chosenFreq} > ${GPU_BASE}/devfreq/min_freq
|
|
echo ${chosenFreq} > ${GPU_BASE}/devfreq/max_freq
|
|
echo ${chosenFreq} > ${GPU_BASE}/devfreq/min_freq
|
|
echo ${chosenFreq} > ${GPU_BASE}/devfreq/max_freq
|
|
echo ${chosenIndex} > ${GPU_BASE}/min_pwrlevel
|
|
echo ${chosenIndex} > ${GPU_BASE}/max_pwrlevel
|
|
echo ${chosenIndex} > ${GPU_BASE}/min_pwrlevel
|
|
echo ${chosenIndex} > ${GPU_BASE}/max_pwrlevel
|
|
|
|
obsCur=`cat ${GPU_BASE}/devfreq/cur_freq`
|
|
obsMin=`cat ${GPU_BASE}/devfreq/min_freq`
|
|
obsMax=`cat ${GPU_BASE}/devfreq/max_freq`
|
|
if [ obsCur -ne ${chosenFreq} ] || [ obsMin -ne ${chosenFreq} ] || [ obsMax -ne ${chosenFreq} ]; then
|
|
echo "Failed to set GPU to $chosenFreq Hz! Aborting..."
|
|
echo "cur_freq = $obsCur"
|
|
echo "min_freq = $obsMin"
|
|
echo "max_freq = $obsMax"
|
|
echo "index = $chosenIndex"
|
|
exit -1
|
|
fi
|
|
echo "Locked GPU to $chosenFreq / $gpuMaxFreq Hz"
|
|
}
|
|
|
|
# cut is not available on some devices (Nexus 5 running LRX22C).
|
|
function_cut_first_from_space_seperated_list() {
|
|
list=$1
|
|
|
|
for freq in $list; do
|
|
echo $freq
|
|
break
|
|
done
|
|
}
|
|
|
|
# kill processes that manage thermals / scaling
|
|
stop thermal-engine || true
|
|
stop perfd || true
|
|
stop vendor.thermal-engine || true
|
|
stop vendor.perfd || true
|
|
setprop vendor.powerhal.init 0 || true
|
|
setprop ctl.interface_restart android.hardware.power@1.0::IPower/default || true
|
|
|
|
function_lock_cpu
|
|
|
|
if [ "$DEVICE" -ne "wembley" ]; then
|
|
function_lock_gpu_kgsl
|
|
else
|
|
echo "Unable to lock gpu clocks of $MODEL ($DEVICE)."
|
|
fi
|
|
|
|
# Memory bus - hardcoded per-device for now
|
|
if [ ${DEVICE} == "marlin" ] || [ ${DEVICE} == "sailfish" ]; then
|
|
echo 13763 > /sys/class/devfreq/soc:qcom,gpubw/max_freq
|
|
else
|
|
echo "Unable to lock memory bus of $MODEL ($DEVICE)."
|
|
fi
|
|
|
|
echo "$DEVICE clocks have been locked - to reset, reboot the device"
|