diff --git a/tools/batch_trace_processor/main.py b/tools/batch_trace_processor/main.py
deleted file mode 100644
index 651247d..0000000
--- a/tools/batch_trace_processor/main.py
+++ /dev/null
@@ -1,140 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (C) 2021 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.
-""" Given a trace file, gives the self-time of userspace slices broken
-down by process, thread and thread state.
-"""
-
-import argparse
-import cmd
-import logging
-import numpy as np
-import pandas as pd
-import plotille
-
-from perfetto.batch_trace_processor.api import BatchTraceProcessor, BatchTraceProcessorConfig
-from perfetto.trace_processor import TraceProcessorException, TraceProcessorConfig
-from typing import List
-
-
-class TpBatchShell(cmd.Cmd):
-
-  def __init__(self, files: List[str], batch_tp: BatchTraceProcessor):
-    super().__init__()
-    self.files = files
-    self.batch_tp = batch_tp
-
-  def do_table(self, arg: str):
-    try:
-      data = self.batch_tp.query_and_flatten(arg)
-      print(data)
-    except TraceProcessorException as ex:
-      logging.error("Query failed: {}".format(ex))
-
-  def do_histogram(self, arg: str):
-    try:
-      data = self.batch_tp.query_single_result(arg)
-      print(plotille.histogram(data))
-      self.print_percentiles(data)
-    except TraceProcessorException as ex:
-      logging.error("Query failed: {}".format(ex))
-
-  def do_vhistogram(self, arg: str):
-    try:
-      data = self.batch_tp.query_single_result(arg)
-      print(plotille.hist(data))
-      self.print_percentiles(data)
-    except TraceProcessorException as ex:
-      logging.error("Query failed: {}".format(ex))
-
-  def do_count(self, arg: str):
-    try:
-      data = self.batch_tp.query_single_result(arg)
-      counts = dict()
-      for i in data:
-        counts[i] = counts.get(i, 0) + 1
-      print(counts)
-    except TraceProcessorException as ex:
-      logging.error("Query failed: {}".format(ex))
-
-  def do_close(self, _):
-    return True
-
-  def do_quit(self, _):
-    return True
-
-  def do_EOF(self, _):
-    print("")
-    return True
-
-  def print_percentiles(self, data):
-    percentiles = [25, 50, 75, 95, 99, 99.9]
-    nearest = np.percentile(data, percentiles, interpolation='nearest')
-    logging.info("Representative traces for percentiles")
-    for i, near in enumerate(nearest):
-      print("{}%: {}".format(percentiles[i], self.files[data.index(near)]))
-
-
-def main():
-  parser = argparse.ArgumentParser()
-  parser.add_argument('--shell-path', default=None)
-  parser.add_argument('--verbose', action='store_true', default=False)
-  parser.add_argument('--file-list', default=None)
-  parser.add_argument('--query-file', default=None)
-  parser.add_argument('--interactive', default=None)
-  parser.add_argument('files', nargs='*')
-  args = parser.parse_args()
-
-  logging.basicConfig(level=logging.DEBUG)
-
-  files = args.files
-  if args.file_list:
-    with open(args.file_list, 'r') as f:
-      files += f.read().splitlines()
-
-  if not files:
-    logging.info("At least one file must be specified in files or file list")
-
-  logging.info('Loading traces...')
-  config = BatchTraceProcessorConfig(
-      tp_config=TraceProcessorConfig(
-          bin_path=args.shell_path,
-          verbose=args.verbose,
-      ))
-
-  with BatchTraceProcessor(files, config) as batch_tp:
-    if args.query_file:
-      logging.info('Running query file...')
-
-      with open(args.query_file, 'r') as f:
-        queries_str = f.read()
-
-      queries = [q.strip() for q in queries_str.split(";\n")]
-      for q in queries[:-1]:
-        batch_tp.query(q)
-
-      res = batch_tp.query_and_flatten(queries[-1])
-      print(res.to_csv(index=False))
-
-    if args.interactive or not args.query_file:
-      try:
-        TpBatchShell(files, batch_tp).cmdloop()
-      except KeyboardInterrupt:
-        pass
-
-    logging.info("Closing; please wait...")
-
-
-if __name__ == '__main__':
-  exit(main())
diff --git a/tools/batch_trace_processor/perfetto/batch_trace_processor/__init__.py b/tools/batch_trace_processor/perfetto/batch_trace_processor/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/tools/batch_trace_processor/perfetto/batch_trace_processor/__init__.py
+++ /dev/null
diff --git a/tools/batch_trace_processor/perfetto/batch_trace_processor/api.py b/tools/batch_trace_processor/perfetto/batch_trace_processor/api.py
deleted file mode 100644
index dcd640c..0000000
--- a/tools/batch_trace_processor/perfetto/batch_trace_processor/api.py
+++ /dev/null
@@ -1,309 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (C) 2021 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.
-
-
-"""Contains classes for BatchTraceProcessor API."""
-
-from concurrent.futures.thread import ThreadPoolExecutor
-import dataclasses as dc
-import multiprocessing
-from typing import Any, Callable, Dict, Optional, Tuple, Union, List
-from numpy.lib.npyio import load
-
-import pandas as pd
-
-from perfetto.trace_processor import LoadableTrace
-from perfetto.trace_processor import TraceProcessor
-from perfetto.trace_processor import TraceProcessorException
-from perfetto.trace_processor import TraceProcessorConfig
-
-
-@dc.dataclass
-class BatchLoadableTrace:
-  trace: LoadableTrace
-  args: Dict[str, str]
-
-
-@dc.dataclass
-class BatchTraceProcessorConfig:
-  TraceProvider = Callable[[str], List[
-      Union[LoadableTrace, BatchLoadableTrace]]]
-
-  tp_config: TraceProcessorConfig
-
-  query_executor: Optional[ThreadPoolExecutor]
-  load_executor: Optional[ThreadPoolExecutor]
-
-  trace_provider: TraceProvider
-
-  def __default_trace_provider(custom_string: str):
-    del custom_string
-    raise TraceProcessorException(
-        'Passed a string to batch trace processor constructor without '
-        'a trace provider being registered.')
-
-  def __init__(self,
-               tp_config: TraceProcessorConfig = TraceProcessorConfig(),
-               query_executor: Optional[ThreadPoolExecutor] = None,
-               load_executor: Optional[ThreadPoolExecutor] = None,
-               trace_provider: TraceProvider = __default_trace_provider):
-    self.tp_config = tp_config
-
-    self.query_executor = query_executor
-    self.load_executor = load_executor
-
-    self.trace_provider = trace_provider
-
-    try:
-      # This is the only place in batch trace processor which should import
-      # from a "vendor" namespace - the purpose of this code is to allow
-      # for users to set their own "default" config for batch trace processor
-      # without needing to specify the config in every place when batch
-      # trace processor is used.
-      from .vendor import override_batch_tp_config
-      override_batch_tp_config(self)
-    except ModuleNotFoundError:
-      pass
-
-
-class BatchTraceProcessor:
-  """Run ad-hoc SQL queries across many Perfetto traces.
-
-  Usage:
-    with BatchTraceProcessor(traces) as btp:
-      dfs = btp.query('select * from slice')
-      for df in dfs:
-        print(df)
-  """
-
-  def __init__(
-      self,
-      traces: Union[str, List[Union[LoadableTrace, BatchLoadableTrace]]],
-      config: BatchTraceProcessorConfig = BatchTraceProcessorConfig()):
-    """Creates a batch trace processor instance.
-
-    BatchTraceProcessor is the blessed way of running ad-hoc queries in
-    Python across many traces.
-
-    Args:
-      traces: Either a list of traces or a custom string which will be
-        converted to a list of traces.
-
-        If a list, each item can be one of the following types:
-        1) path to a trace file to open and read
-        2) a file like object (file, io.BytesIO or similar) to read
-        3) a generator yielding bytes
-        4) a BatchLoadableTrace object; this is basically a wrapper around
-           one of the above types plus an args field; see |query_and_flatten|
-           for the motivation for the args field.
-
-        If a string, it is passed to BatchTraceProcessorConfig.trace_provider to
-        convert to a list of traces; the default implementation of this
-        function just throws an exception so an implementation must be provided
-        if strings will be passed.
-      config: configuration options which customize functionality of batch
-        trace processor and underlying trace processors.
-    """
-
-    def _create_batch_trace(x: Union[LoadableTrace, BatchLoadableTrace]
-                           ) -> BatchLoadableTrace:
-      if isinstance(x, BatchLoadableTrace):
-        return x
-      return BatchLoadableTrace(trace=x, args={})
-
-    def create_tp(trace: BatchLoadableTrace) -> TraceProcessor:
-      return TraceProcessor(trace=trace.trace, config=config.tp_config)
-
-    if isinstance(traces, str):
-      trace_list = config.trace_provider(traces)
-    else:
-      trace_list = traces
-
-    batch_traces = [_create_batch_trace(t) for t in trace_list]
-
-    # As trace processor is completely CPU bound, it makes sense to just
-    # max out the CPUs available.
-    query_executor = config.query_executor or ThreadPoolExecutor(
-        max_workers=multiprocessing.cpu_count())
-    load_exectuor = config.load_executor or query_executor
-
-    self.tps = None
-    self.closed = False
-    self.query_executor = query_executor
-    self.args = [t.args for t in batch_traces]
-    self.tps = list(load_exectuor.map(create_tp, batch_traces))
-
-  def metric(self, metrics: List[str]):
-    """Computes the provided metrics.
-
-    The computation happens in parallel across all the traces.
-
-    Args:
-      metrics: A list of valid metrics as defined in TraceMetrics
-
-    Returns:
-      A list of TraceMetric protos (one for each trace).
-    """
-    return self.execute(lambda tp: tp.metric(metrics))
-
-  def query(self, sql: str):
-    """Executes the provided SQL statement (returning a single row).
-
-    The execution happens in parallel across all the traces.
-
-    Args:
-      sql: The SQL statement to execute.
-
-    Returns:
-      A list of Pandas dataframes with the result of executing the query (one
-      per trace).
-
-    Raises:
-      TraceProcessorException: An error occurred running the query.
-    """
-    return self.execute(lambda tp: tp.query(sql).as_pandas_dataframe())
-
-  def query_and_flatten(self, sql: str):
-    """Executes the provided SQL statement and flattens the result.
-
-    The execution happens in parallel across all the traces and the
-    resulting Pandas dataframes are flattened into a single dataframe.
-
-    Args:
-      sql: The SQL statement to execute.
-
-    Returns:
-      A concatenated Pandas dataframe containing the result of executing the
-      query across all the traces.
-
-      If |BatchLoadableTrace| objects were passed to the constructor, the
-      contents of the |args| dictionary will also be emitted as extra columns
-      (key being column name, value being the value in the dataframe).
-
-      For example:
-        traces = [BatchLoadableTrace(trace='/tmp/path', args={"foo": "bar"})]
-        with BatchTraceProcessor(traces) as btp:
-          df = btp.query_and_flatten('select count(1) as cnt from slice')
-
-      Then df will look like this:
-        cnt             foo
-        100             bar
-
-    Raises:
-      TraceProcessorException: An error occurred running the query.
-    """
-    return self.execute_and_flatten(lambda tp: tp.query(sql).
-                                    as_pandas_dataframe())
-
-  def query_single_result(self, sql: str):
-    """Executes the provided SQL statement (returning a single row).
-
-    The execution happens in parallel across all the traces.
-
-    Args:
-      sql: The SQL statement to execute. This statement should return exactly
-        one row on any trace.
-
-    Returns:
-      A list of values with the result of executing the query (one per trace).
-
-    Raises:
-      TraceProcessorException: An error occurred running the query or more than
-        one result was returned.
-    """
-
-    def query_single_result_inner(tp):
-      df = tp.query(sql).as_pandas_dataframe()
-      if len(df.index) != 1:
-        raise TraceProcessorException("Query should only return a single row")
-
-      if len(df.columns) != 1:
-        raise TraceProcessorException(
-            "Query should only return a single column")
-
-      return df.iloc[0, 0]
-
-    return self.execute(query_single_result_inner)
-
-  def execute(self, fn: Callable[[TraceProcessor], Any]) -> List[Any]:
-    """Executes the provided function.
-
-    The execution happens in parallel across all the trace processor instances
-    owned by this object.
-
-    Args:
-      fn: The function to execute.
-
-    Returns:
-      A list of values with the result of executing the fucntion (one per
-      trace).
-    """
-    return list(self.query_executor.map(fn, self.tps))
-
-  def execute_and_flatten(self, fn: Callable[[TraceProcessor], pd.DataFrame]
-                         ) -> pd.DataFrame:
-    """Executes the provided function and flattens the result.
-
-    The execution happens in parallel across all the trace processor
-    instances owned by this object and the returned Pandas dataframes are
-    flattened into a single dataframe.
-
-    Args:
-      fn: The function to execute which returns a Pandas dataframe.
-
-    Returns:
-      A Pandas dataframe containing the result of executing the query across all
-      the traces. Extra columns containing the file path and args will
-      be added to the dataframe (see |query_and_flatten| for details).
-    """
-
-    def wrapped(pair: Tuple[TraceProcessor, BatchLoadableTrace]):
-      (tp, args) = pair
-      df = fn(tp)
-      for key, value in args.items():
-        df[key] = value
-      return df
-
-    df = pd.concat(
-        list(self.query_executor.map(wrapped, zip(self.tps, self.args))))
-    return df.reset_index(drop=True)
-
-  def close(self):
-    """Closes this batch trace processor instance.
-
-    This closes all spawned trace processor instances, releasing all the memory
-    and resources those instances take.
-
-    No further calls to other methods in this class should be made after
-    calling this method.
-    """
-    if self.closed:
-      return
-    self.closed = True
-
-    if self.tps:
-      for tp in self.tps:
-        tp.close()
-
-  def __enter__(self):
-    return self
-
-  def __exit__(self, a, b, c):
-    del a, b, c  # Unused.
-    self.close()
-    return False
-
-  def __del__(self):
-    self.close()
diff --git a/tools/gen_binary_descriptors b/tools/gen_binary_descriptors
index 5388c48..dbbf8c7 100755
--- a/tools/gen_binary_descriptors
+++ b/tools/gen_binary_descriptors
@@ -26,10 +26,10 @@
 
 SOURCE_TARGET = [
     ('protos/perfetto/trace_processor/trace_processor.proto',
-     'src/trace_processor/python/perfetto/trace_processor/trace_processor.descriptor'
+     'python/perfetto/trace_processor/trace_processor.descriptor'
     ),
     ('protos/perfetto/metrics/metrics.proto',
-     'src/trace_processor/python/perfetto/trace_processor/metrics.descriptor'),
+     'python/perfetto/trace_processor/metrics.descriptor'),
 ]
 
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
diff --git a/tools/run_python_api_tests.py b/tools/run_python_api_tests.py
deleted file mode 100755
index 78a78a1..0000000
--- a/tools/run_python_api_tests.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (C) 2020 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.
-
-import argparse
-import os
-import sys
-import unittest
-
-ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-
-def main():
-  try:
-    import numpy
-    import pandas
-  except ModuleNotFoundError:
-    print('Cannot proceed. Please `pip3 install pandas numpy`', file=sys.stderr)
-    return 1
-
-  # Append test and src paths so that all imports are loaded in correctly
-  sys.path.append(os.path.join(ROOT_DIR, 'test', 'trace_processor', 'python'))
-  sys.path.append(
-      os.path.join(ROOT_DIR, 'src', 'trace_processor', 'python', 'perfetto'))
-  import api_unittest
-  import api_integrationtest
-
-  # Set paths to trace_processor_shell and root directory as environment
-  # variables
-  parser = argparse.ArgumentParser()
-  parser.add_argument("shell", type=str)
-  os.environ["SHELL_PATH"] = parser.parse_args().shell
-  os.environ["ROOT_DIR"] = ROOT_DIR
-
-  # Initialise test suite
-  loader = unittest.TestLoader()
-  suite = unittest.TestSuite()
-
-  # Add all relevant tests to test suite
-  suite.addTests(loader.loadTestsFromModule(api_unittest))
-  suite.addTests(loader.loadTestsFromModule(api_integrationtest))
-
-  # Initialise runner to run all tests in suite
-  runner = unittest.TextTestRunner(verbosity=3)
-  result = runner.run(suite)
-
-  return 0 if result.wasSuccessful() else 1
-
-
-if __name__ == '__main__':
-  sys.exit(main())
diff --git a/tools/slice_breakdown/main.py b/tools/slice_breakdown/main.py
deleted file mode 100644
index f6a4c4c..0000000
--- a/tools/slice_breakdown/main.py
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (C) 2021 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.
-""" Given a trace file, gives the self-time of userspace slices broken
-down by process, thread and thread state.
-"""
-
-import argparse
-import sys
-
-from perfetto.slice_breakdown import compute_breakdown
-from perfetto.slice_breakdown import compute_breakdown_for_startup
-from perfetto.trace_processor import TraceProcessor
-from perfetto.trace_processor import TraceProcessorConfig
-
-
-def compute_breakdown_wrapper(args):
-  config = TraceProcessorConfig(bin_path=args.shell_path, verbose=args.verbose)
-  with TraceProcessor(trace=args.file, config=config) as tp:
-    if args.startup_bounds:
-      breakdown = compute_breakdown_for_startup(tp, args.startup_package,
-                                                args.process_name)
-    else:
-      breakdown = compute_breakdown(tp, args.start_ts, args.end_ts,
-                                    args.process_name)
-  return breakdown
-
-
-def main():
-  parser = argparse.ArgumentParser()
-  parser.add_argument('--file', required=True)
-  parser.add_argument('--shell-path', default=None)
-  parser.add_argument('--start-ts', default=None)
-  parser.add_argument('--end-ts', default=None)
-  parser.add_argument('--startup-bounds', action='store_true', default=False)
-  parser.add_argument('--startup-package', default=None)
-  parser.add_argument('--process-name', default=None)
-  parser.add_argument('--verbose', action='store_true', default=False)
-  parser.add_argument('--out-csv', required=True)
-  args = parser.parse_args()
-
-  if (args.start_ts or args.end_ts) and args.startup_bounds:
-    print("Cannot specify --start-ts or --end-ts and --startup-bounds")
-    return 1
-
-  if args.startup_package and not args.startup_bounds:
-    print("Must specify --startup-bounds if --startup-package is specified")
-    return 1
-
-  breakdown = compute_breakdown_wrapper(args)
-
-  if args.out_csv:
-    diff_csv = breakdown.to_csv(index=False)
-    if args.out_csv == '-':
-      sys.stdout.write(diff_csv)
-    else:
-      with open(args.out_csv, 'w') as out:
-        out.write(diff_csv)
-
-  return 0
-
-
-if __name__ == '__main__':
-  exit(main())
diff --git a/tools/slice_breakdown/perfetto/slice_breakdown/__init__.py b/tools/slice_breakdown/perfetto/slice_breakdown/__init__.py
deleted file mode 100644
index 6e6169f..0000000
--- a/tools/slice_breakdown/perfetto/slice_breakdown/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright (C) 2021 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.
-
-from .breakdown import compute_breakdown, compute_breakdown_for_startup
\ No newline at end of file
diff --git a/tools/slice_breakdown/perfetto/slice_breakdown/breakdown.py b/tools/slice_breakdown/perfetto/slice_breakdown/breakdown.py
deleted file mode 100644
index 85b21d2..0000000
--- a/tools/slice_breakdown/perfetto/slice_breakdown/breakdown.py
+++ /dev/null
@@ -1,186 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (C) 2021 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.
-
-
-def compute_breakdown(tp, start_ts=None, end_ts=None, process_name=None):
-  """For each userspace slice in the trace processor instance |tp|, computes
-  the self-time of that slice grouping by process name, thread name
-  and thread state.
-
-  Args:
-    tp: the trace processor instance to query.
-    start_ts: optional bound to only consider slices after this ts
-    end_ts: optional bound to only consider slices until this ts
-    process_name: optional process name to filter for slices; specifying
-        this argument can make computing the breakdown a lot faster.
-
-  Returns:
-    A Pandas dataframe containing the total self time taken by a slice stack
-    broken down by process name, thread name and thread state.
-  """
-  bounds = tp.query('SELECT * FROM trace_bounds').as_pandas_dataframe()
-  start_ts = start_ts if start_ts else bounds['start_ts'][0]
-  end_ts = end_ts if end_ts else bounds['end_ts'][0]
-
-  tp.query("""
-    DROP VIEW IF EXISTS modded_names
-  """)
-
-  tp.query("""
-    CREATE VIEW modded_names AS
-    SELECT
-      slice.id,
-      slice.depth,
-      slice.stack_id,
-      CASE
-        WHEN slice.name LIKE 'Choreographer#doFrame%'
-          THEN 'Choreographer#doFrame'
-        WHEN slice.name LIKE 'DrawFrames%'
-          THEN 'DrawFrames'
-        WHEN slice.name LIKE '/data/app%.apk'
-          THEN 'APK load'
-        WHEN slice.name LIKE 'OpenDexFilesFromOat%'
-          THEN 'OpenDexFilesFromOat'
-        WHEN slice.name LIKE 'Open oat file%'
-          THEN 'Open oat file'
-        ELSE slice.name
-      END AS modded_name
-    FROM slice
-  """)
-
-  tp.query("""
-    DROP VIEW IF EXISTS thread_slice_stack
-  """)
-
-  tp.query("""
-    CREATE VIEW thread_slice_stack AS
-    SELECT
-      efs.ts,
-      efs.dur,
-      IFNULL(n.stack_id, -1) AS stack_id,
-      t.utid,
-      IIF(efs.source_id IS NULL, '[No slice]', IFNULL(
-        (
-          SELECT GROUP_CONCAT(modded_name, ' > ')
-          FROM (
-            SELECT p.modded_name
-            FROM ancestor_slice(efs.source_id) a
-            JOIN modded_names p ON a.id = p.id
-            ORDER BY p.depth
-          )
-        ) || ' > ' || n.modded_name,
-        n.modded_name
-      )) AS stack_name
-    FROM experimental_flat_slice({}, {}) efs
-    LEFT JOIN modded_names n ON efs.source_id = n.id
-    JOIN thread_track t ON t.id = efs.track_id
-  """.format(start_ts, end_ts))
-
-  tp.query("""
-    DROP TABLE IF EXISTS thread_slice_stack_with_state
-  """)
-
-  tp.query("""
-    CREATE VIRTUAL TABLE thread_slice_stack_with_state
-    USING SPAN_JOIN(
-      thread_slice_stack PARTITIONED utid,
-      thread_state PARTITIONED utid
-    )
-  """)
-
-  if process_name:
-    where_process = "AND process.name = '{}'".format(process_name)
-  else:
-    where_process = ''
-
-  breakdown = tp.query("""
-    SELECT
-      process.name AS process_name,
-      thread.name AS thread_name,
-      CASE
-        WHEN slice.state = 'D' and slice.io_wait
-          THEN 'Uninterruptible sleep (IO)'
-        WHEN slice.state = 'DK' and slice.io_wait
-          THEN 'Uninterruptible sleep + Wake-kill (IO)'
-        WHEN slice.state = 'D' and not slice.io_wait
-          THEN 'Uninterruptible sleep (non-IO)'
-        WHEN slice.state = 'DK' and not slice.io_wait
-          THEN 'Uninterruptible sleep + Wake-kill (non-IO)'
-        WHEN slice.state = 'D'
-          THEN 'Uninterruptible sleep'
-        WHEN slice.state = 'DK'
-          THEN 'Uninterruptible sleep + Wake-kill'
-        WHEN slice.state = 'S' THEN 'Interruptible sleep'
-        WHEN slice.state = 'R' THEN 'Runnable'
-        WHEN slice.state = 'R+' THEN 'Runnable (Preempted)'
-        ELSE slice.state
-      END AS state,
-      slice.stack_name,
-      SUM(slice.dur)/1e6 AS dur_sum,
-      MIN(slice.dur/1e6) AS dur_min,
-      MAX(slice.dur/1e6) AS dur_max,
-      AVG(slice.dur/1e6) AS dur_mean,
-      PERCENTILE(slice.dur/1e6, 50) AS dur_median,
-      PERCENTILE(slice.dur/1e6, 25) AS dur_25_percentile,
-      PERCENTILE(slice.dur/1e6, 75) AS dur_75_percentile,
-      PERCENTILE(slice.dur/1e6, 95) AS dur_95_percentile,
-      PERCENTILE(slice.dur/1e6, 99) AS dur_99_percentile,
-      COUNT(1) as count
-    FROM process
-    JOIN thread USING (upid)
-    JOIN thread_slice_stack_with_state slice USING (utid)
-    WHERE dur != -1 {}
-    GROUP BY thread.name, stack_id, state
-    ORDER BY dur_sum DESC
-  """.format(where_process)).as_pandas_dataframe()
-
-  return breakdown
-
-
-def compute_breakdown_for_startup(tp, package_name=None, process_name=None):
-  """Computes the slice breakdown (like |compute_breakdown|) but only
-  considering slices which happened during an app startup
-
-  Args:
-    tp: the trace processor instance to query.
-    package_name: optional package name to filter for startups. Only a single
-        startup matching this package name should be present. If not specified,
-        only a single startup of any app should be in the trace.
-    process_name: optional process name to filter for slices; specifying
-        this argument can make computing the breakdown a lot faster.
-
-  Returns:
-    The same as |compute_breakdown| but only containing slices which happened
-    during app startup.
-  """
-  tp.metric(['android_startup'])
-
-  # Verify there was only one startup in the trace matching the package
-  # name.
-  filter = "WHERE package = '{}'".format(package_name) if package_name else ''
-  launches = tp.query('''
-    SELECT ts, ts_end, dur
-    FROM launches
-    {}
-  '''.format(filter)).as_pandas_dataframe()
-  if len(launches) == 0:
-    raise Exception("Didn't find startup in trace")
-  if len(launches) > 1:
-    raise Exception("Found multiple startups in trace")
-
-  start = launches['ts'][0]
-  end = launches['ts_end'][0]
-
-  return compute_breakdown(tp, start, end, process_name)