Add power/gpu_frequency tracepoint.
Subsystems (2)
PATCH 1/1 Add power/gpu_frequency tracepoint.
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
--- drivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 +++++++++++++ include/trace/events/power.h | 26 +++++++++++++++++++++++++ 5 files changed, 44 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.c
drivers/gpu/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/
drivers/gpu/trace/Kconfig +3 -0
@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + bool
drivers/gpu/trace/Makefile +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.o
drivers/gpu/trace/trace_gpu_frequency.c new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google, Inc. +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);
include/trace/events/power.h +26 -0
@@ -500,6 +500,32 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports frequency changes in GPU clock domains +* @state: New frequency (in KHz) +* @gpu_id: GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int state, unsigned int gpu_id), + +TP_ARGS (state, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, state) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->state = state; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("state=%lu gpu_id=%lu" , + (unsigned long )__entry->state, + (unsigned long )__entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */
Signature · 1 line
2.28.0.220.ged08abb693-goog
Steven Rostedt
maintainerQuoted 4 lines · On Thu, 13 Aug 2020 14:03:57 -0700 Peiyong Lin <[email protected]> wrote:
include/trace/events/power.h +4
-0+/** +* gpu_frequency - Reports frequency changes in GPU clock domains +* @state: New frequency (in KHz) +* @gpu_id: GPU clock domain
include/trace/events/power.h DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, · line 517
Quoted 10 lines
include/trace/events/power.h +10
-0+*/ +TRACE_EVENT(gpu_frequency, + + TP_PROTO(unsigned int state, unsigned int gpu_id), + + TP_ARGS(state, gpu_id), + + TP_STRUCT__entry( + __field(unsigned int, state) + __field(unsigned int, gpu_id)
Both of the above entries are unsigned int.
include/trace/events/power.h DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, · line 527
Quoted 10 lines
include/trace/events/power.h +10
-0+ ), + + TP_fast_assign( + __entry->state = state; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("state=%lu gpu_id=%lu" , + (unsigned long )__entry->state, + (unsigned long )__entry->gpu_id)
Why typecast to (unsigned long) to use it in %lu? Why not just have:
TP_printk("state=%u gpu_id=%u",
__entry->state, __entry->gpu_id)?
-- Steve
Quoted 4 lines
+);
#endif /*_TRACE_POWER_H*//* This part must be outside protection */
PATCH v2 1/1 Add power/gpu_frequency tracepoint.
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
---
Changelog since v1:
- Use %u in TP_printk
drivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 +++++++++++++ include/trace/events/power.h | 25 +++++++++++++++++++++++++ 5 files changed, 43 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.c
drivers/gpu/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/
drivers/gpu/trace/Kconfig +3 -0
@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + bool
drivers/gpu/trace/Makefile +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.o
drivers/gpu/trace/trace_gpu_frequency.c new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google, Inc. +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);
include/trace/events/power.h +25 -0
@@ -500,6 +500,31 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports frequency changes in GPU clock domains +* @state: New frequency (in KHz) +* @gpu_id: GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int state, unsigned int gpu_id), + +TP_ARGS (state, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, state) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->state = state; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("state=%u gpu_id=%u" , + __entry->state, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */
Signature · 1 line
2.28.0.220.ged08abb693-goog
Quoted 9 lines · On Thu, 13 Aug 2020 14:37:03 -0700 Peiyong Lin <[email protected]> wrote:
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Quoted 6 lines
Signed-off-by Peiyong Lin <[email protected]>---
Changelog since v1:
- Use %u inTP_printk
For just the tracing side of this, but the use case is up for others to do:
-- Steve
PATCH v3 1/1 Add power/gpu_frequency tracepoint.
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
---
Changelog sice v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.
Changelog since v1:
- Use %u in TP_printk
drivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.c
drivers/gpu/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/
drivers/gpu/trace/Kconfig +3 -0
@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + bool
drivers/gpu/trace/Makefile +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.o
drivers/gpu/trace/trace_gpu_frequency.c new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google, Inc. +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);
include/trace/events/power.h +33 -0
@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */
Signature · 1 line
2.28.0.297.g1956fa8f8d-goog
Quoted 10 lines · On Thu, 20 Aug 2020 12:41:34 -0700 Peiyong Lin <[email protected]> wrote:
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>
Just from the tracing point of view (not from the content of the trace point of view).
-- Steve
PATCH 1/1 Add power/gpu_frequency tracepoint.
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
---
Changelog since v3:
- Correct copyright title.
Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.
Changelog since v1:
- Use %u in TP_printk
drivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.c
drivers/gpu/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/
drivers/gpu/trace/Kconfig +3 -0
@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + bool
drivers/gpu/trace/Makefile +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.o
drivers/gpu/trace/trace_gpu_frequency.c new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);
include/trace/events/power.h +33 -0
@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */
Signature · 1 line
2.29.0.rc1.297.gfa9743e501-goog
PATCH v4 1/1 Add power/gpu_frequency tracepoint.
In reply to Steven RostedtHistorically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
---
Changelog since v3:
- Correct copyright title.
Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.
Changelog since v1:
- Use %u in TP_printk
drivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.c
drivers/gpu/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/
drivers/gpu/trace/Kconfig +3 -0
@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + bool
drivers/gpu/trace/Makefile +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.o
drivers/gpu/trace/trace_gpu_frequency.c new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);
include/trace/events/power.h +33 -0
@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */
Signature · 1 line
2.29.0.rc1.297.gfa9743e501-goog
Hi there,
May I ask for a review please?
Thanks,
Peiyong
Quoted 126 lines · Peiyong Lin
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>---
Changelog since v3:
- Correct copyright title.Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.Changelog since v1:
- Use %u inTP_printkdrivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.cdrivers/gpu/Makefile +1
-0@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/drivers/gpu/trace/Kconfig +3
-0@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + booldrivers/gpu/trace/Makefile +1
-0@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.odrivers/gpu/trace/trace_gpu_frequency.c new file +13
-0@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);include/trace/events/power.h +33
-1@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */ --2.29.0.rc1.297.gfa9743e501-goog
Quoted 3 lines · Peiyong Lin
Hi there,
May I ask for a review please?
Please do not top-post, and you just sent this a few days ago, in the middle of the merge window when we could not do anything.
Give maintainers time to catch up, and they will get to it...
greg k-h
Quoted 124 lines · Peiyong Lin
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>---
Changelog since v3:
- Correct copyright title.Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.Changelog since v1:
- Use %u inTP_printkdrivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.cdrivers/gpu/Makefile +1
-0@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/drivers/gpu/trace/Kconfig +3
-0@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + booldrivers/gpu/trace/Makefile +1
-0@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.odrivers/gpu/trace/trace_gpu_frequency.c new file +13
-0@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);include/trace/events/power.h +33
-1@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */ --
Quoted 2 lines
2.29.0.rc1.297.gfa9743e501-goog
Hi there,
May I ask whether the merge window has passed? If so is it possible to ask for a review?
Thanks,
Peiyong
Steven Rostedt
maintainerQuoted 4 lines · On Mon, 16 Nov 2020 12:55:29 -0800 Peiyong Lin <[email protected]> wrote:
Hi there,
May I ask whether the merge window has passed? If so is it possible to ask for a review?
This is up to the maintainers of power management to accept this.
Rafael?
-- Steve
Quoted 10 lines · Steven Rostedt
Quoted 4 lines · On Mon, 16 Nov 2020 12:55:29 -0800 Peiyong Lin <[email protected]> wrote:
Hi there,
May I ask whether the merge window has passed? If so is it possible to ask for a review?
This is up to the maintainers of power management to accept this.
Rafael?
I'd say up to the GPU people rather (dri-devel CCed) since that's where it is going to be used.
Also it would be good to see at least one in-the-tree user of this (or a usage example at least).
Cheers!
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
Quoted 11 lines · Rafael J. Wysocki
Quoted 9 lines · Steven Rostedt
Quoted 4 lines · On Mon, 16 Nov 2020 12:55:29 -0800 Peiyong Lin <[email protected]> wrote:
Hi there,
May I ask whether the merge window has passed? If so is it possible to ask for a review?
This is up to the maintainers of power management to accept this.
Quoted 7 lines
Quoted 1 line
Rafael?
I'd say up to the GPU people rather (dri-devel CCed) since that's where it is going to be used.
Also it would be good to see at least one in-the-tree user of this (or a usage example at least).
Can you resend the patches and cc dri-devel or point out the previous patch discussion?
Alex
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
Quoted 124 lines · Peiyong Lin
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>---
Changelog since v3:
- Correct copyright title.Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.Changelog since v1:
- Use %u inTP_printkdrivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.cdrivers/gpu/Makefile +1
-0@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/drivers/gpu/trace/Kconfig +3
-0@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + booldrivers/gpu/trace/Makefile +1
-0@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.odrivers/gpu/trace/trace_gpu_frequency.c new file +13
-0@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);include/trace/events/power.h +33
-1@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */ --
Quoted 2 lines
2.29.0.rc1.297.gfa9743e501-goog
Hi there,
Per request, re-send this patch with dri-devel@ list CCed.
Thanks,
Peiyong
Quoted 132 lines · Peiyong Lin
Quoted 124 lines · Peiyong Lin
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>---
Changelog since v3:
- Correct copyright title.Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.Changelog since v1:
- Use %u inTP_printkdrivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.cdrivers/gpu/Makefile +1
-0@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/drivers/gpu/trace/Kconfig +3
-0@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + booldrivers/gpu/trace/Makefile +1
-0@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.odrivers/gpu/trace/trace_gpu_frequency.c new file +13
-0@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);include/trace/events/power.h +33
-1@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */ --Quoted 2 lines
2.29.0.rc1.297.gfa9743e501-goog
Hi there,
Quoted 4 lines
Per request, re-send this patch with dri-devel@ list CCed.
Thanks,
Peiyong
Hi there,
For GPU drivers folks in dri-devel@ list, any input?
Thanks,
Peiyong
Hi Peiyong,
Quoted 88 lines · Peiyong Lin
Quoted 87 lines · Peiyong Lin
Quoted 85 lines · Peiyong Lin
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>---
Changelog since v3:
- Correct copyright title.Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.Changelog since v1:
- Use %u inTP_printkdrivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++++ include/trace/events/power.h | 33 +++++++++++++++++++++++++ 5 files changed, 51 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.cdrivers/gpu/Makefile +1
-0@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/drivers/gpu/trace/Kconfig +3
-0@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + booldrivers/gpu/trace/Makefile +1
-0@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.odrivers/gpu/trace/trace_gpu_frequency.c new file +13
-0@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);include/trace/events/power.h +0
-0@@ -500,6 +500,39 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,
Quoted 15 lines
Quoted 7 lines
Quoted 7 lines
include/trace/events/power.h +5
-0TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, Quoted 8 lines
include/trace/events/power.h DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, · line 515
Quoted 8 lines
include/trace/events/power.h +8
-0+* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_id: Id for each GPU clock domain
Thinking about options for how to assign this, there are a few existing tracepoints (I see block device and jb2) which use dev_t, so perhaps that would be an option. We'd still want to be able to expose multiple clocks per device though, either with a separate field or with a defined packing into this one.
dev_t is a little bit tricky because the packing can (is?) different between the kernel and C library. major + minor + clock domain as 3 separate fields would be the most explicit.
As the intended use-case is tools, I imagine userspace will want to link this to data exposed via other APIs, so gpu_id needs to somehow allow that. That probably means some opaque integer assigned within the kernel isn't OK.
Hopefully some other vendors have thoughts on what would work in their systems.
Thanks,
-Brian
Quoted 37 lines
Quoted 30 lines
Quoted 24 lines
include/trace/events/power.h +20
-1+*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_id), + +TP_ARGS (frequency, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_id = gpu_id; + ), + +TP_printk ("frequency=%u gpu_id=%u" , + __entry->frequency, __entry->gpu_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */ --Quoted 2 lines
2.29.0.rc1.297.gfa9743e501-goog
Hi there,
Quoted 4 lines
Per request, re-send this patch with dri-devel@ list CCed.
Thanks,
PeiyongHi there,
Quoted 8 lines
For GPU drivers folks in dri-devel@ list, any input?
Thanks,
Peiyong
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v5 1/1 Add power/gpu_frequency tracepoint.
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
---
Changelog since v4:
- Explicitly use class id and instance id to identify a GPU instance.
- Change gpu_id to clock_id to call out its the clock domain in the GPU instance.
Changelog since v3:
- Correct copyright title.
Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.
Changelog since v1:
- Use %u in TP_printk
drivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 ++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++ include/trace/events/power.h | 41 +++++++++++++++++++++++++ 5 files changed, 59 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.c
drivers/gpu/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/
drivers/gpu/trace/Kconfig +3 -0
@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + bool
drivers/gpu/trace/Makefile +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.o
drivers/gpu/trace/trace_gpu_frequency.c new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);
include/trace/events/power.h +41 -0
47 lines not on this page · raw message
Signature · 1 line
2.29.2.684.gfbc64c5ab5-goog
Quoted 137 lines · Peiyong Lin
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>---
Changelog since v4:
- Explicitly use class id and instance id to identify a GPU instance.
- Changegpu_idtoclock_idto call out its the clock domain in the GPU instance.Changelog since v3:
- Correct copyright title.Changelog since v2:
- Add more comments to indicate when the event should be emitted.
- Change state to frequency.Changelog since v1:
- Use %u inTP_printkdrivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 ++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 ++++++++ include/trace/events/power.h | 41 +++++++++++++++++++++++++ 5 files changed, 59 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.cdrivers/gpu/Makefile +1
-0@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/drivers/gpu/trace/Kconfig +3
-0@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + booldrivers/gpu/trace/Makefile +1
-0@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.odrivers/gpu/trace/trace_gpu_frequency.c new file +13
-0@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google LLC +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);include/trace/events/power.h +41
-1@@ -500,6 +500,47 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports the GPU frequency in GPU clock domains. +* +* This event should be emitted whenever there's a GPU frequency change happens, +* or a GPU goes from idle state to active state, or vice versa. +* +* When the GPU goes from idle state to active state, this event should report +* the GPU frequency of the active state. When the GPU goes from active state to +* idle state, this event should report a zero frequency value. +* +* @frequency: New frequency (in KHz) +* @gpu_class_id: Id representing the class of the GPU +* @gpu_instance_id: Id representing the instance of class &gpu_class_id +* @clock_id: Id for the clock domain in &gpu_instance_id running at &frequency +*/ +TRACE_EVENT (gpu_frequency, + + TP_PROTO(unsigned int frequency, unsigned int gpu_class_id, + unsigned int gpu_instance_id, unsigned int clock_id), + +TP_ARGS (frequency, gpu_class_id, gpu_instance_id, clock_id), + +TP_STRUCT__entry ( + __field(unsigned int, frequency) + __field(unsigned int, gpu_class_id) + __field(unsigned int, gpu_instance_id) + __field(unsigned int, clock_id) + ), + +TP_fast_assign ( + __entry->frequency = frequency; + __entry->gpu_class_id = gpu_class_id; + __entry->gpu_instance_id = gpu_instance_id; + __entry->clock_id = clock_id; + ), + +TP_printk ("frequency=%u gpu_class_id=%u gpu_instance_id=%u clock_id=%u" , + __entry->frequency, __entry->gpu_class_id, + __entry->gpu_instance_id, __entry->clock_id) +);#endif /* _TRACE_POWER_H */ /* This part must be outside protection */ --
Quoted 2 lines
2.29.2.684.gfbc64c5ab5-goog
Hi there,
Could you please take a look at this patch?
Thanks,
Peiyong
Quoted 10 lines · Peiyong Lin
Quoted 9 lines · Peiyong Lin
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
...
Quoted 8 lines
Quoted 4 lines
/* This part must be outside protection */
--
2.29.2.684.gfbc64c5ab5-googHi there,
Could you please take a look at this patch?
Please trim email quotes when replying.
Also, you might want to state _name_ of person who should apply this, so there's no ambiguity. You cc-ed many people...
Pavel
Signature · 1 line
http://www.livejournal.com/~pavelmachek
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
A message that is not in the archive (sent off-list or not yet received): [email protected]
Hi Chris, please see my comments inline.
Quoted 86 lines · Chris Wilson
Quoting Peiyong Lin (2020-08-13 22:03:57)
Quoted 84 lines
Historically there is no common trace event for GPU frequency, in downstream Android each different hardware vendor implements their own way to expose GPU frequency, for example as a debugfs node. This patch standardize it as a common trace event in upstream linux kernel to help the ecosystem have a common implementation across hardware vendors. Toolings in the Linux ecosystem will benefit from this especially in the downstream Android, where this information is critical to graphics developers.
Signed-off-by Peiyong Lin <[email protected]>--- drivers/gpu/Makefile | 1 + drivers/gpu/trace/Kconfig | 3 +++ drivers/gpu/trace/Makefile | 1 + drivers/gpu/trace/trace_gpu_frequency.c | 13 +++++++++++++ include/trace/events/power.h | 26 +++++++++++++++++++++++++ 5 files changed, 44 insertions(+) create mode 100644 drivers/gpu/trace/trace_gpu_frequency.cdrivers/gpu/Makefile +1
-0@@ -6,3 +6,4 @@ obj-$(CONFIG_TEGRA_HOST1X) += host1x/ obj-y += drm/ vga/ obj-$(CONFIG_IMX_IPUV3_CORE) += ipu-v3/ obj-$(CONFIG_TRACE_GPU_MEM) += trace/ +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace/drivers/gpu/trace/Kconfig +3
-0@@ -2,3 +2,6 @@ config TRACE_GPU_MEM bool + +config TRACE_GPU_FREQUENCY + booldrivers/gpu/trace/Makefile +1
-0@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_TRACE_GPU_MEM) += trace_gpu_mem.o +obj-$(CONFIG_TRACE_GPU_FREQUENCY) += trace_gpu_frequency.odrivers/gpu/trace/trace_gpu_frequency.c new file +13
-0@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* GPU frequency trace points +* +* Copyright (C) 2020 Google, Inc. +*/ + +#include <linux/module.h> + +#define CREATE_TRACE_POINTS +#include <trace/events/power.h> + +EXPORT_TRACEPOINT_SYMBOL (gpu_frequency);include/trace/events/power.h +9
-0@@ -500,6 +500,32 @@ DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,TP_ARGS (name, type, new_value) ); + +/** +* gpu_frequency - Reports frequency changes in GPU clock domains +* @state: New frequency (in KHz) +* @gpu_id: GPU clock domain +*/ +TRACE_EVENT(gpu_frequency, + + TP_PROTO(unsigned int state, unsigned int gpu_id),
Quoted 8 lines
include/trace/events/power.h DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, · line 517
Quoted 6 lines
include/trace/events/power.h +6
-0+ +TP_ARGS (state, gpu_id), + +TP_STRUCT__entry ( + __field(unsigned int, state) + __field(unsigned int, gpu_id)What is a gpu-id and how are we supposed to create one?
gpu_id is the id for per GPU clock domain, it should be created for per GPU clock domain. It's not necessarily tied to a physical GPU.
Quoted 6 lines
'state' is quite non-descript, and since this is not an event template you could be a little more specific.
So when should this tracepoint fire? For the frequency change we request, or the frequency change of the black box of the pcu?
If an implementation implements this, the GPU frequency tracepoint should be fired whenever there's a frequency change. That is to say, when gpu goes from idle to active or vice versa, or when the gpu frequency goes up and down.
Quoted 4 lines
We have found that a tracepoint is not a useful monitor of the actual GPU frequencies, for that we use provide sampling via perf-events. -Chris