Adds profiling support for non-rooted devices

tools-webrtc/android/profiling/perf_setup.sh

 #!/bin/bash
 
 # Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
 #
 # Use of this source code is governed by a BSD-style license
 # that can be found in the LICENSE file in the root of the source
 # tree. An additional intellectual property rights grant can be found
 # in the file PATENTS.  All contributing project authors may
 # be found in the AUTHORS file in the root of the source tree.
 #
 # Usage:
 #
 #   It is assumed that a release build of AppRTCMobile exists and has been
-#   installed on a rooted and attached Android device.
+#   installed on an Android device which supports USB debugging.
 #
 #   Source this script once from the WebRTC src/ directory and resolve any
 #   reported issues. Add relative path to build directory as parameter.
 #   Required tools will be downloaded if they don't already exist.
 #
 #   Once all tests are passed, a list of available functions will be given.
 #   Use these functions to do the actual profiling and visualization of the
 #   results.
 #
+#   Note that, using a rooted device is recommended since it allows us to
+#   resolve kernel symbols (kallsyms) as well.
+#
 # Example usage:
 #
 #   > . tools-webrtc/android/profiling/perf_setup.sh out/Release
 #   > perf_record 120
 #   > flame_graph
 #   > plot_flame_graph
 #   > perf_cleanup
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
 source "${SCRIPT_DIR}/utilities.sh"
@@ skipping 19 matching lines @@
 
 # Ensure that user includes name of build directory (e.g. out/Release) as
 # input parameter. Store path in BUILD_DIR.
 if [[ "$#" -eq 1 ]]; then
   if is_not_dir "$1"; then
     error "$1 is invalid"
     return 1
   fi
   BUILD_DIR="$1"
 else
-  unset BUILD_DIR
   error "Missing required parameter".
   usage
+  return 1
 fi
 
-# Helper method to simpify usage of the simpleperf binary on the device.
-function simpleperf_android() {
-  local simpleperf="${DEV_TMP_DIR}/simpleperf"
-  if [ ! -z  "$1" ]; then
-    adb shell "${simpleperf}" "$@"
-  else
-    adb shell $simpleperf --help
-  fi
-}
-
 # Full (relative) path to the libjingle_peerconnection_so.so file.
 function native_shared_lib_path() {
   echo "${BUILD_DIR}${NATIVE_LIB_PATH}"
 }
 
 # Target CPU architecture for the native shared library.
 # Example: AArch64.
 function native_shared_lib_arch() {
   readelf -h $(native_shared_lib_path) | grep Machine | awk '{print $2}'
 }
