[igt-dev] [PATCH i-g-t] tools/intel_gpu_power: Intel GPU idle/busy power measurement

[igt-dev] [PATCH i-g-t] tools/intel_gpu_power: Intel GPU idle/busy power measurement

[Ashutosh Dixit]

In several instances (e.g. when investigating GPU power limits) it is very
useful to be able to measure GPU power easily. Since we already have all
ingredients for doing so, add a tool to measure Intel GPU power when idle
and power under load.

Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
---
 tools/intel_gpu_power.c | 60 +++++++++++++++++++++++++++++++++++++++++
 tools/meson.build       |  5 ++++
 2 files changed, 65 insertions(+)
 create mode 100644 tools/intel_gpu_power.c

diff --git a/tools/intel_gpu_power.c b/tools/intel_gpu_power.c
new file mode 100644
index 00000000000..ae5285e1a85
--- /dev/null
+++ b/tools/intel_gpu_power.c
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2022 Intel Corporation
+ */
+
+#include "igt.h"
+#include "i915/gem.h"
+#include "igt_power.h"
+
+IGT_TEST_DESCRIPTION("Intel gpu power measurement");
+
+static void measure_power(int i915, const char *domain, bool load)
+{
+	const intel_ctx_t *ctx = intel_ctx_create_all_physical(i915);
+	struct power_sample sample[2];
+	int sleep_duration_sec = 2;
+	struct igt_power pwr;
+	igt_spin_t *spin;
+
+	gem_quiescent_gpu(i915);
+	if (load) {
+		spin = igt_spin_new(i915, .ctx = ctx, .engine = ALL_ENGINES,
+				    .flags = IGT_SPIN_POLL_RUN);
+		/* Wait till at least one spinner starts */
+		igt_spin_busywait_until_started(spin);
+	}
+
+	igt_require(!igt_power_open(i915, &pwr, domain));
+	igt_power_get_energy(&pwr, &sample[0]);
+	usleep(sleep_duration_sec * USEC_PER_SEC);
+	igt_power_get_energy(&pwr, &sample[1]);
+	igt_info("Measured power: %g mW\n", igt_power_get_mW(&pwr, &sample[0], &sample[1]));
+
+	igt_power_close(&pwr);
+	igt_free_spins(i915);
+	intel_ctx_destroy(i915, ctx);
+}
+
+igt_main
+{
+	int i915;
+
+	igt_fixture {
+		i915 = drm_open_driver_master(DRIVER_INTEL);
+	}
+
+	igt_describe("Measure idle gpu power");
+	igt_subtest("idle") {
+		measure_power(i915, "gpu", false);
+	}
+
+	igt_describe("Measure gpu power with load");
+	igt_subtest("busy") {
+		measure_power(i915, "gpu", true);
+	}
+
+	igt_fixture {
+		close(i915);
+	}
+}
diff --git a/tools/meson.build b/tools/meson.build
index d2defec8703..e0058940ce0 100644
--- a/tools/meson.build
+++ b/tools/meson.build
@@ -84,6 +84,11 @@ install_data('intel_gpu_abrt', install_dir : bindir)
 
 install_subdir('registers', install_dir : datadir)
 
