android_system_core/storaged/tools/ranker.py

# Copyright 2017 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.

"""Parser and ranker for dumpsys storaged output.

This module parses output from dumpsys storaged by ranking uids based on
their io usage measured in 8 different stats. It must be provided the input
file through command line argument -i/--input.

For more details, see:
    $ python ranker.py -h

Example:
    $ python ranker.py -i io.txt -o output.txt -u 20 -cnt
"""

import argparse
import sys

IO_NAMES = ["[READ][FOREGROUND][CHARGER_OFF]",
            "[WRITE][FOREGROUND][CHARGER_OFF]",
            "[READ][BACKGROUND][CHARGER_OFF]",
            "[WRITE][BACKGROUND][CHARGER_OFF]",
            "[READ][FOREGROUND][CHARGER_ON]",
            "[WRITE][FOREGROUND][CHARGER_ON]",
            "[READ][BACKGROUND][CHARGER_ON]",
            "[WRITE][BACKGROUND][CHARGER_ON]"]


def get_args():
  """Get arguments from command line.

  The only required argument is input file.

  Returns:
    Args containing cmdline arguments
  """

  parser = argparse.ArgumentParser()
  parser.add_argument("-i", "--input", dest="input", required="true",
                      help="input io FILE, must provide", metavar="FILE")
  parser.add_argument("-o", "--output", dest="output", default="stdout",
                      help="output FILE, default to stdout", metavar="FILE")
  parser.add_argument("-u", "--uidcnt", dest="uidcnt", type=int, default=10,
                      help="set number of uids to display for each rank, "
                      "default 10")
  parser.add_argument("-c", "--combine", dest="combine", default=False,
                      action="store_true", help="add io stats for same uids, "
                      "default to take io stats of last appearing uids")
  parser.add_argument("-n", "--native", dest="native", default=False,
                      action="store_true", help="only include native apps in "
                      "ranking, default to include all apps")
  parser.add_argument("-t", "--task", dest="task", default=False,
                      action="store_true", help="display task io under uids, "
                      "default to not display tasks")
  return parser.parse_args()


def is_number(word):
  try:
    int(word)
    return True
  except ValueError:
    return False


def combine_or_filter(args):
  """Parser for io input.

  Either args.combine io stats for the same uids
  or take the io stats for the last uid and ignore
  the same uids before it.

  If task is required, store task ios along with uid
  for later display.

  Returns:
    The structure for the return value uids is as follows:
    uids: {uid -> [UID_STATS, TASK_STATS(optional)]}
    UID_STATS: [io1, io2, ..., io8]
    TASK_STATS: {task_name -> [io1, io2, ..., io8]}
  """
  fin = open(args.input, "r")
  uids = {}
  cur_uid = 0
  task_enabled = args.task
  for line in fin:
    words = line.split()
    if words[0] == "->":
      # task io
      if not task_enabled:
        continue
      # get task command line
      i = len(words) - 8
      task = " ".join(words[1:i])
      if task in uids[cur_uid][1]:
        task_io = uids[cur_uid][1][task]
        for j in range(8):
          task_io[j] += long(words[i+j])
      else:
        task_io = []
        for j in range(8):
          task_io.append(long(words[i+j]))
      uids[cur_uid][1][task] = task_io

    elif len(words) > 8:
      if not is_number(words[0]) and args.native:
        # uid not requested, ignore its tasks as well
        task_enabled = False
        continue
      task_enabled = args.task
      i = len(words) - 8
      uid = " ".join(words[:i])
      if uid in uids and args.combine:
        uid_io = uids[uid][0]
        for j in range(8):
          uid_io[j] += long(words[i+j])
        uids[uid][0] = uid_io
      else:
        uid_io = [long(words[i+j]) for j in range(8)]
        uids[uid] = [uid_io]
        if task_enabled:
          uids[uid].append({})
      cur_uid = uid

  return uids


def rank_uids(uids):
  """Sort uids based on eight different io stats.

  Returns:
    uid_rank is a 2d list of tuples:
    The first dimension represent the 8 different io stats.
    The second dimension is a sorted list of tuples by tup[0],
    each tuple is a uid's perticular stat at the first dimension and the uid.
  """
  uid_rank = [[(uids[uid][0][i], uid) for uid in uids] for i in range(8)]
  for i in range(8):
    uid_rank[i].sort(key=lambda tup: tup[0], reverse=True)
  return uid_rank


def display_uids(uid_rank, uids, args):
  """Display ranked uid io, along with task io if specified."""
  fout = sys.stdout
  if args.output != "stdout":
    fout = open(args.output, "w")

  for i in range(8):
    fout.write("RANKING BY " + IO_NAMES[i] + "\n")
    for j in range(min(args.uidcnt, len(uid_rank[0]))):
      uid = uid_rank[i][j][1]
      uid_stat = " ".join([str(uid_io) for uid_io in uids[uid][0]])
      fout.write(uid + " " + uid_stat + "\n")
      if args.task:
        for task in uids[uid][1]:
          task_stat = " ".join([str(task_io) for task_io in uids[uid][1][task]])
          fout.write("-> " + task + " " + task_stat + "\n")
      fout.write("\n")


def main():
  args = get_args()
  uids = combine_or_filter(args)
  uid_rank = rank_uids(uids)
  display_uids(uid_rank, uids, args)

if __name__ == "__main__":
  main()