blob: 556145214646b588050d1c6d359a4ee71aab1db3 [file] [log] [blame]
#
# 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.
#
# 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
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`
# Find CPU max frequency, and lock big cores 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
# Find max CPU freq, and associated list of available freqs
cpuMaxFreq=0
cpuAvailFreqCmpr=0
cpuAvailFreq=0
enableIndices=''
disableIndices=''
cpu=0
while [ -f ${CPU_BASE}/cpu${cpu}/online ]; do
# enable core, so we can find its frequencies
echo 1 > ${CPU_BASE}/cpu${cpu}/online
# 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 [ ${maxFreq} -gt ${cpuMaxFreq} ]; then
# new highest max freq, look for cpus with same max freq and same avail freq list
cpuMaxFreq=${maxFreq}
cpuAvailFreq=${availFreq}
cpuAvailFreqCmpr=${availFreqCmpr}
if [ -z ${disableIndices} ]; then
disableIndices="$enableIndices"
else
disableIndices="$disableIndices $enableIndices"
fi
enableIndices=${cpu}
elif [ ${maxFreq} == ${cpuMaxFreq} ] && [ ${availFreqCmpr} == ${cpuAvailFreqCmpr} ]; then
enableIndices="$enableIndices $cpu"
else
disableIndices="$disableIndices $cpu"
fi
cpu=$(($cpu + 1))
done
# 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=$(( (${cpuMaxFreq} * ${CPU_TARGET_FREQ_PERCENT}) / 100000 ))
chosenFreq=0
for freq in ${cpuAvailFreq}; do
freqMhz=$(( ${freq} / 1000 ))
if [ ${freqMhz} -ge ${TARGET_FREQ_MHZ} ]; then
chosenFreq=${freq}
break
fi
done
# enable 'big' CPUs
for cpu in ${enableIndices}; do
freq=${CPU_BASE}/cpu$cpu/cpufreq
echo 1 > ${CPU_BASE}/cpu${cpu}/online
echo ${chosenFreq} > ${freq}/scaling_max_freq
echo ${chosenFreq} > ${freq}/scaling_min_freq
echo ${chosenFreq} > ${freq}/scaling_setspeed
# 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 / $maxFreq KHz"
echo "Disabled CPUs ${disableIndices// /,}"
echo "=================================="
}
# 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
stop perfd
stop vendor.thermal-engine
stop vendor.perfd
setprop vendor.powerhal.init 0
setprop ctl.interface_restart android.hardware.power@1.0::IPower/default
function_lock_cpu
function_lock_gpu_kgsl
# 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"