Commit 26a4dc29 authored by Juan A. Suarez Romero's avatar Juan A. Suarez Romero Committed by Melissa Wen
Browse files

drm/v3d: Expose performance counters to userspace 



The V3D engine has several hardware performance counters that can of
interest for userspace performance analysis tools.

This exposes new ioctls to create and destroy performance monitor
objects, as well as to query the counter values.

Each created performance monitor object has an ID that can be attached
to CL/CSD submissions, so the driver enables the requested counters when
the job is submitted, and updates the performance monitor values when
the job is done.

It is up to the user to ensure all the jobs have been finished before
getting the performance monitor values. It is also up to the user to
properly synchronize BCL jobs when submitting jobs with different
performance monitors attached.

Cc: Daniel Vetter <daniel@ffwll.ch>
Cc: David Airlie <airlied@linux.ie>
Cc: Emma Anholt <emma@anholt.net>
To: dri-devel@lists.freedesktop.org
Signed-off-by: default avatarJuan A. Suarez Romero <jasuarez@igalia.com>
Acked-by: default avatarMelissa Wen <mwen@igalia.com>
Signed-off-by: default avatarMelissa Wen <melissa.srw@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20210608111541.461991-1-jasuarez@igalia.com
parent 56f0729a

drivers/gpu/drm/v3d/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ v3d-y := \ 
	v3d_gem.o \

	v3d_irq.o \

	v3d_mmu.o \

	v3d_perfmon.o \

	v3d_trace_points.o \

	v3d_sched.o

drivers/gpu/drm/v3d/v3d_drv.c

+8 −0
Original line number Diff line number Diff line
@@ -94,6 +94,9 @@ static int v3d_get_param_ioctl(struct drm_device *dev, void *data, 
	case DRM_V3D_PARAM_SUPPORTS_CACHE_FLUSH:

		args->value = 1;

		return 0;

	case DRM_V3D_PARAM_SUPPORTS_PERFMON:

		args->value = (v3d->ver >= 40);

		return 0;

	default:

		DRM_DEBUG("Unknown parameter %d\n", args->param);

		return -EINVAL;
@@ -121,6 +124,7 @@ v3d_open(struct drm_device *dev, struct drm_file *file) 
				      1, NULL);

	}



	v3d_perfmon_open_file(v3d_priv);

	file->driver_priv = v3d_priv;



	return 0;
@@ -136,6 +140,7 @@ v3d_postclose(struct drm_device *dev, struct drm_file *file) 
		drm_sched_entity_destroy(&v3d_priv->sched_entity[q]);

	}



	v3d_perfmon_close_file(v3d_priv);

	kfree(v3d_priv);

}
@@ -156,6 +161,9 @@ static const struct drm_ioctl_desc v3d_drm_ioctls[] = { 
	DRM_IOCTL_DEF_DRV(V3D_GET_BO_OFFSET, v3d_get_bo_offset_ioctl, DRM_RENDER_ALLOW),

	DRM_IOCTL_DEF_DRV(V3D_SUBMIT_TFU, v3d_submit_tfu_ioctl, DRM_RENDER_ALLOW | DRM_AUTH),

	DRM_IOCTL_DEF_DRV(V3D_SUBMIT_CSD, v3d_submit_csd_ioctl, DRM_RENDER_ALLOW | DRM_AUTH),

	DRM_IOCTL_DEF_DRV(V3D_PERFMON_CREATE, v3d_perfmon_create_ioctl, DRM_RENDER_ALLOW),

	DRM_IOCTL_DEF_DRV(V3D_PERFMON_DESTROY, v3d_perfmon_destroy_ioctl, DRM_RENDER_ALLOW),

	DRM_IOCTL_DEF_DRV(V3D_PERFMON_GET_VALUES, v3d_perfmon_get_values_ioctl, DRM_RENDER_ALLOW),

};



