Commit 067a974f authored by Tvrtko Ursulin's avatar Tvrtko Ursulin Committed by Lucas De Marchi
Browse files

drm/xe: Add performance tunings to debugfs 



Add a list of active tunings to debugfs, analogous to the existing
list of workarounds.

Rationale being that it seems to make sense to either have both or none.

Signed-off-by: default avatarTvrtko Ursulin <tvrtko.ursulin@igalia.com>
Cc: Lucas De Marchi <lucas.demarchi@intel.com>
Cc: Matt Roper <matthew.d.roper@intel.com>
Reviewed-by: default avatarLucas De Marchi <lucas.demarchi@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20250227101304.46660-6-tvrtko.ursulin@igalia.com


Signed-off-by: default avatarLucas De Marchi <lucas.demarchi@intel.com>
parent 4f122372

drivers/gpu/drm/xe/xe_gt.c

+4 −0
Original line number Diff line number Diff line
@@ -362,6 +362,10 @@ int xe_gt_init_early(struct xe_gt *gt) 
	if (err)

		return err;



	err = xe_tuning_init(gt);

	if (err)

		return err;



	xe_wa_process_oob(gt);



	xe_force_wake_init_gt(gt, gt_to_fw(gt));

drivers/gpu/drm/xe/xe_gt_debugfs.c

+11 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include "xe_reg_sr.h"

#include "xe_reg_whitelist.h"

#include "xe_sriov.h"

#include "xe_tuning.h"

#include "xe_uc_debugfs.h"

#include "xe_wa.h"
@@ -217,6 +218,15 @@ static int workarounds(struct xe_gt *gt, struct drm_printer *p) 
	return 0;

}



static int tunings(struct xe_gt *gt, struct drm_printer *p)

{

	xe_pm_runtime_get(gt_to_xe(gt));

	xe_tuning_dump(gt, p);

	xe_pm_runtime_put(gt_to_xe(gt));



	return 0;

}



static int pat(struct xe_gt *gt, struct drm_printer *p)