+executable('intel_gpu_power', 'intel_gpu_power.c',
+	   install : true,
+	   install_rpath : bindir_rpathdir,
+	   dependencies : [lib_igt,cairo])
+
 executable('intel_gpu_top', 'intel_gpu_top.c',
 	   install : true,
 	   install_rpath : bindir_rpathdir,
-- 
2.38.0

[igt-dev] [PATCH i-g-t] tools/intel_gpu_power: Intel GPU idle/busy power measurement

[Ashutosh Dixit]

In several instances (e.g. when investigating GPU power limits) it is very
useful to be able to measure GPU power easily. Since we already have all
ingredients for doing so, add a tool to measure Intel GPU power when idle
and power under load.

Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
---
 tools/intel_gpu_power.c | 73 +++++++++++++++++++++++++++++++++++++++++
 tools/meson.build       |  1 +
 2 files changed, 74 insertions(+)
 create mode 100644 tools/intel_gpu_power.c

diff --git a/tools/intel_gpu_power.c b/tools/intel_gpu_power.c
new file mode 100644
index 00000000000..3f73e10bf60
--- /dev/null
+++ b/tools/intel_gpu_power.c
@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2022 Intel Corporation
+ */
+
+#include "igt.h"
+#include "i915/gem.h"
+#include "igt_power.h"
+
+static int measure_power(int i915, const char *domain, bool load)
+{
+	const intel_ctx_t *ctx = intel_ctx_create_all_physical(i915);
+	int ret, sleep_duration_sec = 2;
+	struct power_sample sample[2];
+	struct igt_power pwr;
+	igt_spin_t *spin;
+
+	gem_quiescent_gpu(i915);
+	if (load) {
+		spin = igt_spin_new(i915, .ctx = ctx, .engine = ALL_ENGINES,
+				    .flags = IGT_SPIN_POLL_RUN);
+		/* Wait till at least one spinner starts */
+		igt_spin_busywait_until_started(spin);
+	}
+
+	ret = igt_power_open(i915, &pwr, domain);
+	if (ret)
+		return ret;
+	igt_power_get_energy(&pwr, &sample[0]);
+	usleep(sleep_duration_sec * USEC_PER_SEC);
+	igt_power_get_energy(&pwr, &sample[1]);
+	igt_info("Measured power: %g mW\n", igt_power_get_mW(&pwr, &sample[0], &sample[1]));
+
+	igt_power_close(&pwr);
+	igt_free_spins(i915);
+	intel_ctx_destroy(i915, ctx);
+
+	return 0;
+}
+
+static void usage(const char *name)
+{
+	igt_info("Usage: %s [options]\n", name);
+	igt_info("-i/--idle  Measure idle power\n");
+	igt_info("-b/--busy  Measure power under load\n");
+}
+
+int main(int argc, char *argv[])
+{
+	int i915 = drm_open_driver_master(DRIVER_INTEL);
+	static struct option long_options[] = {
+		{"idle", 0, 0, 'i'},
+		{"busy", 0, 0, 'b'},
+		{ 0, 0, 0, 0 }
+	};
+	int opt = getopt_long(argc, argv, "ib", long_options, NULL);
+	int ret = 0;
+
+	switch (opt) {
+	case 'i':
+		ret = measure_power(i915, "gpu", false);
+		break;
+	case 'b':
+		ret = measure_power(i915, "gpu", true);
+		break;
+	default:
+		usage(argv[0]);
+		break;
+	}
+
+	close(i915);
+	return ret;
+}
diff --git a/tools/meson.build b/tools/meson.build
index d2defec8703..4bbbd993cac 100644
--- a/tools/meson.build
+++ b/tools/meson.build
@@ -22,6 +22,7 @@ tools_progs = [
 	'intel_error_decode',
 	'intel_forcewaked',
 	'intel_gpu_frequency',
+	'intel_gpu_power',
 	'intel_firmware_decode',
 	'intel_framebuffer_dump',
 	'intel_gpu_time',
-- 
2.38.0

[igt-dev] ✗ Fi.CI.BAT: failure for tools/intel_gpu_power: Intel GPU idle/busy power measurement (rev2)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 4878 bytes --]

== Series Details ==

Series: tools/intel_gpu_power: Intel GPU idle/busy power measurement (rev2)
URL   : https://patchwork.freedesktop.org/series/113073/
State : failure

== Summary ==

CI Bug Log - changes from CI_DRM_12606 -> IGTPW_8372
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with IGTPW_8372 absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_8372, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/index.html

Participating hosts (40 -> 40)
------------------------------

  Additional (1): fi-kbl-soraka 
  Missing    (1): fi-snb-2520m 

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in IGTPW_8372:

### IGT changes ###

#### Possible regressions ####

  * igt@i915_selftest@live@slpc:
    - fi-kbl-soraka:      NOTRUN -> [INCOMPLETE][1]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-kbl-soraka/igt@i915_selftest@live@slpc.html

  
Known issues
------------

  Here are the changes found in IGTPW_8372 that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@gem_exec_gttfill@basic:
    - fi-kbl-soraka:      NOTRUN -> [SKIP][2] ([fdo#109271]) +15 similar issues
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-kbl-soraka/igt@gem_exec_gttfill@basic.html
    - fi-pnv-d510:        [PASS][3] -> [FAIL][4] ([i915#7229])
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12606/fi-pnv-d510/igt@gem_exec_gttfill@basic.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-pnv-d510/igt@gem_exec_gttfill@basic.html

  * igt@gem_huc_copy@huc-copy:
    - fi-kbl-soraka:      NOTRUN -> [SKIP][5] ([fdo#109271] / [i915#2190])
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-kbl-soraka/igt@gem_huc_copy@huc-copy.html

  * igt@gem_lmem_swapping@basic:
    - fi-kbl-soraka:      NOTRUN -> [SKIP][6] ([fdo#109271] / [i915#4613]) +3 similar issues
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-kbl-soraka/igt@gem_lmem_swapping@basic.html

  * igt@i915_selftest@live@gt_heartbeat:
    - fi-kbl-soraka:      NOTRUN -> [DMESG-FAIL][7] ([i915#5334] / [i915#7872])
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-kbl-soraka/igt@i915_selftest@live@gt_heartbeat.html

  * igt@i915_selftest@live@gt_pm:
    - fi-kbl-soraka:      NOTRUN -> [DMESG-FAIL][8] ([i915#1886])
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-kbl-soraka/igt@i915_selftest@live@gt_pm.html

  
#### Possible fixes ####

  * igt@i915_selftest@live@gt_mocs:
    - {bat-rpls-1}:       [DMESG-FAIL][9] -> [PASS][10]
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12606/bat-rpls-1/igt@i915_selftest@live@gt_mocs.html
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/bat-rpls-1/igt@i915_selftest@live@gt_mocs.html

  
#### Warnings ####

  * igt@i915_suspend@basic-s3-without-i915:
    - fi-rkl-11600:       [FAIL][11] ([fdo#103375]) -> [INCOMPLETE][12] ([i915#4817])
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12606/fi-rkl-11600/igt@i915_suspend@basic-s3-without-i915.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/fi-rkl-11600/igt@i915_suspend@basic-s3-without-i915.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [fdo#103375]: https://bugs.freedesktop.org/show_bug.cgi?id=103375
  [fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
  [i915#1886]: https://gitlab.freedesktop.org/drm/intel/issues/1886
  [i915#2190]: https://gitlab.freedesktop.org/drm/intel/issues/2190
  [i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
  [i915#4817]: https://gitlab.freedesktop.org/drm/intel/issues/4817
  [i915#5334]: https://gitlab.freedesktop.org/drm/intel/issues/5334
  [i915#7229]: https://gitlab.freedesktop.org/drm/intel/issues/7229
  [i915#7359]: https://gitlab.freedesktop.org/drm/intel/issues/7359
  [i915#7625]: https://gitlab.freedesktop.org/drm/intel/issues/7625
  [i915#7872]: https://gitlab.freedesktop.org/drm/intel/issues/7872


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_7124 -> IGTPW_8372

  CI-20190529: 20190529
  CI_DRM_12606: f20b8fdc4658730ff546a9214dc922cb52d496b3 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_8372: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/index.html
  IGT_7124: 6090d0a62e9c087429320c6fd3b6735ff68fde71 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_8372/index.html

[-- Attachment #2: Type: text/html, Size: 5696 bytes --]

[igt-dev] [PATCH i-g-t] tools/intel_gpu_power: Intel GPU idle/busy power measurement

[Ashutosh Dixit]

In several instances (e.g. when investigating GPU power limits) it is very
useful to be able to measure GPU power easily. Since we already have all
ingredients for doing so, add a tool to measure Intel GPU power when idle
and power under load.

v2: Use softpin/allocator (Riana)

Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
---
 tools/intel_gpu_power.c | 76 +++++++++++++++++++++++++++++++++++++++++
 tools/meson.build       |  1 +
 2 files changed, 77 insertions(+)
 create mode 100644 tools/intel_gpu_power.c

diff --git a/tools/intel_gpu_power.c b/tools/intel_gpu_power.c
new file mode 100644
index 00000000000..d9e71581707
--- /dev/null
+++ b/tools/intel_gpu_power.c
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2022 Intel Corporation
+ */
+
+#include "igt.h"
+#include "i915/gem.h"
+#include "igt_power.h"
+
+static int measure_power(int i915, const char *domain, bool load)
+{
+	const intel_ctx_t *ctx = intel_ctx_create_all_physical(i915);
+	uint64_t ahnd = get_reloc_ahnd(i915, ctx->id);
+	int ret, sleep_duration_sec = 2;
+	struct power_sample sample[2];
+	struct igt_power pwr;
+	igt_spin_t *spin;
+
+	gem_quiescent_gpu(i915);
+	if (load) {
+		spin = igt_spin_new(i915, .ahnd = ahnd, .ctx = ctx,
+				    .engine = ALL_ENGINES,
+				    .flags = IGT_SPIN_POLL_RUN);
+		/* Wait till at least one spinner starts */
+		igt_spin_busywait_until_started(spin);
+	}
+
+	ret = igt_power_open(i915, &pwr, domain);
+	if (ret)
+		return ret;
+	igt_power_get_energy(&pwr, &sample[0]);
+	usleep(sleep_duration_sec * USEC_PER_SEC);
+	igt_power_get_energy(&pwr, &sample[1]);
+	igt_info("Measured power: %g mW\n", igt_power_get_mW(&pwr, &sample[0], &sample[1]));
+
+	igt_power_close(&pwr);
+	igt_free_spins(i915);
+	put_ahnd(ahnd);
+	intel_ctx_destroy(i915, ctx);
+
+	return 0;
+}
+
+static void usage(const char *name)
+{
+	igt_info("Usage: %s [options]\n", name);
+	igt_info("-i/--idle  Measure idle power\n");
+	igt_info("-b/--busy  Measure power under load\n");
+}
+
+int main(int argc, char *argv[])
+{
+	int i915 = drm_open_driver_master(DRIVER_INTEL);
+	static struct option long_options[] = {
+		{"idle", 0, 0, 'i'},
+		{"busy", 0, 0, 'b'},
+		{ 0, 0, 0, 0 }
+	};
+	int opt = getopt_long(argc, argv, "ib", long_options, NULL);
+	int ret = 0;
+
+	switch (opt) {
+	case 'i':
+		ret = measure_power(i915, "gpu", false);
+		break;
+	case 'b':
+		ret = measure_power(i915, "gpu", true);
+		break;
+	default:
+		usage(argv[0]);
+		break;
+	}
+
+	close(i915);
+	return ret;
+}
diff --git a/tools/meson.build b/tools/meson.build
index d2defec8703..4bbbd993cac 100644
--- a/tools/meson.build
+++ b/tools/meson.build
@@ -22,6 +22,7 @@ tools_progs = [
 	'intel_error_decode',
 	'intel_forcewaked',
 	'intel_gpu_frequency',
+	'intel_gpu_power',
 	'intel_firmware_decode',
 	'intel_framebuffer_dump',
 	'intel_gpu_time',
-- 
2.38.0

Re: [igt-dev] [PATCH i-g-t] tools/intel_gpu_power: Intel GPU idle/busy power measurement

[Kamil Konieczny]

Hi,

On 2023-01-20 at 08:38:31 -0800, Ashutosh Dixit wrote:
> In several instances (e.g. when investigating GPU power limits) it is very
> useful to be able to measure GPU power easily. Since we already have all
> ingredients for doing so, add a tool to measure Intel GPU power when idle
> and power under load.
> 
> v2: Use softpin/allocator (Riana)
> 
> Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>

These looks like a test or benchmark, btw intel_gpu_top already
has printing used power. What we can have is standalone app which
shows only power consumption every few seconds or some other
configurable interval, plus maybe for all GPUs if there are more.

+cc Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com>

Regards,
Kamil

> ---
>  tools/intel_gpu_power.c | 76 +++++++++++++++++++++++++++++++++++++++++
>  tools/meson.build       |  1 +
>  2 files changed, 77 insertions(+)
>  create mode 100644 tools/intel_gpu_power.c
> 
> diff --git a/tools/intel_gpu_power.c b/tools/intel_gpu_power.c
> new file mode 100644
> index 00000000000..d9e71581707
> --- /dev/null
> +++ b/tools/intel_gpu_power.c
> @@ -0,0 +1,76 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2022 Intel Corporation
> + */
> +
> +#include "igt.h"
> +#include "i915/gem.h"
> +#include "igt_power.h"
> +
> +static int measure_power(int i915, const char *domain, bool load)
> +{
> +	const intel_ctx_t *ctx = intel_ctx_create_all_physical(i915);
> +	uint64_t ahnd = get_reloc_ahnd(i915, ctx->id);
> +	int ret, sleep_duration_sec = 2;
> +	struct power_sample sample[2];
> +	struct igt_power pwr;
> +	igt_spin_t *spin;
> +
> +	gem_quiescent_gpu(i915);
> +	if (load) {
> +		spin = igt_spin_new(i915, .ahnd = ahnd, .ctx = ctx,
> +				    .engine = ALL_ENGINES,
> +				    .flags = IGT_SPIN_POLL_RUN);
> +		/* Wait till at least one spinner starts */
> +		igt_spin_busywait_until_started(spin);
> +	}
> +
> +	ret = igt_power_open(i915, &pwr, domain);
> +	if (ret)
> +		return ret;
> +	igt_power_get_energy(&pwr, &sample[0]);
> +	usleep(sleep_duration_sec * USEC_PER_SEC);
> +	igt_power_get_energy(&pwr, &sample[1]);
> +	igt_info("Measured power: %g mW\n", igt_power_get_mW(&pwr, &sample[0], &sample[1]));
> +
> +	igt_power_close(&pwr);
> +	igt_free_spins(i915);
> +	put_ahnd(ahnd);
> +	intel_ctx_destroy(i915, ctx);
> +
> +	return 0;
> +}
> +
> +static void usage(const char *name)
> +{
> +	igt_info("Usage: %s [options]\n", name);
> +	igt_info("-i/--idle  Measure idle power\n");
> +	igt_info("-b/--busy  Measure power under load\n");
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +	int i915 = drm_open_driver_master(DRIVER_INTEL);
> +	static struct option long_options[] = {
> +		{"idle", 0, 0, 'i'},
> +		{"busy", 0, 0, 'b'},
> +		{ 0, 0, 0, 0 }
> +	};
> +	int opt = getopt_long(argc, argv, "ib", long_options, NULL);
> +	int ret = 0;
> +
> +	switch (opt) {
> +	case 'i':
> +		ret = measure_power(i915, "gpu", false);
> +		break;
> +	case 'b':
> +		ret = measure_power(i915, "gpu", true);
> +		break;
> +	default:
> +		usage(argv[0]);
> +		break;
> +	}
> +
> +	close(i915);
> +	return ret;
> +}
> diff --git a/tools/meson.build b/tools/meson.build
> index d2defec8703..4bbbd993cac 100644
> --- a/tools/meson.build
> +++ b/tools/meson.build
> @@ -22,6 +22,7 @@ tools_progs = [
>  	'intel_error_decode',
>  	'intel_forcewaked',
>  	'intel_gpu_frequency',
> +	'intel_gpu_power',
>  	'intel_firmware_decode',
>  	'intel_framebuffer_dump',
>  	'intel_gpu_time',
> -- 
> 2.38.0
> 

Re: [igt-dev] [PATCH i-g-t] tools/intel_gpu_power: Intel GPU idle/busy power measurement

[Dixit, Ashutosh]

On Fri, 20 Jan 2023 10:00:09 -0800, Kamil Konieczny wrote:
>
> Hi,
>

Hi Kamil,

> On 2023-01-20 at 08:38:31 -0800, Ashutosh Dixit wrote:
> > In several instances (e.g. when investigating GPU power limits) it is very
> > useful to be able to measure GPU power easily. Since we already have all
> > ingredients for doing so, add a tool to measure Intel GPU power when idle
> > and power under load.
> >
> > v2: Use softpin/allocator (Riana)
> >
> > Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
>
> These looks like a test or benchmark, btw intel_gpu_top already
> has printing used power. What we can have is standalone app which
> shows only power consumption every few seconds or some other
> configurable interval, plus maybe for all GPUs if there are more.
>
> +cc Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com>

You are absolutely right, I agree on all points. I completely missed that
intel_gpu_top already shows power. At this point it only shows power for
integrated, we need to switch it from the rapl interface to igt_power
interface, igt_power supports both integrated and discrete (integrated
using rapl and discrete using hwmon).

I might resumbit this patch as a test, but tools wise I think the direction
should be to extend intel_gpu_top to support discrete.

Thanks.
--
Ashutosh