third_party/perfetto/src/trace_processor/importers/ftrace/virtio_gpu_tracker.cc - cobalt - Git at Google

 /*
  * Copyright (C) 2022 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/importers/ftrace/virtio_gpu_tracker.h"
 #include "perfetto/ext/base/string_utils.h"
 #include "protos/perfetto/trace/ftrace/ftrace_event.pbzero.h"
 #include "protos/perfetto/trace/ftrace/virtio_gpu.pbzero.h"
 #include "src/trace_processor/importers/common/async_track_set_tracker.h"
 #include "src/trace_processor/importers/common/event_tracker.h"
 #include "src/trace_processor/importers/common/slice_tracker.h"
 #include "src/trace_processor/importers/common/track_tracker.h"

 enum virtio_gpu_ctrl_type {
   VIRTIO_GPU_UNDEFINED = 0,

   /* 2d commands */
   VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100,
   VIRTIO_GPU_CMD_RESOURCE_CREATE_2D,
   VIRTIO_GPU_CMD_RESOURCE_UNREF,
   VIRTIO_GPU_CMD_SET_SCANOUT,
   VIRTIO_GPU_CMD_RESOURCE_FLUSH,
   VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D,
   VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING,
   VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING,
   VIRTIO_GPU_CMD_GET_CAPSET_INFO,
   VIRTIO_GPU_CMD_GET_CAPSET,
   VIRTIO_GPU_CMD_GET_EDID,
   VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID,
   VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB,
   VIRTIO_GPU_CMD_SET_SCANOUT_BLOB,

   /* 3d commands */
   VIRTIO_GPU_CMD_CTX_CREATE = 0x0200,
   VIRTIO_GPU_CMD_CTX_DESTROY,
   VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE,
   VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE,
   VIRTIO_GPU_CMD_RESOURCE_CREATE_3D,
   VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D,
   VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D,
   VIRTIO_GPU_CMD_SUBMIT_3D,
   VIRTIO_GPU_CMD_RESOURCE_MAP_BLOB,
   VIRTIO_GPU_CMD_RESOURCE_UNMAP_BLOB,

   /* cursor commands */
   VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300,
   VIRTIO_GPU_CMD_MOVE_CURSOR,

   /* success responses */
   VIRTIO_GPU_RESP_OK_NODATA = 0x1100,
   VIRTIO_GPU_RESP_OK_DISPLAY_INFO,
   VIRTIO_GPU_RESP_OK_CAPSET_INFO,
   VIRTIO_GPU_RESP_OK_CAPSET,
   VIRTIO_GPU_RESP_OK_EDID,
   VIRTIO_GPU_RESP_OK_RESOURCE_UUID,
   VIRTIO_GPU_RESP_OK_MAP_INFO,

   /* error responses */
   VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200,
   VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY,
   VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID,
   VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID,
   VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID,
   VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER,
 };

 static const char* virtio_gpu_ctrl_name(uint32_t type) {
   switch (type) {
 #define ENUM(n)            \
   case VIRTIO_GPU_CMD_##n: \
     return #n
     /* 2d commands */
     ENUM(GET_DISPLAY_INFO);
     ENUM(RESOURCE_CREATE_2D);
     ENUM(RESOURCE_UNREF);
     ENUM(SET_SCANOUT);
     ENUM(RESOURCE_FLUSH);
     ENUM(TRANSFER_TO_HOST_2D);
     ENUM(RESOURCE_ATTACH_BACKING);
     ENUM(RESOURCE_DETACH_BACKING);
     ENUM(GET_CAPSET_INFO);
     ENUM(GET_CAPSET);
     ENUM(GET_EDID);
     ENUM(RESOURCE_ASSIGN_UUID);
     ENUM(RESOURCE_CREATE_BLOB);
     ENUM(SET_SCANOUT_BLOB);

     /* 3d commands */
     ENUM(CTX_CREATE);
     ENUM(CTX_DESTROY);
     ENUM(CTX_ATTACH_RESOURCE);
     ENUM(CTX_DETACH_RESOURCE);
     ENUM(RESOURCE_CREATE_3D);
     ENUM(TRANSFER_TO_HOST_3D);
     ENUM(TRANSFER_FROM_HOST_3D);
     ENUM(SUBMIT_3D);
     ENUM(RESOURCE_MAP_BLOB);
     ENUM(RESOURCE_UNMAP_BLOB);

     /* cursor commands */
     ENUM(UPDATE_CURSOR);
     ENUM(MOVE_CURSOR);
 #undef ENUM
     default:
       return "";
   }
 }

 namespace perfetto {
 namespace trace_processor {

 VirtioGpuTracker::VirtioGpuTracker(TraceProcessorContext* context)
     : virtgpu_control_queue_(context, "Control"),
       virtgpu_cursor_queue_(context, "Cursor") {}

 void VirtioGpuTracker::ParseVirtioGpu(int64_t timestamp,
                                       int32_t field_id,
                                       uint32_t pid,
                                       protozero::ConstBytes blob) {
   using protos::pbzero::FtraceEvent;

   switch (field_id) {
     case FtraceEvent::kVirtioGpuCmdQueueFieldNumber: {
       ParseVirtioGpuCmdQueue(timestamp, pid, blob);
       break;
     }
     case FtraceEvent::kVirtioGpuCmdResponseFieldNumber: {
       ParseVirtioGpuCmdResponse(timestamp, pid, blob);
       break;
     }
     default:
       PERFETTO_DFATAL("Unexpected field id");
       break;
   }
 }
 VirtioGpuTracker::VirtioGpuQueue::VirtioGpuQueue(TraceProcessorContext* context,
                                                  const char* name)
     : context_(context) {
   base::StackString<255> num_free_name("Virtgpu %s Free", name);
   base::StackString<255> latency_name("Virtgpu %s Latency", name);
   base::StackString<255> queue_track_name("Virtgpu %s Queue", name);

   num_free_id_ = context->storage->InternString(num_free_name.string_view());
   latency_id_ = context->storage->InternString(latency_name.string_view());
   queue_track_id_ =
       context->storage->InternString(queue_track_name.string_view());
 }

 void VirtioGpuTracker::VirtioGpuQueue::HandleNumFree(int64_t timestamp,
                                                      uint32_t num_free) {
   TrackId track =
       context_->track_tracker->InternGlobalCounterTrack(num_free_id_);
   context_->event_tracker->PushCounter(timestamp, static_cast<double>(num_free),
                                        track);
 }

 void VirtioGpuTracker::VirtioGpuQueue::HandleCmdQueue(int64_t timestamp,
                                                       uint32_t seqno,
                                                       uint32_t type,
                                                       uint64_t fence_id) {
   auto async_track =
       context_->async_track_set_tracker->InternGlobalTrackSet(queue_track_id_);
   TrackId start_id =
       context_->async_track_set_tracker->Begin(async_track, seqno);

   context_->slice_tracker->Begin(
       timestamp, start_id, kNullStringId,
       context_->storage->InternString(
           base::StringView(virtio_gpu_ctrl_name(type))));

   /* cmds with a fence do not necessarily get an immediate response from
    * the host, so we should not use them for calculating latency:
    */
   if (!fence_id) {
     start_timestamps_[seqno] = timestamp;
   }
 }

 void VirtioGpuTracker::VirtioGpuQueue::HandleCmdResponse(int64_t timestamp,
                                                          uint32_t seqno) {
   auto async_track =
       context_->async_track_set_tracker->InternGlobalTrackSet(queue_track_id_);
   TrackId end_id = context_->async_track_set_tracker->End(async_track, seqno);
   context_->slice_tracker->End(timestamp, end_id);

   int64_t* start_timestamp = start_timestamps_.Find(seqno);
   if (!start_timestamp)
     return;

   int64_t duration = timestamp - *start_timestamp;

   TrackId track =
       context_->track_tracker->InternGlobalCounterTrack(latency_id_);
   context_->event_tracker->PushCounter(timestamp,
                                        static_cast<double>(duration), track);

   start_timestamps_.Erase(seqno);
 }

 void VirtioGpuTracker::ParseVirtioGpuCmdQueue(int64_t timestamp,
                                               uint32_t /*pid*/,
                                               protozero::ConstBytes blob) {
   protos::pbzero::VirtioGpuCmdQueueFtraceEvent::Decoder evt(blob.data,
                                                             blob.size);

   auto name = base::StringView(evt.name());
   if (name == "control") {
     virtgpu_control_queue_.HandleNumFree(timestamp, evt.num_free());
     virtgpu_control_queue_.HandleCmdQueue(timestamp, evt.seqno(), evt.type(),
                                           evt.fence_id());
   } else if (name == "cursor") {
     virtgpu_cursor_queue_.HandleNumFree(timestamp, evt.num_free());
     virtgpu_cursor_queue_.HandleCmdQueue(timestamp, evt.seqno(), evt.type(),
                                          evt.fence_id());
   }
 }

 void VirtioGpuTracker::ParseVirtioGpuCmdResponse(int64_t timestamp,
                                                  uint32_t /*pid*/,
                                                  protozero::ConstBytes blob) {
   protos::pbzero::VirtioGpuCmdResponseFtraceEvent::Decoder evt(blob.data,
                                                                blob.size);
   auto name = base::StringView(evt.name());
   if (name == "control") {
     virtgpu_control_queue_.HandleNumFree(timestamp, evt.num_free());
     virtgpu_control_queue_.HandleCmdResponse(timestamp, evt.seqno());
   } else if (name == "cursor") {
     virtgpu_cursor_queue_.HandleNumFree(timestamp, evt.num_free());
     virtgpu_cursor_queue_.HandleCmdResponse(timestamp, evt.seqno());
   }
 }

 }  // namespace trace_processor
 }  // namespace perfetto
	/*
	* Copyright (C) 2022 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/importers/ftrace/virtio_gpu_tracker.h"
	#include "perfetto/ext/base/string_utils.h"
	#include "protos/perfetto/trace/ftrace/ftrace_event.pbzero.h"
	#include "protos/perfetto/trace/ftrace/virtio_gpu.pbzero.h"
	#include "src/trace_processor/importers/common/async_track_set_tracker.h"
	#include "src/trace_processor/importers/common/event_tracker.h"
	#include "src/trace_processor/importers/common/slice_tracker.h"
	#include "src/trace_processor/importers/common/track_tracker.h"

	enum virtio_gpu_ctrl_type {
	VIRTIO_GPU_UNDEFINED = 0,

	/* 2d commands */
	VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100,
	VIRTIO_GPU_CMD_RESOURCE_CREATE_2D,
	VIRTIO_GPU_CMD_RESOURCE_UNREF,
	VIRTIO_GPU_CMD_SET_SCANOUT,
	VIRTIO_GPU_CMD_RESOURCE_FLUSH,
	VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D,
	VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING,
	VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING,
	VIRTIO_GPU_CMD_GET_CAPSET_INFO,
	VIRTIO_GPU_CMD_GET_CAPSET,
	VIRTIO_GPU_CMD_GET_EDID,
	VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID,
	VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB,
	VIRTIO_GPU_CMD_SET_SCANOUT_BLOB,

	/* 3d commands */
	VIRTIO_GPU_CMD_CTX_CREATE = 0x0200,
	VIRTIO_GPU_CMD_CTX_DESTROY,
	VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE,
	VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE,
	VIRTIO_GPU_CMD_RESOURCE_CREATE_3D,
	VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D,
	VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D,
	VIRTIO_GPU_CMD_SUBMIT_3D,
	VIRTIO_GPU_CMD_RESOURCE_MAP_BLOB,
	VIRTIO_GPU_CMD_RESOURCE_UNMAP_BLOB,

	/* cursor commands */
	VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300,
	VIRTIO_GPU_CMD_MOVE_CURSOR,

	/* success responses */
	VIRTIO_GPU_RESP_OK_NODATA = 0x1100,
	VIRTIO_GPU_RESP_OK_DISPLAY_INFO,
	VIRTIO_GPU_RESP_OK_CAPSET_INFO,
	VIRTIO_GPU_RESP_OK_CAPSET,
	VIRTIO_GPU_RESP_OK_EDID,
	VIRTIO_GPU_RESP_OK_RESOURCE_UUID,
	VIRTIO_GPU_RESP_OK_MAP_INFO,

	/* error responses */
	VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200,
	VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY,
	VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID,
	VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID,
	VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID,
	VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER,
	};

	static const char* virtio_gpu_ctrl_name(uint32_t type) {
	switch (type) {
	#define ENUM(n) \
	case VIRTIO_GPU_CMD_##n: \
	return #n
	/* 2d commands */
	ENUM(GET_DISPLAY_INFO);
	ENUM(RESOURCE_CREATE_2D);
	ENUM(RESOURCE_UNREF);
	ENUM(SET_SCANOUT);
	ENUM(RESOURCE_FLUSH);
	ENUM(TRANSFER_TO_HOST_2D);
	ENUM(RESOURCE_ATTACH_BACKING);
	ENUM(RESOURCE_DETACH_BACKING);
	ENUM(GET_CAPSET_INFO);
	ENUM(GET_CAPSET);
	ENUM(GET_EDID);
	ENUM(RESOURCE_ASSIGN_UUID);
	ENUM(RESOURCE_CREATE_BLOB);
	ENUM(SET_SCANOUT_BLOB);

	/* 3d commands */
	ENUM(CTX_CREATE);
	ENUM(CTX_DESTROY);
	ENUM(CTX_ATTACH_RESOURCE);
	ENUM(CTX_DETACH_RESOURCE);
	ENUM(RESOURCE_CREATE_3D);
	ENUM(TRANSFER_TO_HOST_3D);
	ENUM(TRANSFER_FROM_HOST_3D);
	ENUM(SUBMIT_3D);
	ENUM(RESOURCE_MAP_BLOB);
	ENUM(RESOURCE_UNMAP_BLOB);

	/* cursor commands */
	ENUM(UPDATE_CURSOR);
	ENUM(MOVE_CURSOR);
	#undef ENUM
	default:
	return "";
	}
	}

	namespace perfetto {
	namespace trace_processor {

	VirtioGpuTracker::VirtioGpuTracker(TraceProcessorContext* context)
	: virtgpu_control_queue_(context, "Control"),
	virtgpu_cursor_queue_(context, "Cursor") {}

	void VirtioGpuTracker::ParseVirtioGpu(int64_t timestamp,
	int32_t field_id,
	uint32_t pid,
	protozero::ConstBytes blob) {
	using protos::pbzero::FtraceEvent;

	switch (field_id) {
	case FtraceEvent::kVirtioGpuCmdQueueFieldNumber: {
	ParseVirtioGpuCmdQueue(timestamp, pid, blob);
	break;
	}
	case FtraceEvent::kVirtioGpuCmdResponseFieldNumber: {
	ParseVirtioGpuCmdResponse(timestamp, pid, blob);
	break;
	}
	default:
	PERFETTO_DFATAL("Unexpected field id");
	break;
	}
	}
	VirtioGpuTracker::VirtioGpuQueue::VirtioGpuQueue(TraceProcessorContext* context,
	const char* name)
	: context_(context) {
	base::StackString<255> num_free_name("Virtgpu %s Free", name);
	base::StackString<255> latency_name("Virtgpu %s Latency", name);
	base::StackString<255> queue_track_name("Virtgpu %s Queue", name);

	num_free_id_ = context->storage->InternString(num_free_name.string_view());
	latency_id_ = context->storage->InternString(latency_name.string_view());
	queue_track_id_ =
	context->storage->InternString(queue_track_name.string_view());
	}

	void VirtioGpuTracker::VirtioGpuQueue::HandleNumFree(int64_t timestamp,
	uint32_t num_free) {
	TrackId track =
	context_->track_tracker->InternGlobalCounterTrack(num_free_id_);
	context_->event_tracker->PushCounter(timestamp, static_cast<double>(num_free),
	track);
	}

	void VirtioGpuTracker::VirtioGpuQueue::HandleCmdQueue(int64_t timestamp,
	uint32_t seqno,
	uint32_t type,
	uint64_t fence_id) {
	auto async_track =
	context_->async_track_set_tracker->InternGlobalTrackSet(queue_track_id_);
	TrackId start_id =
	context_->async_track_set_tracker->Begin(async_track, seqno);

	context_->slice_tracker->Begin(
	timestamp, start_id, kNullStringId,
	context_->storage->InternString(
	base::StringView(virtio_gpu_ctrl_name(type))));

	/* cmds with a fence do not necessarily get an immediate response from
	* the host, so we should not use them for calculating latency:
	*/
	if (!fence_id) {
	start_timestamps_[seqno] = timestamp;
	}
	}

	void VirtioGpuTracker::VirtioGpuQueue::HandleCmdResponse(int64_t timestamp,
	uint32_t seqno) {
	auto async_track =
	context_->async_track_set_tracker->InternGlobalTrackSet(queue_track_id_);
	TrackId end_id = context_->async_track_set_tracker->End(async_track, seqno);
	context_->slice_tracker->End(timestamp, end_id);

	int64_t* start_timestamp = start_timestamps_.Find(seqno);
	if (!start_timestamp)
	return;

	int64_t duration = timestamp - *start_timestamp;

	TrackId track =
	context_->track_tracker->InternGlobalCounterTrack(latency_id_);
	context_->event_tracker->PushCounter(timestamp,
	static_cast<double>(duration), track);

	start_timestamps_.Erase(seqno);
	}

	void VirtioGpuTracker::ParseVirtioGpuCmdQueue(int64_t timestamp,
	uint32_t /pid/,
	protozero::ConstBytes blob) {
	protos::pbzero::VirtioGpuCmdQueueFtraceEvent::Decoder evt(blob.data,
	blob.size);

	auto name = base::StringView(evt.name());
	if (name == "control") {
	virtgpu_control_queue_.HandleNumFree(timestamp, evt.num_free());
	virtgpu_control_queue_.HandleCmdQueue(timestamp, evt.seqno(), evt.type(),
	evt.fence_id());
	} else if (name == "cursor") {
	virtgpu_cursor_queue_.HandleNumFree(timestamp, evt.num_free());
	virtgpu_cursor_queue_.HandleCmdQueue(timestamp, evt.seqno(), evt.type(),
	evt.fence_id());
	}
	}

	void VirtioGpuTracker::ParseVirtioGpuCmdResponse(int64_t timestamp,
	uint32_t /pid/,
	protozero::ConstBytes blob) {
	protos::pbzero::VirtioGpuCmdResponseFtraceEvent::Decoder evt(blob.data,
	blob.size);
	auto name = base::StringView(evt.name());
	if (name == "control") {
	virtgpu_control_queue_.HandleNumFree(timestamp, evt.num_free());
	virtgpu_control_queue_.HandleCmdResponse(timestamp, evt.seqno());
	} else if (name == "cursor") {
	virtgpu_cursor_queue_.HandleNumFree(timestamp, evt.num_free());
	virtgpu_cursor_queue_.HandleCmdResponse(timestamp, evt.seqno());
	}
	}

	} // namespace trace_processor
	} // namespace perfetto