| Message ID | 20190322092155.1656-17-chris@chris-wilson.co.uk (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | [i-g-t,01/24] i915/gem_exec_latency: Measure the latency of context switching | expand |
On 22/03/2019 09:21, Chris Wilson wrote: > Exercise cloning contexts, an extension of merely creating one. > > Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> > --- > tests/Makefile.sources | 1 + > tests/i915/gem_ctx_clone.c | 421 +++++++++++++++++++++++++++++++++++++ > tests/meson.build | 1 + > 3 files changed, 423 insertions(+) > create mode 100644 tests/i915/gem_ctx_clone.c > > diff --git a/tests/Makefile.sources b/tests/Makefile.sources > index 809b25612..12f4bbd75 100644 > --- a/tests/Makefile.sources > +++ b/tests/Makefile.sources > @@ -21,6 +21,7 @@ TESTS_progs = \ > drm_import_export \ > drm_mm \ > drm_read \ > + i915/gem_ctx_clone \ > i915/gem_vm_create \ > kms_3d \ > kms_addfb_basic \ > diff --git a/tests/i915/gem_ctx_clone.c b/tests/i915/gem_ctx_clone.c > new file mode 100644 > index 000000000..7d83c6350 > --- /dev/null > +++ b/tests/i915/gem_ctx_clone.c > @@ -0,0 +1,421 @@ > +/* > + * Copyright © 2019 Intel Corporation > + * > + * Permission is hereby granted, free of charge, to any person obtaining a > + * copy of this software and associated documentation files (the "Software"), > + * to deal in the Software without restriction, including without limitation > + * the rights to use, copy, modify, merge, publish, distribute, sublicense, > + * and/or sell copies of the Software, and to permit persons to whom the > + * Software is furnished to do so, subject to the following conditions: > + * > + * The above copyright notice and this permission notice (including the next > + * paragraph) shall be included in all copies or substantial portions of the > + * Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL > + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER > + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING > + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS > + * IN THE SOFTWARE. > + */ > + > +#include "igt.h" > +#include "i915/gem_vm.h" > +#include "i915_drm.h" > + > +static int __create_ext(int i915, struct drm_i915_gem_context_create_ext *arg) > +{ > + int err; > + > + err = 0; > + if (igt_ioctl(i915, DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, arg)) > + err = -errno; > + > + errno = 0; > + return err; > +} > + > +static bool has_ctx_clone(int i915) > +{ > + struct drm_i915_gem_context_create_ext_clone ext = { > + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, > + .clone_id = -1, > + }; > + struct drm_i915_gem_context_create_ext create = { > + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, > + .extensions = to_user_pointer(&ext), > + }; > + return __create_ext(i915, &create) == -ENOENT; > +} > + > +static void invalid_clone(int i915) > +{ > + struct drm_i915_gem_context_create_ext_clone ext = { > + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, > + }; > + struct drm_i915_gem_context_create_ext create = { > + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, > + .extensions = to_user_pointer(&ext), > + }; > + > + igt_assert_eq(__create_ext(i915, &create), 0); > + gem_context_destroy(i915, create.ctx_id); > + > + ext.flags = -1; /* Hopefully we won't run out of flags */ > + igt_assert_eq(__create_ext(i915, &create), -EINVAL); > + ext.flags = 0; > + > + ext.base.next_extension = -1; > + igt_assert_eq(__create_ext(i915, &create), -EFAULT); > + ext.base.next_extension = to_user_pointer(&ext); > + igt_assert_eq(__create_ext(i915, &create), -E2BIG); > + ext.base.next_extension = 0; > + > + ext.clone_id = -1; > + igt_assert_eq(__create_ext(i915, &create), -ENOENT); > + ext.clone_id = 0; > +} > + > +static void clone_flags(int i915) > +{ > + struct drm_i915_gem_context_create_ext_setparam set = { > + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, > + { .param = I915_CONTEXT_PARAM_RECOVERABLE }, > + }; > + struct drm_i915_gem_context_create_ext_clone ext = { > + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, > + .flags = I915_CONTEXT_CLONE_FLAGS, > + }; > + struct drm_i915_gem_context_create_ext create = { > + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, > + .extensions = to_user_pointer(&ext), > + }; > + int expected; > + > + set.param.value = 1; /* default is recoverable */ > + igt_require(__gem_context_set_param(i915, &set.param) == 0); > + > + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ > + igt_debug("Cloning %d\n", ext.clone_id); > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = ext.clone_id; > + gem_context_get_param(i915, &set.param); > + expected = set.param.value; > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.param, > + I915_CONTEXT_PARAM_RECOVERABLE); > + igt_assert_eq((int)set.param.value, expected); > + > + gem_context_destroy(i915, create.ctx_id); > + > + expected = set.param.value = 0; > + set.param.ctx_id = ext.clone_id; > + gem_context_set_param(i915, &set.param); > + > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.param, > + I915_CONTEXT_PARAM_RECOVERABLE); > + igt_assert_eq((int)set.param.value, expected); > + > + gem_context_destroy(i915, create.ctx_id); > + > + /* clone but then reset priority to default */ > + set.param.ctx_id = 0; > + set.param.value = 1; > + ext.base.next_extension = to_user_pointer(&set); > + igt_assert_eq(__create_ext(i915, &create), 0); > + ext.base.next_extension = 0; > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + igt_assert_eq_u64(set.param.value, 1); > + > + set.param.ctx_id = ext.clone_id; > + gem_context_get_param(i915, &set.param); > + igt_assert_eq_u64(set.param.value, 0); > + > + gem_context_destroy(i915, create.ctx_id); > + ext.clone_id = gem_context_create(i915); It is quite difficult to follow this sequence in terms of whats is cloned, set, queried, re-set etc. I think it needs a step-by-step commentary. > + } > + > + gem_context_destroy(i915, ext.clone_id); > +} > + > +static void clone_engines(int i915) > +{ > + struct drm_i915_gem_context_create_ext_setparam set = { > + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, > + { .param = I915_CONTEXT_PARAM_ENGINES }, Hm I don't remember seeing the engine map test in the series to this point. Where is it? > + }; > + struct drm_i915_gem_context_create_ext_clone ext = { > + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, > + .flags = I915_CONTEXT_CLONE_ENGINES, > + }; > + struct drm_i915_gem_context_create_ext create = { > + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, > + .extensions = to_user_pointer(&ext), > + }; > + I915_DEFINE_CONTEXT_PARAM_ENGINES(expected, 64); > + I915_DEFINE_CONTEXT_PARAM_ENGINES(engines, 64); > + uint64_t ex_size; > + > + memset(&expected, 0, sizeof(expected)); > + memset(&engines, 0, sizeof(engines)); > + > + igt_require(__gem_context_set_param(i915, &set.param) == 0); > + > + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ > + igt_debug("Cloning %d\n", ext.clone_id); > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = ext.clone_id; > + set.param.size = sizeof(expected); > + set.param.value = to_user_pointer(&expected); > + gem_context_get_param(i915, &set.param); > + ex_size = set.param.size; > + > + set.param.ctx_id = create.ctx_id; > + set.param.size = sizeof(engines); > + set.param.value = to_user_pointer(&engines); > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_ENGINES); > + igt_assert_eq_u64(set.param.size, ex_size); > + igt_assert(!memcmp(&engines, &expected, ex_size)); > + > + gem_context_destroy(i915, create.ctx_id); > + > + expected.class_instance[0].engine_class = > + I915_ENGINE_CLASS_INVALID; > + expected.class_instance[0].engine_instance = > + I915_ENGINE_CLASS_INVALID_NONE; > + ex_size = (sizeof(struct i915_context_param_engines) + > + sizeof(expected.class_instance[0])); > + > + set.param.ctx_id = ext.clone_id; > + set.param.size = ex_size; > + set.param.value = to_user_pointer(&expected); > + gem_context_set_param(i915, &set.param); > + > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = create.ctx_id; > + set.param.size = sizeof(engines); > + set.param.value = to_user_pointer(&engines); > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.size, ex_size); > + igt_assert(!memcmp(&engines, &expected, ex_size)); > + > + gem_context_destroy(i915, create.ctx_id); > + > + /* clone but then reset engines to default */ > + set.param.ctx_id = 0; > + set.param.size = 0; > + set.param.value = 0; > + ext.base.next_extension = to_user_pointer(&set); > + > + igt_assert_eq(__create_ext(i915, &create), 0); > + ext.base.next_extension = 0; > + > + set.param.ctx_id = create.ctx_id; > + set.param.size = sizeof(engines); > + set.param.value = to_user_pointer(&engines); > + gem_context_get_param(i915, &set.param); > + igt_assert_eq_u64(set.param.size, 0); > + > + gem_context_destroy(i915, create.ctx_id); > + > + /* And check we ignore the flag */ > + ext.flags = 0; > + igt_assert_eq(__create_ext(i915, &create), 0); > + ext.flags = I915_CONTEXT_CLONE_ENGINES; > + > + set.param.ctx_id = create.ctx_id; > + set.param.size = sizeof(engines); > + set.param.value = to_user_pointer(&engines); > + gem_context_get_param(i915, &set.param); > + igt_assert_eq_u64(set.param.size, 0); > + > + ext.clone_id = gem_context_create(i915); > + } > + > + gem_context_destroy(i915, ext.clone_id); > +} > + > +static void clone_scheduler(int i915) > +{ > + struct drm_i915_gem_context_create_ext_setparam set = { > + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, > + { .param = I915_CONTEXT_PARAM_PRIORITY }, > + }; > + struct drm_i915_gem_context_create_ext_clone ext = { > + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, > + .flags = I915_CONTEXT_CLONE_SCHEDATTR, > + }; > + struct drm_i915_gem_context_create_ext create = { > + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, > + .extensions = to_user_pointer(&ext), > + }; > + int expected; > + > + igt_require(__gem_context_set_param(i915, &set.param) == 0); > + > + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ > + igt_debug("Cloning %d\n", ext.clone_id); > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = ext.clone_id; > + gem_context_get_param(i915, &set.param); > + expected = set.param.value; > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_PRIORITY); > + igt_assert_eq((int)set.param.value, expected); > + > + gem_context_destroy(i915, create.ctx_id); > + > + expected = set.param.value = 1; > + set.param.ctx_id = ext.clone_id; > + gem_context_set_param(i915, &set.param); > + > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_PRIORITY); > + igt_assert_eq((int)set.param.value, expected); > + > + gem_context_destroy(i915, create.ctx_id); > + > + /* clone but then reset priority to default */ > + set.param.ctx_id = 0; > + set.param.value = 0; > + ext.base.next_extension = to_user_pointer(&set); > + igt_assert_eq(__create_ext(i915, &create), 0); > + ext.base.next_extension = 0; > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + igt_assert_eq_u64(set.param.value, 0); > + > + set.param.ctx_id = ext.clone_id; > + gem_context_get_param(i915, &set.param); > + igt_assert_eq_u64(set.param.value, 1); > + > + gem_context_destroy(i915, create.ctx_id); > + ext.clone_id = gem_context_create(i915); > + } > + > + gem_context_destroy(i915, ext.clone_id); > +} > + > +static void clone_vm(int i915) > +{ > + struct drm_i915_gem_context_create_ext_setparam set = { > + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, > + { .param = I915_CONTEXT_PARAM_VM }, > + }; > + struct drm_i915_gem_context_create_ext_clone ext = { > + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, > + .flags = I915_CONTEXT_CLONE_VM, > + }; > + struct drm_i915_gem_context_create_ext create = { > + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, > + .extensions = to_user_pointer(&ext), > + }; > + uint32_t vm_id[2]; > + int expected; > + > + igt_require(__gem_context_set_param(i915, &set.param) == -ENOENT); > + > + set.param.ctx_id = gem_context_create(i915); > + gem_context_get_param(i915, &set.param); > + vm_id[0] = set.param.value; > + gem_context_destroy(i915, set.param.ctx_id); Do you have in the VM ioctl IGT, or the ctx get/set VM, a subtest that verifies VM survives context destroy, if it was exported before that? It would need one I think. But in this particular one, what is the reason you create one VM indirectly via context create which is immediately destroyed? Exactly to test the above mentioned? > + set.param.ctx_id = 0; > + > + vm_id[1] = gem_vm_create(i915); > + > + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ > + igt_debug("Cloning %d\n", ext.clone_id); > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = ext.clone_id; > + gem_context_get_param(i915, &set.param); > + expected = set.param.value; > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_VM); > + igt_assert_eq((int)set.param.value, expected); > + > + gem_context_destroy(i915, create.ctx_id); > + > + expected = set.param.value = vm_id[0]; > + set.param.ctx_id = ext.clone_id; > + gem_context_set_param(i915, &set.param); > + > + igt_assert_eq(__create_ext(i915, &create), 0); > + > + set.param.ctx_id = create.ctx_id; > + gem_context_get_param(i915, &set.param); > + > + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_VM); > + igt_assert_eq((int)set.param.value, expected); > + > + gem_context_destroy(i915, create.ctx_id); > + ext.clone_id = gem_context_create(i915); > + } vm_id[1] is unused. > + > + gem_context_destroy(i915, ext.clone_id); > + > + for (int i = 0; i < ARRAY_SIZE(vm_id); i++) > + gem_vm_destroy(i915, vm_id[i]); > +} > + > +igt_main > +{ > + int i915 = -1; > + > + igt_fixture { > + i915 = drm_open_driver(DRIVER_INTEL); > + igt_require_gem(i915); > + gem_require_contexts(i915); > + > + igt_require(has_ctx_clone(i915)); > + } > + > + igt_subtest("invalid") > + invalid_clone(i915); > + > + igt_subtest("engines") > + clone_engines(i915); > + > + igt_subtest("flags") > + clone_flags(i915); > + > + igt_subtest("scheduler") > + clone_scheduler(i915); > + > + igt_subtest("vm") > + clone_vm(i915); > + > + igt_fixture { > + close(i915); > + } > +} > diff --git a/tests/meson.build b/tests/meson.build > index 949eefd6f..7c194c3e3 100644 > --- a/tests/meson.build > +++ b/tests/meson.build > @@ -108,6 +108,7 @@ i915_progs = [ > 'gem_cs_prefetch', > 'gem_cs_tlb', > 'gem_ctx_bad_destroy', > + 'gem_ctx_clone', > 'gem_ctx_create', > 'gem_ctx_exec', > 'gem_ctx_isolation', > Regards, Tvrtko
Quoting Tvrtko Ursulin (2019-03-26 15:44:35) > > On 22/03/2019 09:21, Chris Wilson wrote: > > +static void clone_engines(int i915) > > +{ > > + struct drm_i915_gem_context_create_ext_setparam set = { > > + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, > > + { .param = I915_CONTEXT_PARAM_ENGINES }, > > Hm I don't remember seeing the engine map test in the series to this > point. Where is it? "Are we nearly there yet?" Almost. It's hard to tell what order to put these in as I use context cloning for the gem_ctx_engine tests as well. You could say each subtest in a separate patch so they all flow in some well defined order, I'm just trying to make sure things work :) -Chris
Quoting Tvrtko Ursulin (2019-03-26 15:44:35) > > On 22/03/2019 09:21, Chris Wilson wrote: > > +static void clone_vm(int i915) > > +{ > > + struct drm_i915_gem_context_create_ext_setparam set = { > > + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, > > + { .param = I915_CONTEXT_PARAM_VM }, > > + }; > > + struct drm_i915_gem_context_create_ext_clone ext = { > > + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, > > + .flags = I915_CONTEXT_CLONE_VM, > > + }; > > + struct drm_i915_gem_context_create_ext create = { > > + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, > > + .extensions = to_user_pointer(&ext), > > + }; > > + uint32_t vm_id[2]; > > + int expected; > > + > > + igt_require(__gem_context_set_param(i915, &set.param) == -ENOENT); > > + > > + set.param.ctx_id = gem_context_create(i915); > > + gem_context_get_param(i915, &set.param); > > + vm_id[0] = set.param.value; > > + gem_context_destroy(i915, set.param.ctx_id); > > Do you have in the VM ioctl IGT, or the ctx get/set VM, a subtest that > verifies VM survives context destroy, if it was exported before that? It > would need one I think. > > But in this particular one, what is the reason you create one VM > indirectly via context create which is immediately destroyed? Exactly to > test the above mentioned? It was precisely that to check that we could keep a VM from an earlier context. But honestly it was because I had forgotten about gem_vm_create() at that point and had to go and write another bunch of tests. > > + set.param.ctx_id = 0; > > + > > + vm_id[1] = gem_vm_create(i915); And then I was supposed to check we got similar results using explict allocation. > > + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ > > + igt_debug("Cloning %d\n", ext.clone_id); > > + igt_assert_eq(__create_ext(i915, &create), 0); > > + > > + set.param.ctx_id = ext.clone_id; > > + gem_context_get_param(i915, &set.param); > > + expected = set.param.value; > > + > > + set.param.ctx_id = create.ctx_id; > > + gem_context_get_param(i915, &set.param); > > + > > + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_VM); > > + igt_assert_eq((int)set.param.value, expected); > > + > > + gem_context_destroy(i915, create.ctx_id); > > + > > + expected = set.param.value = vm_id[0]; > > + set.param.ctx_id = ext.clone_id; > > + gem_context_set_param(i915, &set.param); > > + > > + igt_assert_eq(__create_ext(i915, &create), 0); > > + > > + set.param.ctx_id = create.ctx_id; > > + gem_context_get_param(i915, &set.param); > > + > > + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_VM); > > + igt_assert_eq((int)set.param.value, expected); > > + > > + gem_context_destroy(i915, create.ctx_id); > > + ext.clone_id = gem_context_create(i915); > > + } > > vm_id[1] is unused. Yeah... -Chris
diff --git a/tests/Makefile.sources b/tests/Makefile.sources index 809b25612..12f4bbd75 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -21,6 +21,7 @@ TESTS_progs = \ drm_import_export \ drm_mm \ drm_read \ + i915/gem_ctx_clone \ i915/gem_vm_create \ kms_3d \ kms_addfb_basic \ diff --git a/tests/i915/gem_ctx_clone.c b/tests/i915/gem_ctx_clone.c new file mode 100644 index 000000000..7d83c6350 --- /dev/null +++ b/tests/i915/gem_ctx_clone.c @@ -0,0 +1,421 @@ +/* + * Copyright © 2019 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include "igt.h" +#include "i915/gem_vm.h" +#include "i915_drm.h" + +static int __create_ext(int i915, struct drm_i915_gem_context_create_ext *arg) +{ + int err; + + err = 0; + if (igt_ioctl(i915, DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT, arg)) + err = -errno; + + errno = 0; + return err; +} + +static bool has_ctx_clone(int i915) +{ + struct drm_i915_gem_context_create_ext_clone ext = { + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, + .clone_id = -1, + }; + struct drm_i915_gem_context_create_ext create = { + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, + .extensions = to_user_pointer(&ext), + }; + return __create_ext(i915, &create) == -ENOENT; +} + +static void invalid_clone(int i915) +{ + struct drm_i915_gem_context_create_ext_clone ext = { + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, + }; + struct drm_i915_gem_context_create_ext create = { + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, + .extensions = to_user_pointer(&ext), + }; + + igt_assert_eq(__create_ext(i915, &create), 0); + gem_context_destroy(i915, create.ctx_id); + + ext.flags = -1; /* Hopefully we won't run out of flags */ + igt_assert_eq(__create_ext(i915, &create), -EINVAL); + ext.flags = 0; + + ext.base.next_extension = -1; + igt_assert_eq(__create_ext(i915, &create), -EFAULT); + ext.base.next_extension = to_user_pointer(&ext); + igt_assert_eq(__create_ext(i915, &create), -E2BIG); + ext.base.next_extension = 0; + + ext.clone_id = -1; + igt_assert_eq(__create_ext(i915, &create), -ENOENT); + ext.clone_id = 0; +} + +static void clone_flags(int i915) +{ + struct drm_i915_gem_context_create_ext_setparam set = { + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, + { .param = I915_CONTEXT_PARAM_RECOVERABLE }, + }; + struct drm_i915_gem_context_create_ext_clone ext = { + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, + .flags = I915_CONTEXT_CLONE_FLAGS, + }; + struct drm_i915_gem_context_create_ext create = { + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, + .extensions = to_user_pointer(&ext), + }; + int expected; + + set.param.value = 1; /* default is recoverable */ + igt_require(__gem_context_set_param(i915, &set.param) == 0); + + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ + igt_debug("Cloning %d\n", ext.clone_id); + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = ext.clone_id; + gem_context_get_param(i915, &set.param); + expected = set.param.value; + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.param, + I915_CONTEXT_PARAM_RECOVERABLE); + igt_assert_eq((int)set.param.value, expected); + + gem_context_destroy(i915, create.ctx_id); + + expected = set.param.value = 0; + set.param.ctx_id = ext.clone_id; + gem_context_set_param(i915, &set.param); + + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.param, + I915_CONTEXT_PARAM_RECOVERABLE); + igt_assert_eq((int)set.param.value, expected); + + gem_context_destroy(i915, create.ctx_id); + + /* clone but then reset priority to default */ + set.param.ctx_id = 0; + set.param.value = 1; + ext.base.next_extension = to_user_pointer(&set); + igt_assert_eq(__create_ext(i915, &create), 0); + ext.base.next_extension = 0; + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + igt_assert_eq_u64(set.param.value, 1); + + set.param.ctx_id = ext.clone_id; + gem_context_get_param(i915, &set.param); + igt_assert_eq_u64(set.param.value, 0); + + gem_context_destroy(i915, create.ctx_id); + ext.clone_id = gem_context_create(i915); + } + + gem_context_destroy(i915, ext.clone_id); +} + +static void clone_engines(int i915) +{ + struct drm_i915_gem_context_create_ext_setparam set = { + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, + { .param = I915_CONTEXT_PARAM_ENGINES }, + }; + struct drm_i915_gem_context_create_ext_clone ext = { + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, + .flags = I915_CONTEXT_CLONE_ENGINES, + }; + struct drm_i915_gem_context_create_ext create = { + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, + .extensions = to_user_pointer(&ext), + }; + I915_DEFINE_CONTEXT_PARAM_ENGINES(expected, 64); + I915_DEFINE_CONTEXT_PARAM_ENGINES(engines, 64); + uint64_t ex_size; + + memset(&expected, 0, sizeof(expected)); + memset(&engines, 0, sizeof(engines)); + + igt_require(__gem_context_set_param(i915, &set.param) == 0); + + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ + igt_debug("Cloning %d\n", ext.clone_id); + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = ext.clone_id; + set.param.size = sizeof(expected); + set.param.value = to_user_pointer(&expected); + gem_context_get_param(i915, &set.param); + ex_size = set.param.size; + + set.param.ctx_id = create.ctx_id; + set.param.size = sizeof(engines); + set.param.value = to_user_pointer(&engines); + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_ENGINES); + igt_assert_eq_u64(set.param.size, ex_size); + igt_assert(!memcmp(&engines, &expected, ex_size)); + + gem_context_destroy(i915, create.ctx_id); + + expected.class_instance[0].engine_class = + I915_ENGINE_CLASS_INVALID; + expected.class_instance[0].engine_instance = + I915_ENGINE_CLASS_INVALID_NONE; + ex_size = (sizeof(struct i915_context_param_engines) + + sizeof(expected.class_instance[0])); + + set.param.ctx_id = ext.clone_id; + set.param.size = ex_size; + set.param.value = to_user_pointer(&expected); + gem_context_set_param(i915, &set.param); + + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = create.ctx_id; + set.param.size = sizeof(engines); + set.param.value = to_user_pointer(&engines); + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.size, ex_size); + igt_assert(!memcmp(&engines, &expected, ex_size)); + + gem_context_destroy(i915, create.ctx_id); + + /* clone but then reset engines to default */ + set.param.ctx_id = 0; + set.param.size = 0; + set.param.value = 0; + ext.base.next_extension = to_user_pointer(&set); + + igt_assert_eq(__create_ext(i915, &create), 0); + ext.base.next_extension = 0; + + set.param.ctx_id = create.ctx_id; + set.param.size = sizeof(engines); + set.param.value = to_user_pointer(&engines); + gem_context_get_param(i915, &set.param); + igt_assert_eq_u64(set.param.size, 0); + + gem_context_destroy(i915, create.ctx_id); + + /* And check we ignore the flag */ + ext.flags = 0; + igt_assert_eq(__create_ext(i915, &create), 0); + ext.flags = I915_CONTEXT_CLONE_ENGINES; + + set.param.ctx_id = create.ctx_id; + set.param.size = sizeof(engines); + set.param.value = to_user_pointer(&engines); + gem_context_get_param(i915, &set.param); + igt_assert_eq_u64(set.param.size, 0); + + ext.clone_id = gem_context_create(i915); + } + + gem_context_destroy(i915, ext.clone_id); +} + +static void clone_scheduler(int i915) +{ + struct drm_i915_gem_context_create_ext_setparam set = { + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, + { .param = I915_CONTEXT_PARAM_PRIORITY }, + }; + struct drm_i915_gem_context_create_ext_clone ext = { + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, + .flags = I915_CONTEXT_CLONE_SCHEDATTR, + }; + struct drm_i915_gem_context_create_ext create = { + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, + .extensions = to_user_pointer(&ext), + }; + int expected; + + igt_require(__gem_context_set_param(i915, &set.param) == 0); + + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ + igt_debug("Cloning %d\n", ext.clone_id); + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = ext.clone_id; + gem_context_get_param(i915, &set.param); + expected = set.param.value; + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_PRIORITY); + igt_assert_eq((int)set.param.value, expected); + + gem_context_destroy(i915, create.ctx_id); + + expected = set.param.value = 1; + set.param.ctx_id = ext.clone_id; + gem_context_set_param(i915, &set.param); + + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_PRIORITY); + igt_assert_eq((int)set.param.value, expected); + + gem_context_destroy(i915, create.ctx_id); + + /* clone but then reset priority to default */ + set.param.ctx_id = 0; + set.param.value = 0; + ext.base.next_extension = to_user_pointer(&set); + igt_assert_eq(__create_ext(i915, &create), 0); + ext.base.next_extension = 0; + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + igt_assert_eq_u64(set.param.value, 0); + + set.param.ctx_id = ext.clone_id; + gem_context_get_param(i915, &set.param); + igt_assert_eq_u64(set.param.value, 1); + + gem_context_destroy(i915, create.ctx_id); + ext.clone_id = gem_context_create(i915); + } + + gem_context_destroy(i915, ext.clone_id); +} + +static void clone_vm(int i915) +{ + struct drm_i915_gem_context_create_ext_setparam set = { + { .name = I915_CONTEXT_CREATE_EXT_SETPARAM }, + { .param = I915_CONTEXT_PARAM_VM }, + }; + struct drm_i915_gem_context_create_ext_clone ext = { + { .name = I915_CONTEXT_CREATE_EXT_CLONE }, + .flags = I915_CONTEXT_CLONE_VM, + }; + struct drm_i915_gem_context_create_ext create = { + .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, + .extensions = to_user_pointer(&ext), + }; + uint32_t vm_id[2]; + int expected; + + igt_require(__gem_context_set_param(i915, &set.param) == -ENOENT); + + set.param.ctx_id = gem_context_create(i915); + gem_context_get_param(i915, &set.param); + vm_id[0] = set.param.value; + gem_context_destroy(i915, set.param.ctx_id); + set.param.ctx_id = 0; + + vm_id[1] = gem_vm_create(i915); + + for (int pass = 0; pass < 2; pass++) { /* cloning default, then child */ + igt_debug("Cloning %d\n", ext.clone_id); + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = ext.clone_id; + gem_context_get_param(i915, &set.param); + expected = set.param.value; + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_VM); + igt_assert_eq((int)set.param.value, expected); + + gem_context_destroy(i915, create.ctx_id); + + expected = set.param.value = vm_id[0]; + set.param.ctx_id = ext.clone_id; + gem_context_set_param(i915, &set.param); + + igt_assert_eq(__create_ext(i915, &create), 0); + + set.param.ctx_id = create.ctx_id; + gem_context_get_param(i915, &set.param); + + igt_assert_eq_u64(set.param.param, I915_CONTEXT_PARAM_VM); + igt_assert_eq((int)set.param.value, expected); + + gem_context_destroy(i915, create.ctx_id); + ext.clone_id = gem_context_create(i915); + } + + gem_context_destroy(i915, ext.clone_id); + + for (int i = 0; i < ARRAY_SIZE(vm_id); i++) + gem_vm_destroy(i915, vm_id[i]); +} + +igt_main +{ + int i915 = -1; + + igt_fixture { + i915 = drm_open_driver(DRIVER_INTEL); + igt_require_gem(i915); + gem_require_contexts(i915); + + igt_require(has_ctx_clone(i915)); + } + + igt_subtest("invalid") + invalid_clone(i915); + + igt_subtest("engines") + clone_engines(i915); + + igt_subtest("flags") + clone_flags(i915); + + igt_subtest("scheduler") + clone_scheduler(i915); + + igt_subtest("vm") + clone_vm(i915); + + igt_fixture { + close(i915); + } +} diff --git a/tests/meson.build b/tests/meson.build index 949eefd6f..7c194c3e3 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -108,6 +108,7 @@ i915_progs = [ 'gem_cs_prefetch', 'gem_cs_tlb', 'gem_ctx_bad_destroy', + 'gem_ctx_clone', 'gem_ctx_create', 'gem_ctx_exec', 'gem_ctx_isolation',
Exercise cloning contexts, an extension of merely creating one. Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> --- tests/Makefile.sources | 1 + tests/i915/gem_ctx_clone.c | 421 +++++++++++++++++++++++++++++++++++++ tests/meson.build | 1 + 3 files changed, 423 insertions(+) create mode 100644 tests/i915/gem_ctx_clone.c