src/trace_processor/sched_slice_table.cc

/*
 * 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.
 */

#include "src/trace_processor/sched_slice_table.h"

namespace perfetto {
namespace trace_processor {

SchedSliceTable::SchedSliceTable(sqlite3*, const TraceStorage* storage)
    : storage_(storage) {}

void SchedSliceTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
  Table::Register<SchedSliceTable>(db, storage, "sched");
}

StorageSchema SchedSliceTable::CreateStorageSchema() {
  const auto& slices = storage_->slices();
  return StorageSchema::Builder()
      .AddOrderedNumericColumn("ts", &slices.start_ns())
      .AddNumericColumn("cpu", &slices.cpus())
      .AddNumericColumn("dur", &slices.durations())
      .AddGenericNumericColumn(
          "ts_end", TsEndAccessor(&slices.start_ns(), &slices.durations()))
      .AddNumericColumn("utid", &slices.utids(), &slices.rows_for_utids())
      .AddColumn<EndStateColumn>("end_state", &slices.end_state())
      .AddNumericColumn("priority", &slices.priorities())
      .AddGenericNumericColumn("row_id", RowIdAccessor(TableId::kSched))
      .Build({"cpu", "ts"});
}

uint32_t SchedSliceTable::RowCount() {
  return static_cast<uint32_t>(storage_->slices().slice_count());
}

int SchedSliceTable::BestIndex(const QueryConstraints& qc,
                               BestIndexInfo* info) {
  info->estimated_cost = EstimateQueryCost(qc);

  // We should be able to handle any constraint and any order by clause given
  // to us.
  info->order_by_consumed = true;
  std::fill(info->omit.begin(), info->omit.end(), true);

  return SQLITE_OK;
}

uint32_t SchedSliceTable::EstimateQueryCost(const QueryConstraints& qc) {
  const auto& cs = qc.constraints();

  size_t ts_idx = schema().ColumnIndexFromName("ts");
  auto has_ts_column = [ts_idx](const QueryConstraints::Constraint& c) {
    return c.iColumn == static_cast<int>(ts_idx);
  };
  bool has_time_constraint = std::any_of(cs.begin(), cs.end(), has_ts_column);
  if (has_time_constraint) {
    // If there is a constraint on ts, we can do queries very fast (O(log n))
    // so always make this preferred if available.
    return 10;
  }

  size_t utid_idx = schema().ColumnIndexFromName("utid");
  auto has_utid_eq_cs = [utid_idx](const QueryConstraints::Constraint& c) {
    return c.iColumn == static_cast<int>(utid_idx) &&
           sqlite_utils::IsOpEq(c.op);
  };
  bool has_utid_eq = std::any_of(cs.begin(), cs.end(), has_utid_eq_cs);
  if (has_utid_eq) {
    // The other column which is often joined on is utid. Sometimes, doing
    // nested subqueries on the thread table is faster but with some queries,
    // it's actually better to do subqueries on this table. Estimate the cost
    // of filtering on utid equality constraint by dividing the number of slices
    // by the number of threads.
    return RowCount() / storage_->thread_count();
  }

  // If we get to this point, we do not have any special filter logic so
  // simply return the number of rows.
  return RowCount();
}

SchedSliceTable::EndStateColumn::EndStateColumn(
    std::string col_name,
    const std::deque<ftrace_utils::TaskState>* deque)
    : StorageColumn(col_name, false), deque_(deque) {
  for (uint16_t i = 0; i < state_strings_.size(); i++) {
    state_strings_[i] = ftrace_utils::TaskState(i).ToString();
  }
}
SchedSliceTable::EndStateColumn::~EndStateColumn() = default;

void SchedSliceTable::EndStateColumn::ReportResult(sqlite3_context* ctx,
                                                   uint32_t row) const {
  const auto& state = (*deque_)[row];
  if (state.is_valid()) {
    PERFETTO_CHECK(state.raw_state() < state_strings_.size());
    sqlite3_result_text(ctx, state_strings_[state.raw_state()].data(), -1,
                        sqlite_utils::kSqliteStatic);
  } else {
    sqlite3_result_null(ctx);
  }
}

void SchedSliceTable::EndStateColumn::Filter(int op,
                                             sqlite3_value* value,
                                             FilteredRowIndex* index) const {
  switch (op) {
    case SQLITE_INDEX_CONSTRAINT_ISNULL:
    case SQLITE_INDEX_CONSTRAINT_ISNOTNULL: {
      bool non_nulls = op == SQLITE_INDEX_CONSTRAINT_ISNOTNULL;
      index->FilterRows([this, non_nulls](uint32_t row) {
        const auto& state = (*deque_)[row];
        return state.is_valid() == non_nulls;
      });
      break;
    }
    case SQLITE_INDEX_CONSTRAINT_EQ:
    case SQLITE_INDEX_CONSTRAINT_NE:
    case SQLITE_INDEX_CONSTRAINT_MATCH:
      FilterOnState(op, value, index);
      break;
    default:
      index->set_error("Unsupported op given to filter on end_state");
      break;
  }
}

void SchedSliceTable::EndStateColumn::FilterOnState(
    int op,
    sqlite3_value* value,
    FilteredRowIndex* index) const {
  if (sqlite3_value_type(value) != SQLITE_TEXT) {
    index->set_error("end_state can only be filtered using strings");
    return;
  }

  const char* str = reinterpret_cast<const char*>(sqlite3_value_text(value));
  ftrace_utils::TaskState compare(str);
  if (!compare.is_valid()) {
    index->set_error("Invalid end_state string given to filter");
    return;
  }

  uint16_t raw_state = compare.raw_state();
  if (op == SQLITE_INDEX_CONSTRAINT_EQ) {
    index->FilterRows([this, raw_state](uint32_t row) {
      const auto& state = (*deque_)[row];
      return state.is_valid() && state.raw_state() == raw_state;
    });
  } else if (op == SQLITE_INDEX_CONSTRAINT_NE) {
    index->FilterRows([this, raw_state](uint32_t row) {
      const auto& state = (*deque_)[row];
      return state.is_valid() && state.raw_state() != raw_state;
    });
  } else if (op == SQLITE_INDEX_CONSTRAINT_MATCH) {
    index->FilterRows([this, compare](uint32_t row) {
      const auto& state = (*deque_)[row];
      if (!state.is_valid())
        return false;
      return (state.raw_state() & compare.raw_state()) == compare.raw_state();
    });
  } else {
    PERFETTO_FATAL("Should never reach this state");
  }
}

StorageColumn::Comparator SchedSliceTable::EndStateColumn::Sort(
    const QueryConstraints::OrderBy& ob) const {
  if (ob.desc) {
    return [this](uint32_t f, uint32_t s) {
      const auto& a = (*deque_)[f];
      const auto& b = (*deque_)[s];
      if (!a.is_valid()) {
        return !b.is_valid() ? 0 : 1;
      } else if (!b.is_valid()) {
        return -1;
      }
      return sqlite_utils::CompareValuesAsc(a.raw_state(), b.raw_state());
    };
  }
  return [this](uint32_t f, uint32_t s) {
    const auto& a = (*deque_)[f];
    const auto& b = (*deque_)[s];
    if (!a.is_valid()) {
      return !b.is_valid() ? 0 : -1;
    } else if (!b.is_valid()) {
      return 1;
    }
    return sqlite_utils::CompareValuesAsc(a.raw_state(), b.raw_state());
  };
}

Table::ColumnType SchedSliceTable::EndStateColumn::GetType() const {
  return Table::ColumnType::kString;
}

}  // namespace trace_processor
}  // namespace perfetto