src/trace_processor/sched_slice_table.cc - third_party/perfetto - Git at Google

 /*
  * 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) {
   SqliteTable::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", RowAccessor())
       .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->sqlite_omit_order_by = true;
   auto& omit_cs = info->sqlite_omit_constraint;
   std::fill(omit_cs.begin(), omit_cs.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.column == 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.column == 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_table().row_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());
   };
 }

 SqlValue::Type SchedSliceTable::EndStateColumn::GetType() const {
   return SqlValue::Type::kString;
 }

 }  // namespace trace_processor
 }  // namespace perfetto
	/*
	* 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) {
	SqliteTable::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", RowAccessor())
	.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->sqlite_omit_order_by = true;
	auto& omit_cs = info->sqlite_omit_constraint;
	std::fill(omit_cs.begin(), omit_cs.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.column == 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.column == 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_table().row_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());
	};
	}

	SqlValue::Type SchedSliceTable::EndStateColumn::GetType() const {
	return SqlValue::Type::kString;
	}

	} // namespace trace_processor
	} // namespace perfetto