{

	xe_pm_runtime_get(gt_to_xe(gt));
@@ -300,6 +310,7 @@ static const struct drm_info_list debugfs_list[] = { 
	{"powergate_info", .show = xe_gt_debugfs_simple_show, .data = powergate_info},

	{"register-save-restore", .show = xe_gt_debugfs_simple_show, .data = register_save_restore},

	{"workarounds", .show = xe_gt_debugfs_simple_show, .data = workarounds},

	{"tunings", .show = xe_gt_debugfs_simple_show, .data = tunings},

	{"pat", .show = xe_gt_debugfs_simple_show, .data = pat},

	{"mocs", .show = xe_gt_debugfs_simple_show, .data = mocs},

	{"default_lrc_rcs", .show = xe_gt_debugfs_simple_show, .data = rcs_default_lrc},

drivers/gpu/drm/xe/xe_gt_types.h

+10 −0
Original line number Diff line number Diff line
@@ -413,6 +413,16 @@ struct xe_gt { 
		bool oob_initialized;

	} wa_active;



	/** @tuning_active: keep track of active tunings */

	struct {

		/** @tuning_active.gt: bitmap with active GT tunings */

		unsigned long *gt;

		/** @tuning_active.engine: bitmap with active engine tunings */

		unsigned long *engine;

		/** @tuning_active.lrc: bitmap with active LRC tunings */

		unsigned long *lrc;

	} tuning_active;



	/** @user_engines: engines present in GT and available to userspace */

	struct {

		/**

drivers/gpu/drm/xe/xe_tuning.c

+59 −0
Original line number Diff line number Diff line
@@ -7,6 +7,8 @@ 


#include <kunit/visibility.h>



#include <drm/drm_managed.h>



#include "regs/xe_gt_regs.h"

#include "xe_gt_types.h"

#include "xe_platform_types.h"
@@ -140,10 +142,44 @@ static const struct xe_rtp_entry_sr lrc_tunings[] = { 
	{}

};



/**

 * xe_tuning_init - initialize gt with tunings bookkeeping

 * @gt: GT instance to initialize

 *

 * Returns 0 for success, negative error code otherwise.

 */

int xe_tuning_init(struct xe_gt *gt)

{

	struct xe_device *xe = gt_to_xe(gt);

	size_t n_lrc, n_engine, n_gt, total;

	unsigned long *p;



	n_gt = BITS_TO_LONGS(ARRAY_SIZE(gt_tunings));

	n_engine = BITS_TO_LONGS(ARRAY_SIZE(engine_tunings));

	n_lrc = BITS_TO_LONGS(ARRAY_SIZE(lrc_tunings));

	total = n_gt + n_engine + n_lrc;



	p = drmm_kzalloc(&xe->drm, sizeof(*p) * total, GFP_KERNEL);

	if (!p)

		return -ENOMEM;



	gt->tuning_active.gt = p;

	p += n_gt;

	gt->tuning_active.engine = p;

	p += n_engine;

	gt->tuning_active.lrc = p;



	return 0;

}

ALLOW_ERROR_INJECTION(xe_tuning_init, ERRNO); /* See xe_pci_probe() */



void xe_tuning_process_gt(struct xe_gt *gt)

{

	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(gt);



	xe_rtp_process_ctx_enable_active_tracking(&ctx,

						  gt->tuning_active.gt,

						  ARRAY_SIZE(gt_tunings));

	xe_rtp_process_to_sr(&ctx, gt_tunings, &gt->reg_sr);

}

EXPORT_SYMBOL_IF_KUNIT(xe_tuning_process_gt);
@@ -152,6 +188,9 @@ void xe_tuning_process_engine(struct xe_hw_engine *hwe) 
{

	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe);



	xe_rtp_process_ctx_enable_active_tracking(&ctx,

						  hwe->gt->tuning_active.engine,

						  ARRAY_SIZE(engine_tunings));

	xe_rtp_process_to_sr(&ctx, engine_tunings, &hwe->reg_sr);

}

EXPORT_SYMBOL_IF_KUNIT(xe_tuning_process_engine);
@@ -168,5 +207,25 @@ void xe_tuning_process_lrc(struct xe_hw_engine *hwe) 
{

	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe);



	xe_rtp_process_ctx_enable_active_tracking(&ctx,

						  hwe->gt->tuning_active.lrc,

						  ARRAY_SIZE(lrc_tunings));

	xe_rtp_process_to_sr(&ctx, lrc_tunings, &hwe->reg_lrc);

}



void xe_tuning_dump(struct xe_gt *gt, struct drm_printer *p)

{

	size_t idx;



	drm_printf(p, "GT Tunings\n");

	for_each_set_bit(idx, gt->tuning_active.gt, ARRAY_SIZE(gt_tunings))

		drm_printf_indent(p, 1, "%s\n", gt_tunings[idx].name);



	drm_printf(p, "\nEngine Tunings\n");

	for_each_set_bit(idx, gt->tuning_active.engine, ARRAY_SIZE(engine_tunings))

		drm_printf_indent(p, 1, "%s\n", engine_tunings[idx].name);



	drm_printf(p, "\nLRC Tunings\n");

	for_each_set_bit(idx, gt->tuning_active.lrc, ARRAY_SIZE(lrc_tunings))

		drm_printf_indent(p, 1, "%s\n", lrc_tunings[idx].name);

}

drivers/gpu/drm/xe/xe_tuning.h

+3 −0
Original line number Diff line number Diff line
@@ -6,11 +6,14 @@ 
#ifndef _XE_TUNING_

#define _XE_TUNING_



struct drm_printer;

struct xe_gt;

struct xe_hw_engine;



int xe_tuning_init(struct xe_gt *gt);

void xe_tuning_process_gt(struct xe_gt *gt);

void xe_tuning_process_engine(struct xe_hw_engine *hwe);

void xe_tuning_process_lrc(struct xe_hw_engine *hwe);

void xe_tuning_dump(struct xe_gt *gt, struct drm_printer *p);



#endif