Multi-CCS support in IGT
Subsystems (2)
v10 cover Multi-CCS support in IGT
From: Nishit Sharma <[email protected]>
Revision 1:
Added loop_kernel_duration in available pipelines. loop_kernel_duration holds sleep duration and during sleep GPU will be workng. Patch-1/3: loop_kernel_duration addition in available pipelines in lib/intel_compute.c. igt_skip is called in pipeline which doesn't support loop_kernel shader.
Patch-2/3: Added loop-duration-2s subtest in tests/intel/xe_compute to test if GPU is executing shader when sleep is called. This is verfied using gputop in another terminal. This also tests whether the test executed successfully in >= 2seconds of duration set Patch-3/3: Added eu-busy-10s test which creates multi threads depending on num_slices available and schedules workload on all ccs instances available. This also prints engine utlization in percentage while workload is executing.
v2:
- Addressed review comments from Zbyshek on description in Patch-1.
- Added execution time check in Patch-2 regarding single iteration of scheduling and executing workload on single instance of CCS engine.
v3:
- Added missing code section in Patch-1.
- Modified LOOP_DURATIOn macro to LOOP_DURATION_2s to avoid confusion.
- Used LOOP_DURATION_2s in place of LOOP_DURATION and adjusted sleep durations.
v4:
- Test will skip if sriov is enabled and sriov_numfs > 0.
- Test will continue runing if sriov_numvfs = 0
v5:
- Incorporated review comments (Zbigniew)
v6:
- Simplified logic to capture EU busyness
- Removed header which had pmu counter and engine instance logic
- Moved pthread_data structure to xe_compute file which is used during thread creation
v7:
- collective counters are set per compute engine available in t->eci
- fixed few nits
v8:
- Incorporated review comments (Zbigniew)
- After workload execution set back ccs_mode to default value
v9:
- Moved get_gt_mask() in igt_fixture to avoid build failure
v10:
- Moved sriov enabled check in igt_fixture to skip test if sriov is enabled without initilializing or creation of threads.
- Moved check for loop_kernel support in pipeline in igt_fixture
v11:
- Moved sriov enabled check in subtests which is setting ccs_mode value
- loop_kernel support check moved in subtests which are using loop_kernel
v12:
- Added sriov enable check in subtest eu-busy-10s
Nishit Sharma (3):
lib/intel_compute: loop_kernel_duration in Pipeline tests/intel/xe_compute: Add loop_duration_2s subtest tests/intel/xe_compute: Add eu-busy-10s test
lib/intel_compute.c | 26 ++- lib/intel_compute.h | 2 + tests/intel/xe_compute.c | 349 ++++++++++++++++++++++++++++++++++++++- tests/meson.build | 1 + 4 files changed, 374 insertions(+), 4 deletions(-)
Signature · 1 line
2.43.0
PATCH v10 1/3 lib/intel_compute: loop_kernel_duration in Pipeline
From: Nishit Sharma <[email protected]>
Incase of multi-ccs it is expected that all ccs engines will be busy. There's no existing code which keeps GPU busy for a specified duration, So we need to terminate loop kernel from CPU after the desired time has elapsed.
Introduce the loop_kernel_duration variable to control kernel execution duration in compute pipelines. Currently this is supported in xe2lg and xe3lpg pipelines.
--- lib/intel_compute.c | 26 +++++++++++++++++++++++++- lib/intel_compute.h | 2 ++ 2 files changed, 27 insertions(+), 1 deletion(-)
lib/intel_compute.c +25 -1
@@ -849,6 +849,9 @@ static void compute_exec(int fd, const unsigned char *kernel,uint16_t devid =intel_get_drm_devid (fd);int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1131,6 +1134,9 @@ static void xehp_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1343,6 +1349,9 @@ static void xehpc_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1731,6 +1740,9 @@ static void xelpg_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1818,6 +1830,7 @@ static void xe2lpg_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_input_addr = (user && user->input_addr) ? user->input_addr :ADDR_INPUT ;uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +int64_t timeout_one_ns =1 ;bo_execenv_create (fd, &execenv, eci, user);
@@ -1849,7 +1862,18 @@ static void xe2lpg_compute_exec(int fd, const unsigned char *kernel,OFFSET_KERNEL ,0 , false, execenv.array_size); -bo_execenv_exec (&execenv,ADDR_BATCH ); +if (user && user->loop_kernel_duration) { +bo_execenv_exec_async (&execenv,ADDR_BATCH ); +igt_measured_usleep (user->loop_kernel_duration); +/* Check that the loop kernel has not completed yet */ +igt_assert_neq (0 ,__xe_wait_ufence (fd, &execenv.bo_sync->sync,USER_FENCE_VALUE , + execenv.exec_queue, &timeout_one_ns)); + ((int *)bo_dict[4 ].data)[0 ] =MAGIC_LOOP_STOP ; +bo_execenv_sync (&execenv); + user->skip_results_check =1 ; + }else { +bo_execenv_exec (&execenv,ADDR_BATCH ); + }if (!user || (user && !user->skip_results_check))bo_check_square (input_data, output_data, execenv.array_size);
lib/intel_compute.h +2 -0
@@ -63,6 +63,8 @@ struct user_execenv {uint64_t input_addr;/** @output_addr: override default address of the output array if provided */ uint64_t output_addr; +/** @loop_kernel_duration: duration till kernel should execute in gpu **/ +uint64_t loop_kernel_duration; };enum execenv_alloc_prefs {
Signature · 1 line
2.43.0
PATCH v10 2/3 tests/intel/xe_compute: Add loop_duration_2s subtest
In reply to [email protected]From: Nishit Sharma <[email protected]>
Verify introduced loop_kernel_duration parameter in user_execenv which makes GPU busy for specified duration. Execution should remain within a 0.2 second margin of the requested duration. loop_kernel shader is not supported in xehpc, xehp, xelpg pipelines so test will skip.
--- tests/intel/xe_compute.c | 61 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+)
tests/intel/xe_compute.c +61 -0
@@ -19,6 +19,9 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#define LOOP_DURATION_2s (1000000ull * 2) +#define DURATION_MARGIN 0.2 +static int gt_sysfs_open (int gt) {int fd, gt_fd;
@@ -186,6 +189,60 @@ test_compute_kernel_with_ccs_mode(void)igt_require (num_gt_with_ccs_mode >0 ); } +static double elapsed (const struct timeval *start, +const struct timeval *end) +{ +return (end->tv_sec - start->tv_sec) +1e-6 *(end->tv_usec - start->tv_usec); +} + +/** +* SUBTEST: loop-duration-2s +* Functionality: OpenCL kernel +* Description: +* Run an openCL loop Kernel that for duration, +* set in loop_kernel_duration .. +*/ +static void +test_compute_kernel_loop (uint64_t loop_duration) +{ +int fd; +unsigned int ip_ver; +const struct intel_compute_kernels *kernels; +struct user_execenv execenv = {0 }; +struct drm_xe_engine_class_instance *hwe; +struct timeval start, end; + + fd =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; + +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* loop_kernel_duration used as sleep to make EU busy for loop_duration */ + execenv.loop_kernel_duration = loop_duration; + execenv.kernel = kernels->loop_kernel; + execenv.kernel_size = kernels->loop_kernel_size; + +xe_for_each_engine (fd, hwe) { +if (hwe->engine_class !=DRM_XE_ENGINE_CLASS_COMPUTE ) +continue ; + +igt_info ("Running loop_kernel on ccs engine %d\n" , hwe->engine_instance); +gettimeofday (&start,NULL ); +igt_assert_f (xe_run_intel_compute_kernel_on_engine (fd, hwe, &execenv, +EXECENV_PREF_SYSTEM ), +"Unable to run compute kernel successfully\n" ); +gettimeofday (&end,NULL ); +igt_assert ((double )(loop_duration / LOOP_DURATION_2s -DURATION_MARGIN ) <elapsed (&start, &end) && + (double )(loop_duration / LOOP_DURATION_2s +DURATION_MARGIN )); + } +drm_close_driver (fd); +} +/** * SUBTEST: compute-square * Mega feature: WMTP
@@ -223,4 +280,8 @@ igt_main igt_subtest("ccs-mode-compute-kernel")test_compute_kernel_with_ccs_mode (); + +/* To test compute function stops after loop_kernel_duration */ + igt_subtest("loop-duration-2s") +test_compute_kernel_loop (LOOP_DURATION_2s); }
Signature · 1 line
2.43.0
PATCH v10 3/3 tests/intel/xe_compute: Add eu-busy-10s test
In reply to [email protected]From: Nishit Sharma <[email protected]>
Add multi threading to utilize available CCS instances as per num_slices available in /sys/class/drm/cardX/device/tileX/gtX/num_cslices. Depending upon num_slices, number of threads will be created and schedule compute workload in different CCS instances. Sleep is called via loop_kernel_duration so that HW engine runs for sleep duration. During execution per EU utlization percentage is grabbed and displayed on console. Added igt_skip() if sriov is enabled in platform, so if sriov_numvfs > 0 then test will be skipped.
--- tests/intel/xe_compute.c | 290 ++++++++++++++++++++++++++++++++++++++- tests/meson.build | 1 + 2 files changed, 287 insertions(+), 4 deletions(-)
tests/intel/xe_compute.c +286 -4
@@ -19,9 +19,24 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#include "igt_perf.h" +#include "igt_sriov_device.h" +#define LOOP_DURATION_2s (1000000ull * 2)#define DURATION_MARGIN 0.2 +struct thread_data { +pthread_t thread; +pthread_mutex_t *mutex; +pthread_cond_t *cond; +int class; +int fd; +int gt; +struct user_execenv *execenv; +struct drm_xe_engine_class_instance *eci; +bool *go; +}; +static int gt_sysfs_open (int gt) {int fd, gt_fd;
@@ -243,6 +258,233 @@ test_compute_kernel_loop(uint64_t loop_duration)drm_close_driver (fd); } +static void +*intel_compute_thread (void *data) +{ +struct thread_data *t = (struct thread_data *)data; +char device[30 ]; +uint64_t type; +uint32_t engine_class, engine_instance, gt_shift; +uint64_t engine_active_config, engine_total_config; +int ret, fd1, fd2; +uint64_t val[4 ]; +uint64_t param_config; + +pthread_mutex_lock (t->mutex); +while (*t->go ==0 ) +pthread_cond_wait (t->cond, t->mutex); +pthread_mutex_unlock (t->mutex); + + type =igt_perf_type_id (xe_perf_device (t->fd, device,sizeof (device))); +igt_debug ("type: %lx, device: %s\n" , type, device); + +perf_event_format (device,"gt" , >_shift); +perf_event_format (device,"engine_class" , &engine_class); +perf_event_format (device,"engine_instance" , &engine_instance); + + ret =perf_event_config (device,"engine-active-ticks" , &engine_active_config); +igt_assert_eq (ret,0 ); + ret =perf_event_config (device,"engine-total-ticks" , &engine_total_config); +igt_assert_eq (ret,0 ); + +igt_debug ("gt_id: %x, class: %x, instance: %x\n" , + t->eci->gt_id, t->eci->engine_class, t->eci->engine_instance); + +/* Setting collective counters for compute engine available in t->eci */ + param_config = (uint64_t )t->eci->gt_id << gt_shift | + t->eci->engine_class << engine_class | + t->eci->engine_instance << engine_instance; + + fd1 =igt_perf_open_group (type, engine_active_config | param_config,-1 ); + fd2 =igt_perf_open_group (type, engine_total_config | param_config, fd1); +igt_debug ("fd1: %d, fd2: %d\n" , fd1, fd2); + + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("start - active: %ld, total: %ld, busyness: %.1f before scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); + +igt_assert_f (xe_run_intel_compute_kernel_on_engine (t->fd, t->eci, t->execenv, +EXECENV_PREF_VRAM_IF_POSSIBLE ), +"Unable to run compute kernel successfully\n" ); + + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("end - active: %ld, total: %ld, busyness: %.1f after scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); + +igt_assert_f (((float )val[2 ] / (float )val[3 ] *100.0 ) >50.0 , +"Engines utilization is below 50 perc\n" ); + +close (fd1); +close (fd2); +return NULL ; +} + +static void +igt_check_supported_pipeline (void ) +{ +int fd; +unsigned int ip_ver; +const struct intel_compute_kernels *kernels; + + fd =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; + +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* skip if loop_kernel is not supported by pipeline */ +if (!kernels->kernel || !kernels->loop_kernel) { +drm_close_driver (fd); +igt_skip ("loop_kernel not supported by pipeline\n" ); + }else { +igt_info ("loop kernel supported by pipeline\n" ); +drm_close_driver (fd); + } +} + +static void +igt_check_sriov (void ) +{ +int fd =drm_open_driver (DRIVER_XE ); + +if (igt_sriov_is_pf (fd) &&igt_sriov_vfs_supported (fd)) { +drm_close_driver (fd); +igt_skip ("Skipping test when SRIOV is enabled\n" ); + } +drm_close_driver (fd); +} + +static void +igt_set_ccs_default_value (int ccs_mode[],int size) +{ +uint64_t gt_mask =get_gt_mask (); +u32 gt, num_slices; +int gt_fd; + +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , ccs_mode[gt]) >0 ); +close (gt_fd); + } +} + +/** +* SUBTEST: eu-busy-10s +* Functionality: OpenCL kernel +* Description: Run loop_kernel for duration_sec and observe EU business +*/ +static void +test_eu_busy (uint64_t duration_sec) +{ +struct user_execenv execenv = {0 }; +struct thread_data *threads_data; +struct drm_xe_engine_class_instance *hwe; +const struct intel_compute_kernels *kernels; +pthread_mutex_t mutex; +pthread_cond_t cond; +u32 gt, n_threads =0 , iterations =0 , n_instances =0 , i; +bool go = false; +int ccs_mode, gt_fd, fd; +u32 num_slices, ip_ver; +uint64_t gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , num_slices) >0 ); +igt_assert (igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode) >0 ); +close (gt_fd); + } + +igt_skip_on_f (ccs_mode <=1 ,"Skipping test as ccs_mode <=1 not matching criteria :%d\n" , + ccs_mode); + + fd =drm_open_driver (DRIVER_XE ); + + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* +* User should use different kernel if loop_kernel_duration not set +* With loop kernel and loop duration it assumes we stop it via memory write +* +*/ + + execenv.loop_kernel_duration = duration_sec; + execenv.kernel = kernels->loop_kernel; + execenv.kernel_size = kernels->loop_kernel_size; +drm_close_driver (fd); + + gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { + fd =drm_open_driver (DRIVER_XE ); +xe_for_each_engine (fd, hwe) { +igt_assert (hwe); +if (hwe->engine_class ==DRM_XE_ENGINE_CLASS_COMPUTE ) + ++n_instances; + } +drm_close_driver (fd); + } + + threads_data =calloc (n_instances,sizeof (*threads_data)); +igt_assert (threads_data); + +pthread_mutex_init (&mutex,0 ); +pthread_cond_init (&cond,0 ); + + gt_mask =get_gt_mask (); + fd =drm_open_driver (DRIVER_XE ); +for_each_bit (gt_mask, gt) { +xe_for_each_engine (fd, hwe) { +if (hwe->gt_id != gt || + hwe->engine_class !=DRM_XE_ENGINE_CLASS_COMPUTE ) +continue ; + + threads_data[i].mutex = &mutex; + threads_data[i].cond = &cond; + threads_data[i].fd = fd; + threads_data[i].eci = hwe; + threads_data[i].go = &go; + threads_data[i].execenv = &execenv; + ++n_threads; +pthread_create (&threads_data[i].thread,0 , intel_compute_thread, + &threads_data[i]); + ++i; + ++iterations; + } +pthread_mutex_lock (&mutex); + go = true; +pthread_cond_broadcast (&cond); +pthread_mutex_unlock (&mutex); + +for (int val =0 ; val < i; ++val) +pthread_join (threads_data[val].thread,NULL ); + + i =0 ; + n_threads =0 ; + iterations =0 ; + } +free (threads_data); +drm_close_driver (fd); +} +/** * SUBTEST: compute-square * Mega feature: WMTP
@@ -262,10 +504,24 @@ test_compute_square(int fd) igt_main { -int xe; +int xe, ccs_mode[4 ], gt_fd, gt; +unsigned int ip_ver; +u32 num_slices; +uint64_t gt_mask; igt_fixture { + xe =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (xe)); + gt_mask =get_gt_mask (); +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode[gt]); +close (gt_fd); + } }igt_subtest ("compute-square" )
@@ -275,13 +531,39 @@ igt_maindrm_close_driver (xe);/* ccs mode tests should be run without open gpu file handles */ - igt_subtest("ccs-mode-basic") + igt_subtest("ccs-mode-basic") { +/* skip if sriov enabled */ +igt_check_sriov ();test_ccs_mode (); + } - igt_subtest("ccs-mode-compute-kernel") + igt_subtest("ccs-mode-compute-kernel") { +/* skip if sriov enabled */ +igt_check_sriov ();test_compute_kernel_with_ccs_mode (); + }/* To test compute function stops after loop_kernel_duration */ - igt_subtest("loop-duration-2s") + igt_subtest("loop-duration-2s") { +/* skip test if loop_kernel not supported in pipeline */ +if (ip_ver <IP_VER (20 ,0 )) +igt_check_supported_pipeline (); +test_compute_kernel_loop (LOOP_DURATION_2s); + } + +/* test to check available EU utilisation in multi-ccs case */ + igt_subtest("eu-busy-10s") { +/* skip if sriov enabled */ +igt_check_sriov (); + +/* skip test if loop_kernel not supported in pipeline */ +if (ip_ver <IP_VER (20 ,0 )) +igt_check_supported_pipeline (); + +test_eu_busy (5 * LOOP_DURATION_2s); +/* calling sleep to make sure EUs done with execution */ +sleep (3 ); +igt_set_ccs_default_value (ccs_mode,sizeof (ccs_mode)); + } }
tests/meson.build +1 -0
@@ -408,6 +408,7 @@ extra_dependencies = { 'sw_sync': [ libatomic ], 'xe_fault_injection': [ lib_igt_xe_oa ], 'xe_oa': [ lib_igt_xe_oa ], + 'xe_compute': [ igt_deps,lib_igt_perf,lib_igt_profiling,math ], } test_executables = []
Signature · 1 line
2.43.0
Re: [PATCH i-g-t v10 3/3] tests/intel/xe_compute: Add eu-busy-10s test
Quoted 10 lines · On Wed, Nov 05, 2025 at 03:51:34AM +0000, [email protected] wrote:
From: Nishit Sharma <[email protected]>
Add multi threading to utilize available CCS instances as per
num_slicesavailable in/sys/class/drm/cardX/device/tileX/gtX/num_cslices. Depending uponnum_slices, number of threads will be created and schedule compute workload in different CCS instances. Sleep is called vialoop_kernel_durationso that HW engine runs for sleep duration. During execution per EU utlization percentage is grabbed and displayed on console. Addedigt_skip()if sriov is enabled in platform, so ifsriov_numvfs> 0 then test will be skipped.
You should rephrase commit message to explain why you need the test and what it does. Information that you're using multiple threads is irrelevant, that's only implementation detail.
Quoted 70 lines
Signed-off-by Nishit Sharma <[email protected]>--- tests/intel/xe_compute.c | 290 ++++++++++++++++++++++++++++++++++++++- tests/meson.build | 1 + 2 files changed, 287 insertions(+), 4 deletions(-)tests/intel/xe_compute.c +45
-0@@ -19,9 +19,24 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#include "igt_perf.h" +#include "igt_sriov_device.h" +#define LOOP_DURATION_2s (1000000ull * 2)#define DURATION_MARGIN 0.2 +struct thread_data { +pthread_t thread; +pthread_mutex_t *mutex; +pthread_cond_t *cond; +int class; +int fd; +int gt; +struct user_execenv *execenv; +struct drm_xe_engine_class_instance *eci; +bool *go; +}; +static int gt_sysfs_open (int gt) {int fd, gt_fd;@@ -243,6 +258,233 @@ test_compute_kernel_loop(uint64_t loop_duration)drm_close_driver (fd); } +static void +*intel_compute_thread (void *data) +{ +struct thread_data *t = (struct thread_data *)data; +char device[30 ]; +uint64_t type; +uint32_t engine_class, engine_instance, gt_shift; +uint64_t engine_active_config, engine_total_config; +int ret, fd1, fd2; +uint64_t val[4 ]; +uint64_t param_config; + +pthread_mutex_lock (t->mutex); +while (*t->go ==0 ) +pthread_cond_wait (t->cond, t->mutex); +pthread_mutex_unlock (t->mutex); + + type =igt_perf_type_id (xe_perf_device (t->fd, device,sizeof (device))); +igt_debug ("type: %lx, device: %s\n" , type, device); + +perf_event_format (device,"gt" , >_shift); +perf_event_format (device,"engine_class" , &engine_class); +perf_event_format (device,"engine_instance" , &engine_instance); + + ret =perf_event_config (device,"engine-active-ticks" , &engine_active_config); +igt_assert_eq (ret,0 ); + ret =perf_event_config (device,"engine-total-ticks" , &engine_total_config); +igt_assert_eq (ret,0 ); + + igt_debug("gt_id: %x, class: %x, instance: %x\n",
tests/intel/xe_compute.c test_compute_kernel_loop(uint64_t loop_duration) · line 300
Quoted 10 lines
tests/intel/xe_compute.c +10
-0+ t->eci->gt_id, t->eci->engine_class, t->eci->engine_instance); + +/* Setting collective counters for compute engine available in t->eci */ + param_config = (uint64_t )t->eci->gt_id << gt_shift | + t->eci->engine_class << engine_class | + t->eci->engine_instance << engine_instance; + + fd1 =igt_perf_open_group (type, engine_active_config | param_config,-1 ); + fd2 =igt_perf_open_group (type, engine_total_config | param_config, fd1); +igt_debug ("fd1: %d, fd2: %d\n" , fd1, fd2);
Drop above debug, it is not needed.
Quoted 6 lines
tests/intel/xe_compute.c +6
-0+ + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("start - active: %ld, total: %ld, busyness: %.1f before scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); +
tests/intel/xe_compute.c test_compute_kernel_loop(uint64_t loop_duration) · line 316
Quoted 10 lines
tests/intel/xe_compute.c +10
-0+igt_assert_f (xe_run_intel_compute_kernel_on_engine (t->fd, t->eci, t->execenv, +EXECENV_PREF_VRAM_IF_POSSIBLE ), +"Unable to run compute kernel successfully\n" ); + + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("end - active: %ld, total: %ld, busyness: %.1f after scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); + + igt_assert_f(((float)val[2] / (float)val[3] * 100.0) > 50.0,
50%? We expect almost near 100%.
Quoted 6 lines
tests/intel/xe_compute.c +6
-0+ "Engines utilization is below 50 perc\n"); + +close (fd1); +close (fd2); +return NULL ; +}
tests/intel/xe_compute.c test_compute_kernel_loop(uint64_t loop_duration) · line 332
Quoted 10 lines
tests/intel/xe_compute.c +10
-0+ +static void +igt_check_supported_pipeline (void ) +{ +int fd; +unsigned int ip_ver; +const struct intel_compute_kernels *kernels; + + fd =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd));
You may close fd here.
Quoted 22 lines
tests/intel/xe_compute.c +22
-0+ kernels = intel_compute_square_kernels; + +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* skip if loop_kernel is not supported by pipeline */ +if (!kernels->kernel || !kernels->loop_kernel) { +drm_close_driver (fd); +igt_skip ("loop_kernel not supported by pipeline\n" ); + }else { +igt_info ("loop kernel supported by pipeline\n" ); +drm_close_driver (fd); + } +} + +static void +igt_check_sriov (void ) +{ +int fd =drm_open_driver (DRIVER_XE );
tests/intel/xe_compute.c test_compute_kernel_loop(uint64_t loop_duration) · line 364
Quoted 10 lines
tests/intel/xe_compute.c +10
-0+ +if (igt_sriov_is_pf (fd) &&igt_sriov_vfs_supported (fd)) { +drm_close_driver (fd); +igt_skip ("Skipping test when SRIOV is enabled\n" ); + } +drm_close_driver (fd); +} + +static void +igt_set_ccs_default_value (int ccs_mode[],int size)
I suggest to rename to igt_restore_ccs_mode().
Quoted 4 lines
tests/intel/xe_compute.c +4
-0+{ +uint64_t gt_mask =get_gt_mask (); +u32 gt, num_slices; +int gt_fd;
tests/intel/xe_compute.c test_compute_kernel_loop(uint64_t loop_duration) · line 378
Quoted 10 lines
tests/intel/xe_compute.c +10
-0+ +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , ccs_mode[gt]) >0 ); +close (gt_fd); + } +}
And add counterpart igt_store_ccs_mode(), which will contain ccs_mode store loop from igt_fixture.
Quoted 125 lines
tests/intel/xe_compute.c +114
-1+ +/** +* SUBTEST: eu-busy-10s +* Functionality: OpenCL kernel +* Description: Run loop_kernel for duration_sec and observe EU business +*/ +static void +test_eu_busy (uint64_t duration_sec) +{ +struct user_execenv execenv = {0 }; +struct thread_data *threads_data; +struct drm_xe_engine_class_instance *hwe; +const struct intel_compute_kernels *kernels; +pthread_mutex_t mutex; +pthread_cond_t cond; +u32 gt, n_threads =0 , iterations =0 , n_instances =0 , i; +bool go = false; +int ccs_mode, gt_fd, fd; +u32 num_slices, ip_ver; +uint64_t gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , num_slices) >0 ); +igt_assert (igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode) >0 ); +close (gt_fd); + } + +igt_skip_on_f (ccs_mode <=1 ,"Skipping test as ccs_mode <=1 not matching criteria :%d\n" , + ccs_mode); + + fd =drm_open_driver (DRIVER_XE ); + + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* +* User should use different kernel if loop_kernel_duration not set +* With loop kernel and loop duration it assumes we stop it via memory write +* +*/ + + execenv.loop_kernel_duration = duration_sec; + execenv.kernel = kernels->loop_kernel; + execenv.kernel_size = kernels->loop_kernel_size; +drm_close_driver (fd); + + gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { + fd =drm_open_driver (DRIVER_XE ); +xe_for_each_engine (fd, hwe) { +igt_assert (hwe); +if (hwe->engine_class ==DRM_XE_ENGINE_CLASS_COMPUTE ) + ++n_instances; + } +drm_close_driver (fd); + } + + threads_data =calloc (n_instances,sizeof (*threads_data)); +igt_assert (threads_data); + +pthread_mutex_init (&mutex,0 ); +pthread_cond_init (&cond,0 ); + + gt_mask =get_gt_mask (); + fd =drm_open_driver (DRIVER_XE ); +for_each_bit (gt_mask, gt) { +xe_for_each_engine (fd, hwe) { +if (hwe->gt_id != gt || + hwe->engine_class !=DRM_XE_ENGINE_CLASS_COMPUTE ) +continue ; + + threads_data[i].mutex = &mutex; + threads_data[i].cond = &cond; + threads_data[i].fd = fd; + threads_data[i].eci = hwe; + threads_data[i].go = &go; + threads_data[i].execenv = &execenv; + ++n_threads; +pthread_create (&threads_data[i].thread,0 , intel_compute_thread, + &threads_data[i]); + ++i; + ++iterations; + } +pthread_mutex_lock (&mutex); + go = true; +pthread_cond_broadcast (&cond); +pthread_mutex_unlock (&mutex); + +for (int val =0 ; val < i; ++val) +pthread_join (threads_data[val].thread,NULL ); + + i =0 ; + n_threads =0 ; + iterations =0 ; + } +free (threads_data); +drm_close_driver (fd); +} +/** * SUBTEST: compute-square * Mega feature: WMTP @@ -262,10 +504,24 @@ test_compute_square(int fd) igt_main { -int xe; +int xe, ccs_mode[4 ], gt_fd, gt; +unsigned int ip_ver; +u32 num_slices; +uint64_t gt_mask; igt_fixture { + xe =drm_open_driver (DRIVER_XE );
tests/intel/xe_compute.c test_compute_square(int fd) · line 524
Quoted 10 lines
tests/intel/xe_compute.c +10
-0+ ip_ver =intel_graphics_ver (intel_get_drm_devid (xe)); + gt_mask =get_gt_mask (); +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode[gt]); +close (gt_fd); + }
Migrate above ccs_mode store loop to igt_store_ccs_mode().
Quoted 33 lines
tests/intel/xe_compute.c +17
-3}igt_subtest ("compute-square" )@@ -275,13 +531,39 @@ igt_maindrm_close_driver (xe);/* ccs mode tests should be run without open gpu file handles */ - igt_subtest("ccs-mode-basic") + igt_subtest("ccs-mode-basic") { +/* skip if sriov enabled */ +igt_check_sriov ();test_ccs_mode (); + } - igt_subtest("ccs-mode-compute-kernel") + igt_subtest("ccs-mode-compute-kernel") { +/* skip if sriov enabled */ +igt_check_sriov ();test_compute_kernel_with_ccs_mode (); + }/* To test compute function stops after loop_kernel_duration */ - igt_subtest("loop-duration-2s") + igt_subtest("loop-duration-2s") { +/* skip test if loop_kernel not supported in pipeline */ +if (ip_ver <IP_VER (20 ,0 )) +igt_check_supported_pipeline (); +test_compute_kernel_loop (LOOP_DURATION_2s); + } + +/* test to check available EU utilisation in multi-ccs case */ + igt_subtest("eu-busy-10s") {
tests/intel/xe_compute.c igt_main · line 566
Quoted 10 lines
tests/intel/xe_compute.c +10
-0+/* skip if sriov enabled */ +igt_check_sriov (); + +/* skip test if loop_kernel not supported in pipeline */ +if (ip_ver <IP_VER (20 ,0 )) +igt_check_supported_pipeline (); + +test_eu_busy (5 * LOOP_DURATION_2s); +/* calling sleep to make sure EUs done with execution */ +sleep (3 );
I don't understand above sleep. We're writing magic value to stop the loop kernel, then we sync. There's no job on EU then.
--
Zbigniew
Quoted 18 lines
tests/intel/xe_compute.c +2
-0+igt_set_ccs_default_value (ccs_mode,sizeof (ccs_mode)); + } }tests/meson.build +1
-0@@ -408,6 +408,7 @@ extra_dependencies = { 'sw_sync': [ libatomic ], 'xe_fault_injection': [ lib_igt_xe_oa ], 'xe_oa': [ lib_igt_xe_oa ], + 'xe_compute': [ igt_deps,lib_igt_perf,lib_igt_profiling,math ], } test_executables = []Signature · 1 line
2.43.0