src/trace_processor/raw_table.cc - platform/external/perfetto - Gitiles

 /*
  * Copyright (C) 2019 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/raw_table.h"

 #include <inttypes.h>

 #include "src/trace_processor/ftrace_descriptors.h"
 #include "src/trace_processor/sqlite_utils.h"
 #include "src/trace_processor/variadic.h"

 #include "perfetto/trace/ftrace/binder.pbzero.h"
 #include "perfetto/trace/ftrace/clk.pbzero.h"
 #include "perfetto/trace/ftrace/ftrace.pbzero.h"
 #include "perfetto/trace/ftrace/ftrace_event.pbzero.h"
 #include "perfetto/trace/ftrace/sched.pbzero.h"

 namespace perfetto {
 namespace trace_processor {

 RawTable::RawTable(sqlite3* db, const TraceStorage* storage)
     : storage_(storage) {
   auto fn = [](sqlite3_context* ctx, int argc, sqlite3_value** argv) {
     auto* thiz = static_cast<RawTable*>(sqlite3_user_data(ctx));
     thiz->ToSystrace(ctx, argc, argv);
   };
   sqlite3_create_function(db, "to_ftrace", 1,
                           SQLITE_UTF8 | SQLITE_DETERMINISTIC, this, fn, nullptr,
                           nullptr);
 }

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

 StorageSchema RawTable::CreateStorageSchema() {
   const auto& raw = storage_->raw_events();
   return StorageSchema::Builder()
       .AddGenericNumericColumn("id", RowIdAccessor(TableId::kRawEvents))
       .AddOrderedNumericColumn("ts", &raw.timestamps())
       .AddStringColumn("name", &raw.name_ids(), &storage_->string_pool())
       .AddNumericColumn("cpu", &raw.cpus())
       .AddNumericColumn("utid", &raw.utids())
       .AddNumericColumn("arg_set_id", &raw.arg_set_ids())
       .Build({"name", "ts"});
 }

 uint32_t RawTable::RowCount() {
   return static_cast<uint32_t>(storage_->raw_events().raw_event_count());
 }

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

   // Only the string columns are handled by SQLite
   info->order_by_consumed = true;
   size_t name_index = schema().ColumnIndexFromName("name");
   for (size_t i = 0; i < qc.constraints().size(); i++) {
     info->omit[i] = qc.constraints()[i].iColumn != static_cast<int>(name_index);
   }

   return SQLITE_OK;
 }

 void RawTable::FormatSystraceArgs(NullTermStringView event_name,
                                   ArgSetId arg_set_id,
                                   base::StringWriter* writer) {
   const auto& set_ids = storage_->args().set_ids();
   auto lb = std::lower_bound(set_ids.begin(), set_ids.end(), arg_set_id);
   auto ub = std::find(lb, set_ids.end(), arg_set_id + 1);

   auto start_row = static_cast<uint32_t>(std::distance(set_ids.begin(), lb));

   using ValueWriter = std::function<void(const Variadic&)>;
   auto write_value = [this, writer](const Variadic& value) {
     switch (value.type) {
       case Variadic::kInt:
         writer->AppendInt(value.int_value);
         break;
       case Variadic::kReal:
         writer->AppendDouble(value.real_value);
         break;
       case Variadic::kString: {
         const auto& str = storage_->GetString(value.string_value);
         writer->AppendString(str.c_str(), str.size());
       }
     }
   };
   auto write_value_at_index = [this, start_row](uint32_t arg_idx,
                                                 ValueWriter value_fn) {
     value_fn(storage_->args().arg_values()[start_row + arg_idx]);
   };
   auto write_arg = [this, writer, start_row](uint32_t arg_idx,
                                              ValueWriter value_fn) {
     uint32_t arg_row = start_row + arg_idx;
     const auto& args = storage_->args();
     const auto& key = storage_->GetString(args.keys()[arg_row]);
     const auto& value = args.arg_values()[arg_row];

     writer->AppendChar(' ');
     writer->AppendString(key.c_str(), key.size());
     writer->AppendChar('=');
     value_fn(value);
   };

   if (event_name == "sched_switch") {
     using SS = protos::pbzero::SchedSwitchFtraceEvent;
     write_arg(SS::kPrevCommFieldNumber - 1, write_value);
     write_arg(SS::kPrevPidFieldNumber - 1, write_value);
     write_arg(SS::kPrevPrioFieldNumber - 1, write_value);
     write_arg(SS::kPrevStateFieldNumber - 1, [writer](const Variadic& value) {
       auto state = static_cast<uint16_t>(value.int_value);
       writer->AppendString(ftrace_utils::TaskState(state).ToString().data());
     });
     writer->AppendLiteral(" ==>");
     write_arg(SS::kNextCommFieldNumber - 1, write_value);
     write_arg(SS::kNextPidFieldNumber - 1, write_value);
     write_arg(SS::kNextPrioFieldNumber - 1, write_value);
     return;
   } else if (event_name == "sched_wakeup") {
     using SW = protos::pbzero::SchedWakeupFtraceEvent;
     write_arg(SW::kCommFieldNumber - 1, write_value);
     write_arg(SW::kPidFieldNumber - 1, write_value);
     write_arg(SW::kPrioFieldNumber - 1, write_value);
     write_arg(SW::kTargetCpuFieldNumber - 1, [writer](const Variadic& value) {
       writer->AppendPaddedInt<'0', 3>(value.int_value);
     });
     return;
   } else if (event_name == "clock_set_rate") {
     // TODO(lalitm): this is a big hack but the best way to do this now.
     // Doing this requires overhauling how we deal with args by pushing them all
     // to an array and then reading back from that array.

     // We use the string "todo" as the name to stay consistent with old
     // trace_to_text print code.
     writer->AppendString(" todo");
     write_arg(0 /* state */, write_value);
     write_arg(1 /* cpu_id */, write_value);
     return;
   } else if (event_name == "clk_set_rate") {
     using CSR = protos::pbzero::ClkSetRateFtraceEvent;
     writer->AppendLiteral(" ");
     write_value_at_index(CSR::kNameFieldNumber - 1, write_value);
     writer->AppendLiteral(" ");
     write_value_at_index(CSR::kRateFieldNumber - 1, write_value);
     return;
   } else if (event_name == "binder_transaction") {
     using BT = protos::pbzero::BinderTransactionFtraceEvent;
     writer->AppendString(" transaction=");
     write_value_at_index(BT::kDebugIdFieldNumber - 1, write_value);
     writer->AppendString(" dest_node=");
     write_value_at_index(BT::kTargetNodeFieldNumber - 1, write_value);
     writer->AppendString(" dest_proc=");
     write_value_at_index(BT::kToProcFieldNumber - 1, write_value);
     writer->AppendString(" dest_thread=");
     write_value_at_index(BT::kToThreadFieldNumber - 1, write_value);
     write_arg(BT::kReplyFieldNumber - 1, write_value);
     writer->AppendString(" flags=0x");
     write_value_at_index(
         BT::kFlagsFieldNumber - 1, [writer](const Variadic& value) {
           writer->AppendHexInt(static_cast<uint32_t>(value.int_value));
         });
     writer->AppendString(" code=0x");
     write_value_at_index(
         BT::kCodeFieldNumber - 1, [writer](const Variadic& value) {
           writer->AppendHexInt(static_cast<uint32_t>(value.int_value));
         });
     return;
   } else if (event_name == "binder_transaction_alloc_buf") {
     using BTAB = protos::pbzero::BinderTransactionAllocBufFtraceEvent;
     writer->AppendString(" transaction=");
     write_value_at_index(BTAB::kDebugIdFieldNumber - 1, write_value);
     write_arg(BTAB::kDataSizeFieldNumber - 1, write_value);
     write_arg(BTAB::kOffsetsSizeFieldNumber - 1, write_value);
     return;
   } else if (event_name == "binder_transaction_received") {
     using BTR = protos::pbzero::BinderTransactionReceivedFtraceEvent;
     writer->AppendString(" transaction=");
     write_value_at_index(BTR::kDebugIdFieldNumber - 1, write_value);
     return;
   } else if (event_name == "print") {
     using P = protos::pbzero::PrintFtraceEvent;

     uint32_t arg_row = start_row + P::kBufFieldNumber - 1;
     const auto& args = storage_->args();
     const auto& value = args.arg_values()[arg_row];
     const auto& str = storage_->GetString(value.string_value);
     // If the last character is a newline in a print, just drop it.
     auto chars_to_print = !str.empty() && str.c_str()[str.size() - 1] == '\n'
                               ? str.size() - 1
                               : str.size();
     writer->AppendChar(' ');
     writer->AppendString(str.c_str(), chars_to_print);
     return;
   }

   uint32_t arg = 0;
   for (auto it = lb; it != ub; it++) {
     write_arg(arg++, write_value);
   }
 }

 void RawTable::ToSystrace(sqlite3_context* ctx,
                           int argc,
                           sqlite3_value** argv) {
   if (argc != 1 || sqlite3_value_type(argv[0]) != SQLITE_INTEGER) {
     sqlite3_result_error(ctx, "Usage: to_ftrace(id)", -1);
     return;
   }
   RowId row_id = sqlite3_value_int64(argv[0]);
   auto pair = TraceStorage::ParseRowId(row_id);
   PERFETTO_DCHECK(pair.first == TableId::kRawEvents);
   auto row = pair.second;

   const auto& raw_evts = storage_->raw_events();

   UniqueTid utid = raw_evts.utids()[row];
   const auto& thread = storage_->GetThread(utid);
   uint32_t tgid = 0;
   if (thread.upid.has_value()) {
     tgid = storage_->GetProcess(thread.upid.value()).pid;
   }
   const auto& name = storage_->GetString(thread.name_id);

   char line[4096];
   base::StringWriter writer(line, sizeof(line));

   ftrace_utils::FormatSystracePrefix(raw_evts.timestamps()[row],
                                      raw_evts.cpus()[row], thread.tid, tgid,
                                      base::StringView(name), &writer);

   const auto& event_name = storage_->GetString(raw_evts.name_ids()[row]);
   writer.AppendChar(' ');
   if (event_name == "print") {
     writer.AppendString("tracing_mark_write");
   } else {
     writer.AppendString(event_name.c_str(), event_name.size());
   }
   writer.AppendChar(':');

   FormatSystraceArgs(event_name, raw_evts.arg_set_ids()[row], &writer);
   sqlite3_result_text(ctx, writer.CreateStringCopy(), -1, free);
 }

 }  // namespace trace_processor
 }  // namespace perfetto
	/*
	* Copyright (C) 2019 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/raw_table.h"

	#include <inttypes.h>

	#include "src/trace_processor/ftrace_descriptors.h"
	#include "src/trace_processor/sqlite_utils.h"
	#include "src/trace_processor/variadic.h"

	#include "perfetto/trace/ftrace/binder.pbzero.h"
	#include "perfetto/trace/ftrace/clk.pbzero.h"
	#include "perfetto/trace/ftrace/ftrace.pbzero.h"
	#include "perfetto/trace/ftrace/ftrace_event.pbzero.h"
	#include "perfetto/trace/ftrace/sched.pbzero.h"

	namespace perfetto {
	namespace trace_processor {

	RawTable::RawTable(sqlite3* db, const TraceStorage* storage)
	: storage_(storage) {
	auto fn = [](sqlite3_context* ctx, int argc, sqlite3_value** argv) {
	auto* thiz = static_cast<RawTable*>(sqlite3_user_data(ctx));
	thiz->ToSystrace(ctx, argc, argv);
	};
	sqlite3_create_function(db, "to_ftrace", 1,
	SQLITE_UTF8 \| SQLITE_DETERMINISTIC, this, fn, nullptr,
	nullptr);
	}

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

	StorageSchema RawTable::CreateStorageSchema() {
	const auto& raw = storage_->raw_events();
	return StorageSchema::Builder()
	.AddGenericNumericColumn("id", RowIdAccessor(TableId::kRawEvents))
	.AddOrderedNumericColumn("ts", &raw.timestamps())
	.AddStringColumn("name", &raw.name_ids(), &storage_->string_pool())
	.AddNumericColumn("cpu", &raw.cpus())
	.AddNumericColumn("utid", &raw.utids())
	.AddNumericColumn("arg_set_id", &raw.arg_set_ids())
	.Build({"name", "ts"});
	}

	uint32_t RawTable::RowCount() {
	return static_cast<uint32_t>(storage_->raw_events().raw_event_count());
	}

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

	// Only the string columns are handled by SQLite
	info->order_by_consumed = true;
	size_t name_index = schema().ColumnIndexFromName("name");
	for (size_t i = 0; i < qc.constraints().size(); i++) {
	info->omit[i] = qc.constraints()[i].iColumn != static_cast<int>(name_index);
	}

	return SQLITE_OK;
	}

	void RawTable::FormatSystraceArgs(NullTermStringView event_name,
	ArgSetId arg_set_id,
	base::StringWriter* writer) {
	const auto& set_ids = storage_->args().set_ids();
	auto lb = std::lower_bound(set_ids.begin(), set_ids.end(), arg_set_id);
	auto ub = std::find(lb, set_ids.end(), arg_set_id + 1);

	auto start_row = static_cast<uint32_t>(std::distance(set_ids.begin(), lb));

	using ValueWriter = std::function<void(const Variadic&)>;
	auto write_value = [this, writer](const Variadic& value) {
	switch (value.type) {
	case Variadic::kInt:
	writer->AppendInt(value.int_value);
	break;
	case Variadic::kReal:
	writer->AppendDouble(value.real_value);
	break;
	case Variadic::kString: {
	const auto& str = storage_->GetString(value.string_value);
	writer->AppendString(str.c_str(), str.size());
	}
	}
	};
	auto write_value_at_index = [this, start_row](uint32_t arg_idx,
	ValueWriter value_fn) {
	value_fn(storage_->args().arg_values()[start_row + arg_idx]);
	};
	auto write_arg = [this, writer, start_row](uint32_t arg_idx,
	ValueWriter value_fn) {
	uint32_t arg_row = start_row + arg_idx;
	const auto& args = storage_->args();
	const auto& key = storage_->GetString(args.keys()[arg_row]);
	const auto& value = args.arg_values()[arg_row];

	writer->AppendChar(' ');
	writer->AppendString(key.c_str(), key.size());
	writer->AppendChar('=');
	value_fn(value);
	};

	if (event_name == "sched_switch") {
	using SS = protos::pbzero::SchedSwitchFtraceEvent;
	write_arg(SS::kPrevCommFieldNumber - 1, write_value);
	write_arg(SS::kPrevPidFieldNumber - 1, write_value);
	write_arg(SS::kPrevPrioFieldNumber - 1, write_value);
	write_arg(SS::kPrevStateFieldNumber - 1, [writer](const Variadic& value) {
	auto state = static_cast<uint16_t>(value.int_value);
	writer->AppendString(ftrace_utils::TaskState(state).ToString().data());
	});
	writer->AppendLiteral(" ==>");
	write_arg(SS::kNextCommFieldNumber - 1, write_value);
	write_arg(SS::kNextPidFieldNumber - 1, write_value);
	write_arg(SS::kNextPrioFieldNumber - 1, write_value);
	return;
	} else if (event_name == "sched_wakeup") {
	using SW = protos::pbzero::SchedWakeupFtraceEvent;
	write_arg(SW::kCommFieldNumber - 1, write_value);
	write_arg(SW::kPidFieldNumber - 1, write_value);
	write_arg(SW::kPrioFieldNumber - 1, write_value);
	write_arg(SW::kTargetCpuFieldNumber - 1, [writer](const Variadic& value) {
	writer->AppendPaddedInt<'0', 3>(value.int_value);
	});
	return;
	} else if (event_name == "clock_set_rate") {
	// TODO(lalitm): this is a big hack but the best way to do this now.
	// Doing this requires overhauling how we deal with args by pushing them all
	// to an array and then reading back from that array.

	// We use the string "todo" as the name to stay consistent with old
	// trace_to_text print code.
	writer->AppendString(" todo");
	write_arg(0 /* state */, write_value);
	write_arg(1 /* cpu_id */, write_value);
	return;
	} else if (event_name == "clk_set_rate") {
	using CSR = protos::pbzero::ClkSetRateFtraceEvent;
	writer->AppendLiteral(" ");
	write_value_at_index(CSR::kNameFieldNumber - 1, write_value);
	writer->AppendLiteral(" ");
	write_value_at_index(CSR::kRateFieldNumber - 1, write_value);
	return;
	} else if (event_name == "binder_transaction") {
	using BT = protos::pbzero::BinderTransactionFtraceEvent;
	writer->AppendString(" transaction=");
	write_value_at_index(BT::kDebugIdFieldNumber - 1, write_value);
	writer->AppendString(" dest_node=");
	write_value_at_index(BT::kTargetNodeFieldNumber - 1, write_value);
	writer->AppendString(" dest_proc=");
	write_value_at_index(BT::kToProcFieldNumber - 1, write_value);
	writer->AppendString(" dest_thread=");
	write_value_at_index(BT::kToThreadFieldNumber - 1, write_value);
	write_arg(BT::kReplyFieldNumber - 1, write_value);
	writer->AppendString(" flags=0x");
	write_value_at_index(
	BT::kFlagsFieldNumber - 1, [writer](const Variadic& value) {
	writer->AppendHexInt(static_cast<uint32_t>(value.int_value));
	});
	writer->AppendString(" code=0x");
	write_value_at_index(
	BT::kCodeFieldNumber - 1, [writer](const Variadic& value) {
	writer->AppendHexInt(static_cast<uint32_t>(value.int_value));
	});
	return;
	} else if (event_name == "binder_transaction_alloc_buf") {
	using BTAB = protos::pbzero::BinderTransactionAllocBufFtraceEvent;
	writer->AppendString(" transaction=");
	write_value_at_index(BTAB::kDebugIdFieldNumber - 1, write_value);
	write_arg(BTAB::kDataSizeFieldNumber - 1, write_value);
	write_arg(BTAB::kOffsetsSizeFieldNumber - 1, write_value);
	return;
	} else if (event_name == "binder_transaction_received") {
	using BTR = protos::pbzero::BinderTransactionReceivedFtraceEvent;
	writer->AppendString(" transaction=");
	write_value_at_index(BTR::kDebugIdFieldNumber - 1, write_value);
	return;
	} else if (event_name == "print") {
	using P = protos::pbzero::PrintFtraceEvent;

	uint32_t arg_row = start_row + P::kBufFieldNumber - 1;
	const auto& args = storage_->args();
	const auto& value = args.arg_values()[arg_row];
	const auto& str = storage_->GetString(value.string_value);
	// If the last character is a newline in a print, just drop it.
	auto chars_to_print = !str.empty() && str.c_str()[str.size() - 1] == '\n'
	? str.size() - 1
	: str.size();
	writer->AppendChar(' ');
	writer->AppendString(str.c_str(), chars_to_print);
	return;
	}

	uint32_t arg = 0;
	for (auto it = lb; it != ub; it++) {
	write_arg(arg++, write_value);
	}
	}

	void RawTable::ToSystrace(sqlite3_context* ctx,
	int argc,
	sqlite3_value** argv) {
	if (argc != 1 \|\| sqlite3_value_type(argv[0]) != SQLITE_INTEGER) {
	sqlite3_result_error(ctx, "Usage: to_ftrace(id)", -1);
	return;
	}
	RowId row_id = sqlite3_value_int64(argv[0]);
	auto pair = TraceStorage::ParseRowId(row_id);
	PERFETTO_DCHECK(pair.first == TableId::kRawEvents);
	auto row = pair.second;

	const auto& raw_evts = storage_->raw_events();

	UniqueTid utid = raw_evts.utids()[row];
	const auto& thread = storage_->GetThread(utid);
	uint32_t tgid = 0;
	if (thread.upid.has_value()) {
	tgid = storage_->GetProcess(thread.upid.value()).pid;
	}
	const auto& name = storage_->GetString(thread.name_id);

	char line[4096];
	base::StringWriter writer(line, sizeof(line));

	ftrace_utils::FormatSystracePrefix(raw_evts.timestamps()[row],
	raw_evts.cpus()[row], thread.tid, tgid,
	base::StringView(name), &writer);

	const auto& event_name = storage_->GetString(raw_evts.name_ids()[row]);
	writer.AppendChar(' ');
	if (event_name == "print") {
	writer.AppendString("tracing_mark_write");
	} else {
	writer.AppendString(event_name.c_str(), event_name.size());
	}
	writer.AppendChar(':');

	FormatSystraceArgs(event_name, raw_evts.arg_set_ids()[row], &writer);
	sqlite3_result_text(ctx, writer.CreateStringCopy(), -1, free);
	}

	} // namespace trace_processor
	} // namespace perfetto