@@ skipping 31 matching lines @@
   adb pull /proc/kallsyms "${symbol_cache}"
 } 1> /dev/null
 
 # Download the correct version of 'simpleperf' to $DEV_TMP_DIR
 # on the device and enable profiling.
 function copy_simpleperf_to_device() {
   local perf_binary
   [[ $(dev_arch) == "aarch64" ]] \
     && perf_binary="/arm64/simpleperf" \
     || perf_binary="/arm/simpleperf"
-  local simpleperf="${DEV_TMP_DIR}/simpleperf"
   # Copy the simpleperf binary from local host to temp folder on device.
   adb push "${SCRIPT_DIR}/simpleperf/bin/android${perf_binary}" \
     "${DEV_TMP_DIR}" 1> /dev/null
-  adb shell chmod a+x $simpleperf
+  # Copy simpleperf from temp folder to the application package.
+  adb shell run-as "${APP_NAME}" cp "${DEV_TMP_DIR}/simpleperf" .
+  adb shell run-as "${APP_NAME}" chmod a+x simpleperf
   # Enable profiling on the device.
   enable_profiling
   # Allows usage of running report commands on the device.
   if image_is_root; then
     enable_report_symbols
   fi
 }
 
 # Copy the recorded 'perf.data' file from the device to the current directory.
 # TODO(henrika): add support for specifying the destination.
 function pull_perf_data_from_device() {
-  adb pull "${DEV_TMP_DIR}/perf.data" .
+  adb shell run-as "${APP_NAME}" cp perf.data /sdcard/perf.data
+  adb pull sdcard/perf.data .
 } 1> /dev/null
 
 
 # Wraps calls to simpleperf report. Used by e.g. perf_report_threads.
 # A valid profile input file must exist in the current folder.
 # TODO(henrika): possibly add support to add path to alternative input file.
 function perf_report() {
   local perf_data="perf.data"
   is_file "${perf_data}" \
     && simpleperf report \
@@ skipping 29 matching lines @@
 # Lists the main available functions after sourcing this script.
 function print_function_help() {
   printf "\nAvailable functions in this shell:\n"
   printf " perf_record [duration, default=60sec]\n"
   printf " perf_report_threads\n"
   printf " perf_report_bins\n"
   printf " perf_report_symbols\n"
   printf " perf_report_graph\n"
   printf " perf_report_graph_callee\n"
   printf " perf_update\n"
-  printf " perf_clean\n"
+  printf " perf_cleanup\n"
   printf " flame_graph\n"
   printf " plot_flame_graph\n"
 }
 
 function cleanup() {
   unset -f main
 }
 
 # -----------------------------------------------------------------------------
 # Main methods to be used after sourcing the main script.
 # -----------------------------------------------------------------------------
 
 # Call this method after the application as been rebuilt and installed on the
 # device to ensure that symbols are up-to-date.
 function perf_update() {
   copy_native_shared_library_to_symbol_cache
-  copy_kernel_symbols_from_device_to_symbol_cache
+  if image_is_root; then
+    copy_kernel_symbols_from_device_to_symbol_cache
+  fi
 }
 
 # Record stack frame based call graphs while using the application.
 # We use default events (cpu-cycles), and write records to 'perf.data' in the
 # tmp folder on the device. Default duration is 60 seconds but it can be changed
 # by adding one parameter. As soon as the recording is done, 'perf.data' is
 # copied to the directory from which this method is called and a summary of
 # the load distribution per thread is printed.
 function perf_record() {
   if app_is_running "${APP_NAME}"; then
     # Ensure that the latest native shared library exists in the local cache.
     copy_native_shared_library_to_symbol_cache
     local duration=60
     if [ "$#" -eq 1 ]; then
       duration="$1"
     fi
     local pid=$(find_app_pid "${APP_NAME}")
     echo "Profiling PID $pid for $duration seconds (media must be is active)..."
-    local output_file="${DEV_TMP_DIR}/perf.data"
-    simpleperf_android record \
+    adb shell run-as "${APP_NAME}" ./simpleperf record \
       --call-graph fp \
       -p "${pid}" \
-      -o $output_file \
       -f 1000 \
       --duration "${duration}" \
       --log error
-    app_stop "${APP_NAME}"
     # Copy profile results from device to current directory.
     pull_perf_data_from_device
     # Print out a summary report (load per thread).
     perf_report_threads | tail -n +6
   else
     # AppRTCMobile was not enabled. Start it up automatically and ask the user
     # to start media and then call this method again.
     warning "AppRTCMobile must be active"
     app_start "${APP_NAME}"
     echo "Start media and then call perf_record again..."
-  fi 2> /dev/null
+  fi
 }
 
 # Analyze the profile report and show samples per threads.
 function perf_report_threads() {
   perf_report --sort comm
 } 2> /dev/null
 
 # Analyze the profile report and show samples per binary.
 function perf_report_bins() {
   perf_report --sort dso
@@ skipping 41 matching lines @@
   fi
   local file_name="flame_graph.svg"
   local title="WebRTC Flame Graph"
   if [[ "$#" -eq 1 ]]; then
     file_name="$1"
   fi
   if [[ "$#" -eq 2 ]]; then
     file_name="$1"
     title="$2"
   fi
-  report_sample.py \
-    --symfs "${SYMBOL_DIR}" \
-    --kallsyms "${SYMBOL_DIR}/kallsyms" \
-    perf.data >out.perf
+  if image_is_not_root; then
+    report_sample.py \
+      --symfs "${SYMBOL_DIR}" \
+      perf.data >out.perf
+  else
+    report_sample.py \
+      --symfs "${SYMBOL_DIR}" \
+      --kallsyms "${SYMBOL_DIR}/kallsyms" \
+      perf.data >out.perf
+  fi
   stackcollapse-perf.pl out.perf >out.folded
   flamegraph.pl --title="${title}" out.folded >"${file_name}"
   rm out.perf
   rm out.folded
 }
 
 # Remove all downloaded third-party tools.
 function perf_cleanup () {
   rm_simpleperf
   rm_flame_graph
@@ skipping 28 matching lines @@
   fi
   ok "adb tool is working"
 
   # Exactly one Android device must be connected.
   if [[ ! one_device_connected ]]; then
     error "one device must be connected"
     return 1
   fi
   ok "one device is connected via USB"
 
-  # Ensure that the device is rooted.
-  if image_is_not_root; then
-    error "device is not rooted"
-    return 1
+  # Restart adb with root permissions if needed.
+  if image_is_root && adb_has_no_root_permissions; then
+    adb root
+    ok "adb is running as root"
   fi
-  ok "device is rooted"
-
-  # Restart adb with root permissions if needed.
-  if adb_has_no_root_permissions; then
-    adb root
-  fi
-  ok "adbd is running as root"
 
   # Create an empty symbol cache in the tmp folder.
   # TODO(henrika): it might not be required to start from a clean cache.
   is_dir "${SYMBOL_DIR}" && rm -rf "${SYMBOL_DIR}"
   mkdir "${SYMBOL_DIR}" \
     && ok "empty symbol cache created at ${SYMBOL_DIR}" \
     || error "failed to create symbol cache"
 
   # Ensure that path to the native library with symbols is valid.
   local native_lib=$(native_shared_lib_path)
@@ skipping 75 matching lines @@
 
   cleanup
 
   return 0
 }
 
 # Only call main() if proper input parameter has been provided.
 if is_set $BUILD_DIR; then
   main "$@"
 fi