static const struct drm_driver v3d_drm_driver = {

drivers/gpu/drm/v3d/v3d_drv.h

+63 −0
Original line number Diff line number Diff line
@@ -37,6 +37,40 @@ struct v3d_queue_state { 
	u64 emit_seqno;

};



/* Performance monitor object. The perform lifetime is controlled by userspace

 * using perfmon related ioctls. A perfmon can be attached to a submit_cl

 * request, and when this is the case, HW perf counters will be activated just

 * before the submit_cl is submitted to the GPU and disabled when the job is

 * done. This way, only events related to a specific job will be counted.

 */

struct v3d_perfmon {

	/* Tracks the number of users of the perfmon, when this counter reaches

	 * zero the perfmon is destroyed.

	 */

	refcount_t refcnt;



	/* Protects perfmon stop, as it can be invoked from multiple places. */

	struct mutex lock;



	/* Number of counters activated in this perfmon instance

	 * (should be less than DRM_V3D_MAX_PERF_COUNTERS).

	 */

	u8 ncounters;



	/* Events counted by the HW perf counters. */

	u8 counters[DRM_V3D_MAX_PERF_COUNTERS];



	/* Storage for counter values. Counters are incremented by the

	 * HW perf counter values every time the perfmon is attached

	 * to a GPU job.  This way, perfmon users don't have to

	 * retrieve the results after each job if they want to track

	 * events covering several submissions.  Note that counter

	 * values can't be reset, but you can fake a reset by

	 * destroying the perfmon and creating a new one.

	 */

	u64 values[];

};



struct v3d_dev {

	struct drm_device drm;
@@ -89,6 +123,9 @@ struct v3d_dev { 
	 */

	spinlock_t job_lock;



	/* Used to track the active perfmon if any. */

	struct v3d_perfmon *active_perfmon;



	/* Protects bo_stats */

	struct mutex bo_lock;
@@ -133,6 +170,11 @@ v3d_has_csd(struct v3d_dev *v3d) 
struct v3d_file_priv {

	struct v3d_dev *v3d;



	struct {

		struct idr idr;

		struct mutex lock;

	} perfmon;



	struct drm_sched_entity sched_entity[V3D_MAX_QUEUES];

};
@@ -205,6 +247,11 @@ struct v3d_job { 
	 */

	struct dma_fence *done_fence;



	/* Pointer to a performance monitor object if the user requested it,

	 * NULL otherwise.

	 */

	struct v3d_perfmon *perfmon;



	/* Callback for the freeing of the job on refcount going to 0. */

	void (*free)(struct kref *ref);

};
@@ -353,3 +400,19 @@ void v3d_mmu_remove_ptes(struct v3d_bo *bo); 
/* v3d_sched.c */

int v3d_sched_init(struct v3d_dev *v3d);

void v3d_sched_fini(struct v3d_dev *v3d);



/* v3d_perfmon.c */

void v3d_perfmon_get(struct v3d_perfmon *perfmon);

void v3d_perfmon_put(struct v3d_perfmon *perfmon);

void v3d_perfmon_start(struct v3d_dev *v3d, struct v3d_perfmon *perfmon);

void v3d_perfmon_stop(struct v3d_dev *v3d, struct v3d_perfmon *perfmon,

		      bool capture);

struct v3d_perfmon *v3d_perfmon_find(struct v3d_file_priv *v3d_priv, int id);

void v3d_perfmon_open_file(struct v3d_file_priv *v3d_priv);

void v3d_perfmon_close_file(struct v3d_file_priv *v3d_priv);

int v3d_perfmon_create_ioctl(struct drm_device *dev, void *data,

			     struct drm_file *file_priv);

int v3d_perfmon_destroy_ioctl(struct drm_device *dev, void *data,

			      struct drm_file *file_priv);

int v3d_perfmon_get_values_ioctl(struct drm_device *dev, void *data,

				 struct drm_file *file_priv);

drivers/gpu/drm/v3d/v3d_gem.c

+31 −0
Original line number Diff line number Diff line
@@ -126,6 +126,8 @@ v3d_reset(struct v3d_dev *v3d) 
	v3d_mmu_set_page_table(v3d);

	v3d_irq_reset(v3d);



	v3d_perfmon_stop(v3d, v3d->active_perfmon, false);



	trace_v3d_reset_end(dev);

}
@@ -375,6 +377,9 @@ v3d_job_free(struct kref *ref) 
	pm_runtime_mark_last_busy(job->v3d->drm.dev);

	pm_runtime_put_autosuspend(job->v3d->drm.dev);



	if (job->perfmon)

		v3d_perfmon_put(job->perfmon);



	kfree(job);

}
@@ -539,6 +544,9 @@ v3d_submit_cl_ioctl(struct drm_device *dev, void *data, 


	trace_v3d_submit_cl_ioctl(&v3d->drm, args->rcl_start, args->rcl_end);



	if (args->pad != 0)

		return -EINVAL;



	if (args->flags != 0 &&

	    args->flags != DRM_V3D_SUBMIT_CL_FLUSH_CACHE) {

		DRM_INFO("invalid flags: %d\n", args->flags);
@@ -611,8 +619,20 @@ v3d_submit_cl_ioctl(struct drm_device *dev, void *data, 
	if (ret)

		goto fail;



	if (args->perfmon_id) {

		render->base.perfmon = v3d_perfmon_find(v3d_priv,

							args->perfmon_id);



		if (!render->base.perfmon) {

			ret = -ENOENT;

			goto fail;

		}

	}



	mutex_lock(&v3d->sched_lock);

	if (bin) {

		bin->base.perfmon = render->base.perfmon;

		v3d_perfmon_get(bin->base.perfmon);

		ret = v3d_push_job(v3d_priv, &bin->base, V3D_BIN);

		if (ret)

			goto fail_unreserve;
@@ -633,6 +653,8 @@ v3d_submit_cl_ioctl(struct drm_device *dev, void *data, 
		ret = drm_gem_fence_array_add(&clean_job->deps, render_fence);

		if (ret)

			goto fail_unreserve;

		clean_job->perfmon = render->base.perfmon;

		v3d_perfmon_get(clean_job->perfmon);

		ret = v3d_push_job(v3d_priv, clean_job, V3D_CACHE_CLEAN);

		if (ret)

			goto fail_unreserve;
@@ -827,6 +849,15 @@ v3d_submit_csd_ioctl(struct drm_device *dev, void *data, 
	if (ret)

		goto fail;



	if (args->perfmon_id) {

		job->base.perfmon = v3d_perfmon_find(v3d_priv,

						     args->perfmon_id);

		if (!job->base.perfmon) {

			ret = -ENOENT;

			goto fail;

		}

	}



	mutex_lock(&v3d->sched_lock);

	ret = v3d_push_job(v3d_priv, &job->base, V3D_CSD);

	if (ret)

drivers/gpu/drm/v3d/v3d_perfmon.c

0 → 100644
+213 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) 2021 Raspberry Pi

 */



#include "v3d_drv.h"

#include "v3d_regs.h"



#define V3D_PERFMONID_MIN	1

#define V3D_PERFMONID_MAX	U32_MAX



void v3d_perfmon_get(struct v3d_perfmon *perfmon)

{

	if (perfmon)

		refcount_inc(&perfmon->refcnt);

}



void v3d_perfmon_put(struct v3d_perfmon *perfmon)

{

	if (perfmon && refcount_dec_and_test(&perfmon->refcnt))

		kfree(perfmon);

}



void v3d_perfmon_start(struct v3d_dev *v3d, struct v3d_perfmon *perfmon)

{

	unsigned int i;

	u32 mask;

	u8 ncounters = perfmon->ncounters;



	if (WARN_ON_ONCE(!perfmon || v3d->active_perfmon))

		return;



	mask = GENMASK(ncounters - 1, 0);



	for (i = 0; i < ncounters; i++) {

		u32 source = i / 4;

		u32 channel = V3D_SET_FIELD(perfmon->counters[i], V3D_PCTR_S0);



		i++;

		channel |= V3D_SET_FIELD(i < ncounters ? perfmon->counters[i] : 0,

					 V3D_PCTR_S1);

		i++;

		channel |= V3D_SET_FIELD(i < ncounters ? perfmon->counters[i] : 0,

					 V3D_PCTR_S2);

		i++;

		channel |= V3D_SET_FIELD(i < ncounters ? perfmon->counters[i] : 0,

					 V3D_PCTR_S3);

		V3D_CORE_WRITE(0, V3D_V4_PCTR_0_SRC_X(source), channel);

	}



	V3D_CORE_WRITE(0, V3D_V4_PCTR_0_CLR, mask);

	V3D_CORE_WRITE(0, V3D_PCTR_0_OVERFLOW, mask);

	V3D_CORE_WRITE(0, V3D_V4_PCTR_0_EN, mask);



	v3d->active_perfmon = perfmon;

}



void v3d_perfmon_stop(struct v3d_dev *v3d, struct v3d_perfmon *perfmon,

		      bool capture)

{

	unsigned int i;



	if (!perfmon || !v3d->active_perfmon)

		return;



	mutex_lock(&perfmon->lock);

	if (perfmon != v3d->active_perfmon) {

		mutex_unlock(&perfmon->lock);

		return;

	}



	if (capture)

		for (i = 0; i < perfmon->ncounters; i++)

			perfmon->values[i] += V3D_CORE_READ(0, V3D_PCTR_0_PCTRX(i));



	V3D_CORE_WRITE(0, V3D_V4_PCTR_0_EN, 0);



	v3d->active_perfmon = NULL;

	mutex_unlock(&perfmon->lock);

}



struct v3d_perfmon *v3d_perfmon_find(struct v3d_file_priv *v3d_priv, int id)

{

	struct v3d_perfmon *perfmon;



	mutex_lock(&v3d_priv->perfmon.lock);

	perfmon = idr_find(&v3d_priv->perfmon.idr, id);

	v3d_perfmon_get(perfmon);

	mutex_unlock(&v3d_priv->perfmon.lock);



	return perfmon;

}



void v3d_perfmon_open_file(struct v3d_file_priv *v3d_priv)

{

	mutex_init(&v3d_priv->perfmon.lock);

	idr_init(&v3d_priv->perfmon.idr);

}



static int v3d_perfmon_idr_del(int id, void *elem, void *data)

{

	struct v3d_perfmon *perfmon = elem;



	v3d_perfmon_put(perfmon);



	return 0;

}



void v3d_perfmon_close_file(struct v3d_file_priv *v3d_priv)

{

	mutex_lock(&v3d_priv->perfmon.lock);

	idr_for_each(&v3d_priv->perfmon.idr, v3d_perfmon_idr_del, NULL);

	idr_destroy(&v3d_priv->perfmon.idr);

	mutex_unlock(&v3d_priv->perfmon.lock);

}



int v3d_perfmon_create_ioctl(struct drm_device *dev, void *data,

			     struct drm_file *file_priv)

{

	struct v3d_file_priv *v3d_priv = file_priv->driver_priv;

	struct drm_v3d_perfmon_create *req = data;

	struct v3d_perfmon *perfmon;

	unsigned int i;

	int ret;



	/* Number of monitored counters cannot exceed HW limits. */

	if (req->ncounters > DRM_V3D_MAX_PERF_COUNTERS ||

	    !req->ncounters)

		return -EINVAL;



	/* Make sure all counters are valid. */

	for (i = 0; i < req->ncounters; i++) {

		if (req->counters[i] >= V3D_PERFCNT_NUM)

			return -EINVAL;

	}



	perfmon = kzalloc(struct_size(perfmon, values, req->ncounters),

			  GFP_KERNEL);

	if (!perfmon)

		return -ENOMEM;



	for (i = 0; i < req->ncounters; i++)

		perfmon->counters[i] = req->counters[i];



	perfmon->ncounters = req->ncounters;



	refcount_set(&perfmon->refcnt, 1);

	mutex_init(&perfmon->lock);



	mutex_lock(&v3d_priv->perfmon.lock);

	ret = idr_alloc(&v3d_priv->perfmon.idr, perfmon, V3D_PERFMONID_MIN,

			V3D_PERFMONID_MAX, GFP_KERNEL);

	mutex_unlock(&v3d_priv->perfmon.lock);



	if (ret < 0) {

		kfree(perfmon);

		return ret;

	}



	req->id = ret;



	return 0;

}



int v3d_perfmon_destroy_ioctl(struct drm_device *dev, void *data,

			      struct drm_file *file_priv)

{

	struct v3d_file_priv *v3d_priv = file_priv->driver_priv;

	struct drm_v3d_perfmon_destroy *req = data;

	struct v3d_perfmon *perfmon;



	mutex_lock(&v3d_priv->perfmon.lock);

	perfmon = idr_remove(&v3d_priv->perfmon.idr, req->id);

	mutex_unlock(&v3d_priv->perfmon.lock);



	if (!perfmon)

		return -EINVAL;



	v3d_perfmon_put(perfmon);



	return 0;

}



int v3d_perfmon_get_values_ioctl(struct drm_device *dev, void *data,

				 struct drm_file *file_priv)

{

	struct v3d_dev *v3d = to_v3d_dev(dev);

	struct v3d_file_priv *v3d_priv = file_priv->driver_priv;

	struct drm_v3d_perfmon_get_values *req = data;

	struct v3d_perfmon *perfmon;

	int ret = 0;



	if (req->pad != 0)

		return -EINVAL;



	mutex_lock(&v3d_priv->perfmon.lock);

	perfmon = idr_find(&v3d_priv->perfmon.idr, req->id);

	v3d_perfmon_get(perfmon);

	mutex_unlock(&v3d_priv->perfmon.lock);



	if (!perfmon)

		return -EINVAL;



	v3d_perfmon_stop(v3d, perfmon, true);



	if (copy_to_user(u64_to_user_ptr(req->values_ptr), perfmon->values,

			 perfmon->ncounters * sizeof(u64)))

		ret = -EFAULT;



	v3d_perfmon_put(perfmon);



	return ret;

}