* [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test @ 2015-04-07 12:23 Joonas Lahtinen 2015-04-07 14:08 ` Chris Wilson 2015-04-13 11:32 ` [PATCH i-g-t] " Tvrtko Ursulin 0 siblings, 2 replies; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-07 12:23 UTC (permalink / raw) To: intel-gfx Add a straightforward test that allocates a BO that is bigger than (by 1 page currently) the mappable aperture, tests mmap access to it by CPU directly and through GTT in sequence. Currently it is expected for the GTT access to gracefully fail as all objects are attempted to get pinned to GTT completely for mmap access. Once the partial view support is merged to kernel, the test should pass for all parts. Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> --- tests/gem_mmap_gtt.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c index 55c66a2..bf3627c 100644 --- a/tests/gem_mmap_gtt.c +++ b/tests/gem_mmap_gtt.c @@ -41,6 +41,10 @@ #include "drmtest.h" #include "igt_debugfs.h" +#ifndef PAGE_SIZE +#define PAGE_SIZE 4096 +#endif + static int OBJECT_SIZE = 16*1024*1024; static void set_domain(int fd, uint32_t handle) @@ -258,6 +262,68 @@ test_write_gtt(int fd) } static void +test_huge_bo(int fd) +{ + uint32_t bo; + char *ptr_cpu; + char *ptr_gtt; + char *cpu_pattern; + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / + PAGE_SIZE; + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; + uint64_t last_offset = huge_object_size - PAGE_SIZE; + + cpu_pattern = malloc(PAGE_SIZE); + igt_assert(cpu_pattern); + memset(cpu_pattern, 0xaa, PAGE_SIZE); + + bo = gem_create(fd, huge_object_size); + + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, + PROT_READ | PROT_WRITE); + if (!ptr_cpu) { + igt_warn("Not enough free memory for huge BO test!\n"); + goto out; + } + + /* Test read/write to first/last page with CPU. */ + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); + + munmap(ptr_cpu, huge_object_size); + ptr_cpu = NULL; + + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, + PROT_READ | PROT_WRITE); + if (!ptr_gtt) { + igt_debug("Huge BO GTT mapping not supported!\n"); + goto out; + } + + /* Test read/write to first/last page through GTT. */ + set_domain(fd, bo); + + igt_assert(memcmp(ptr_gtt, cpu_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + memset(ptr_gtt, 0x55, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + memset(ptr_gtt + last_offset, 0x55, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt, ptr_gtt + last_offset, PAGE_SIZE) == 0); + + munmap(ptr_gtt, huge_object_size); +out: + gem_close(fd, bo); + free(cpu_pattern); +} + +static void test_read(int fd) { void *dst; @@ -395,6 +461,8 @@ igt_main run_without_prefault(fd, test_write_gtt); igt_subtest("write-cpu-read-gtt") test_write_cpu_read_gtt(fd); + igt_subtest("huge-bo") + test_huge_bo(fd); igt_fixture close(fd); -- 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply related [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test 2015-04-07 12:23 [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen @ 2015-04-07 14:08 ` Chris Wilson 2015-04-08 10:45 ` Joonas Lahtinen ` (2 more replies) 2015-04-13 11:32 ` [PATCH i-g-t] " Tvrtko Ursulin 1 sibling, 3 replies; 16+ messages in thread From: Chris Wilson @ 2015-04-07 14:08 UTC (permalink / raw) To: Joonas Lahtinen; +Cc: intel-gfx On Tue, Apr 07, 2015 at 03:23:08PM +0300, Joonas Lahtinen wrote: > static void > +test_huge_bo(int fd) > +{ > + uint32_t bo; > + char *ptr_cpu; > + char *ptr_gtt; > + char *cpu_pattern; > + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / > + PAGE_SIZE; > + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; > + uint64_t last_offset = huge_object_size - PAGE_SIZE; > + > + cpu_pattern = malloc(PAGE_SIZE); > + igt_assert(cpu_pattern); > + memset(cpu_pattern, 0xaa, PAGE_SIZE); > + > + bo = gem_create(fd, huge_object_size); > + > + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, > + PROT_READ | PROT_WRITE); > + if (!ptr_cpu) { > + igt_warn("Not enough free memory for huge BO test!\n"); > + goto out; > + } Should be a set-domain(CPU, CPU) here. > + /* Test read/write to first/last page with CPU. */ > + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); > + > + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); > + > + munmap(ptr_cpu, huge_object_size); > + ptr_cpu = NULL; > + > + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, > + PROT_READ | PROT_WRITE); > + if (!ptr_gtt) { > + igt_debug("Huge BO GTT mapping not supported!\n"); > + goto out; > + } > + > + /* Test read/write to first/last page through GTT. */ > + set_domain(fd, bo); > + > + igt_assert(memcmp(ptr_gtt, cpu_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + memset(ptr_gtt, 0x55, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + memset(ptr_gtt + last_offset, 0x55, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt, ptr_gtt + last_offset, PAGE_SIZE) == 0); > + > + munmap(ptr_gtt, huge_object_size); And repeat the CPU sanity check (for 0x55). Perhaps using pread this time. And tiling checks. -Chris -- Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test 2015-04-07 14:08 ` Chris Wilson @ 2015-04-08 10:45 ` Joonas Lahtinen 2015-04-08 10:50 ` [PATCH i-g-t v2 1/2] tests/gem_mmap_gtt: Clarify BO domain setting functions Joonas Lahtinen 2015-04-08 10:51 ` [PATCH i-g-t v2 2/2] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 2 siblings, 0 replies; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-08 10:45 UTC (permalink / raw) To: Chris Wilson; +Cc: intel-gfx Hi, On ti, 2015-04-07 at 15:08 +0100, Chris Wilson wrote: > On Tue, Apr 07, 2015 at 03:23:08PM +0300, Joonas Lahtinen wrote: [snip] > > + > > + bo = gem_create(fd, huge_object_size); > > + > > + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, > > + PROT_READ | PROT_WRITE); > > + if (!ptr_cpu) { > > + igt_warn("Not enough free memory for huge BO test!\n"); > > + goto out; > > + } > > Should be a set-domain(CPU, CPU) here. Corrected, that went unnoticed when I moved the test to be last test. > > > + /* Test read/write to first/last page with CPU. */ > > + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); > > + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); > > + > > + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); > > + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); > > + > > + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); > > + > > + munmap(ptr_cpu, huge_object_size); > > + ptr_cpu = NULL; > > + > > + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, > > + PROT_READ | PROT_WRITE); > > + if (!ptr_gtt) { > > + igt_debug("Huge BO GTT mapping not supported!\n"); > > + goto out; > > + } > > + > > + /* Test read/write to first/last page through GTT. */ > > + set_domain(fd, bo); > > + > > + igt_assert(memcmp(ptr_gtt, cpu_pattern, PAGE_SIZE) == 0); > > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > > + > > + memset(ptr_gtt, 0x55, PAGE_SIZE); > > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > > + > > + memset(ptr_gtt + last_offset, 0x55, PAGE_SIZE); > > + igt_assert(memcmp(ptr_gtt, ptr_gtt + last_offset, PAGE_SIZE) == 0); > > + > > + munmap(ptr_gtt, huge_object_size); > > And repeat the CPU sanity check (for 0x55). Perhaps using pread this time. > I stuck to mmap in this test. Initial partial views revision will not have fencing as agreed with Daniel, just checks to bail out if somebody attempts to to partially map a tiled buffer because it's going to require reworking all the fence calculation functions to calculate the stride based on view size and not buffer size. Will send a new patch (two actually) shortly. Regards, Joonas > And tiling checks. > -Chris > _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH i-g-t v2 1/2] tests/gem_mmap_gtt: Clarify BO domain setting functions 2015-04-07 14:08 ` Chris Wilson 2015-04-08 10:45 ` Joonas Lahtinen @ 2015-04-08 10:50 ` Joonas Lahtinen 2015-04-08 10:51 ` [PATCH i-g-t v2 2/2] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 2 siblings, 0 replies; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-08 10:50 UTC (permalink / raw) To: intel-gfx Add suffix and complementary function for CPU domain. Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> --- tests/gem_mmap_gtt.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c index 55c66a2..d2803d7 100644 --- a/tests/gem_mmap_gtt.c +++ b/tests/gem_mmap_gtt.c @@ -43,11 +43,16 @@ static int OBJECT_SIZE = 16*1024*1024; -static void set_domain(int fd, uint32_t handle) +static void set_domain_gtt(int fd, uint32_t handle) { gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT); } +static void set_domain_cpu(int fd, uint32_t handle) +{ + gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); +} + static void * mmap_bo(int fd, uint32_t handle) { @@ -245,7 +250,7 @@ test_write_gtt(int fd) /* prefault object into gtt */ dst_gtt = mmap_bo(fd, dst); - set_domain(fd, dst); + set_domain_gtt(fd, dst); memset(dst_gtt, 0, OBJECT_SIZE); munmap(dst_gtt, OBJECT_SIZE); -- 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply related [flat|nested] 16+ messages in thread
* [PATCH i-g-t v2 2/2] tests/gem_mmap_gtt: add huge BO test 2015-04-07 14:08 ` Chris Wilson 2015-04-08 10:45 ` Joonas Lahtinen 2015-04-08 10:50 ` [PATCH i-g-t v2 1/2] tests/gem_mmap_gtt: Clarify BO domain setting functions Joonas Lahtinen @ 2015-04-08 10:51 ` Joonas Lahtinen 2015-04-08 11:00 ` Chris Wilson 2 siblings, 1 reply; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-08 10:51 UTC (permalink / raw) To: intel-gfx Add a straightforward test that allocates a BO that is bigger than (by 1 page currently) the mappable aperture, tests mmap access to it by CPU directly and through GTT in sequence. Currently it is expected for the GTT access to gracefully fail as all objects are attempted to get pinned to GTT completely for mmap access. Once the partial view support is merged to kernel, the test should pass for all parts. v2: - Corrected BO domain handling (Chris Wilson) - Check again after GTT access for added paranoia (Chris Wilson) Cc: Chris Wilson <chris@chris-wilson.co.uk> Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> --- tests/gem_mmap_gtt.c | 104 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c index d2803d7..c613a41 100644 --- a/tests/gem_mmap_gtt.c +++ b/tests/gem_mmap_gtt.c @@ -41,6 +41,10 @@ #include "drmtest.h" #include "igt_debugfs.h" +#ifndef PAGE_SIZE +#define PAGE_SIZE 4096 +#endif + static int OBJECT_SIZE = 16*1024*1024; static void set_domain_gtt(int fd, uint32_t handle) @@ -263,6 +267,104 @@ test_write_gtt(int fd) } static void +test_huge_bo(int fd) +{ + uint32_t bo; + char *ptr_cpu; + char *ptr_gtt; + char *cpu_pattern; + char *gtt_pattern; + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / + PAGE_SIZE; + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; + uint64_t last_offset = huge_object_size - PAGE_SIZE; + + cpu_pattern = malloc(PAGE_SIZE); + gtt_pattern = malloc(PAGE_SIZE); + igt_assert(cpu_pattern && gtt_pattern); + memset(cpu_pattern, 0xaa, PAGE_SIZE); + memset(gtt_pattern, ~0xaa, PAGE_SIZE); + + bo = gem_create(fd, huge_object_size); + + /* Test read/write to first/last page with CPU. */ + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, + PROT_READ | PROT_WRITE); + if (!ptr_cpu) { + igt_warn("Not enough free memory to begin huge BO test!\n"); + goto out; + } + + set_domain_cpu(fd, bo); + + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); + + munmap(ptr_cpu, huge_object_size); + ptr_cpu = NULL; + + /* Test read/write to first/last page through GTT after CPU writes. + * Require that previous CPU written values still exist. + */ + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, + PROT_READ | PROT_WRITE); + if (!ptr_gtt) { + igt_debug("Huge BO GTT mapping not supported!\n"); + goto out; + } + + set_domain_gtt(fd, bo); + + igt_assert(memcmp(ptr_gtt , cpu_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_gtt, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE) == 0); + + munmap(ptr_gtt, huge_object_size); + ptr_gtt = NULL; + + /* Test read/write to first/last page through CPU after GTT writes. + * Require that previous GTT written values still exist. + */ + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, + PROT_READ | PROT_WRITE); + if (!ptr_cpu) { + igt_warn("Not enough free memory to complete huge BO test!\n"); + goto out; + } + + set_domain_cpu(fd, bo); + + igt_assert(memcmp(ptr_cpu , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_cpu + last_offset, gtt_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu , cpu_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_cpu + last_offset, gtt_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu , cpu_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + munmap(ptr_cpu, huge_object_size); + ptr_cpu = NULL; +out: + gem_close(fd, bo); + free(cpu_pattern); +} + +static void test_read(int fd) { void *dst; @@ -400,6 +502,8 @@ igt_main run_without_prefault(fd, test_write_gtt); igt_subtest("write-cpu-read-gtt") test_write_cpu_read_gtt(fd); + igt_subtest("huge-bo") + test_huge_bo(fd); igt_fixture close(fd); -- 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply related [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t v2 2/2] tests/gem_mmap_gtt: add huge BO test 2015-04-08 10:51 ` [PATCH i-g-t v2 2/2] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen @ 2015-04-08 11:00 ` Chris Wilson 2015-04-08 12:55 ` [PATCH i-g-t v3 1/2] tests/gem_mmap_gtt: clarify BO domain setting functions Joonas Lahtinen 2015-04-08 12:57 ` [PATCH i-g-t v3 2/2] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 0 siblings, 2 replies; 16+ messages in thread From: Chris Wilson @ 2015-04-08 11:00 UTC (permalink / raw) To: Joonas Lahtinen; +Cc: intel-gfx On Wed, Apr 08, 2015 at 01:51:52PM +0300, Joonas Lahtinen wrote: > + /* Test read/write to first/last page through CPU after GTT writes. > + * Require that previous GTT written values still exist. > + */ > + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, > + PROT_READ | PROT_WRITE); > + if (!ptr_cpu) { > + igt_warn("Not enough free memory to complete huge BO test!\n"); > + goto out; > + } > + > + set_domain_cpu(fd, bo); > + > + igt_assert(memcmp(ptr_cpu , gtt_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_cpu + last_offset, gtt_pattern, PAGE_SIZE) == 0); > + > + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu , cpu_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_cpu + last_offset, gtt_pattern, PAGE_SIZE) == 0); > + > + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu , cpu_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); On second thought I think this is better using pread as on non-llc platforms this will a second gigantic clflush. Otherwise lgtm. -Chris -- Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH i-g-t v3 1/2] tests/gem_mmap_gtt: clarify BO domain setting functions 2015-04-08 11:00 ` Chris Wilson @ 2015-04-08 12:55 ` Joonas Lahtinen 2015-04-13 6:03 ` Joonas Lahtinen 2015-04-08 12:57 ` [PATCH i-g-t v3 2/2] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 1 sibling, 1 reply; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-08 12:55 UTC (permalink / raw) To: intel-gfx Add suffix and complementary function for CPU domain. v2: - Change function signatures to be consistent with the rest Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> --- tests/gem_mmap_gtt.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c index 55c66a2..115e398 100644 --- a/tests/gem_mmap_gtt.c +++ b/tests/gem_mmap_gtt.c @@ -43,11 +43,18 @@ static int OBJECT_SIZE = 16*1024*1024; -static void set_domain(int fd, uint32_t handle) +static void +set_domain_gtt(int fd, uint32_t handle) { gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT); } +static void +set_domain_cpu(int fd, uint32_t handle) +{ + gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); +} + static void * mmap_bo(int fd, uint32_t handle) { @@ -245,7 +252,7 @@ test_write_gtt(int fd) /* prefault object into gtt */ dst_gtt = mmap_bo(fd, dst); - set_domain(fd, dst); + set_domain_gtt(fd, dst); memset(dst_gtt, 0, OBJECT_SIZE); munmap(dst_gtt, OBJECT_SIZE); -- 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply related [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t v3 1/2] tests/gem_mmap_gtt: clarify BO domain setting functions 2015-04-08 12:55 ` [PATCH i-g-t v3 1/2] tests/gem_mmap_gtt: clarify BO domain setting functions Joonas Lahtinen @ 2015-04-13 6:03 ` Joonas Lahtinen 0 siblings, 0 replies; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-13 6:03 UTC (permalink / raw) To: intel-gfx These two patches still have something to work on, or could they be committed? On ke, 2015-04-08 at 15:55 +0300, Joonas Lahtinen wrote: > Add suffix and complementary function for CPU domain. > > v2: > - Change function signatures to be consistent with the rest > > Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> > --- > tests/gem_mmap_gtt.c | 11 +++++++++-- > 1 file changed, 9 insertions(+), 2 deletions(-) > > diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c > index 55c66a2..115e398 100644 > --- a/tests/gem_mmap_gtt.c > +++ b/tests/gem_mmap_gtt.c > @@ -43,11 +43,18 @@ > > static int OBJECT_SIZE = 16*1024*1024; > > -static void set_domain(int fd, uint32_t handle) > +static void > +set_domain_gtt(int fd, uint32_t handle) > { > gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT); > } > > +static void > +set_domain_cpu(int fd, uint32_t handle) > +{ > + gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); > +} > + > static void * > mmap_bo(int fd, uint32_t handle) > { > @@ -245,7 +252,7 @@ test_write_gtt(int fd) > > /* prefault object into gtt */ > dst_gtt = mmap_bo(fd, dst); > - set_domain(fd, dst); > + set_domain_gtt(fd, dst); > memset(dst_gtt, 0, OBJECT_SIZE); > munmap(dst_gtt, OBJECT_SIZE); > _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH i-g-t v3 2/2] tests/gem_mmap_gtt: add huge BO test 2015-04-08 11:00 ` Chris Wilson 2015-04-08 12:55 ` [PATCH i-g-t v3 1/2] tests/gem_mmap_gtt: clarify BO domain setting functions Joonas Lahtinen @ 2015-04-08 12:57 ` Joonas Lahtinen 1 sibling, 0 replies; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-08 12:57 UTC (permalink / raw) To: intel-gfx Add a straightforward test that allocates a BO that is bigger than (by 1 page currently) the mappable aperture, tests mmap access to it by CPU directly and through GTT in sequence. Currently it is expected for the GTT access to gracefully fail as all objects are attempted to get pinned to GTT completely for mmap access. Once the partial view support is merged to kernel, the test should pass for all parts. v2: - Corrected BO domain handling (Chris Wilson) - Check again after GTT access for added paranoia (Chris Wilson) v3: - Avoid flush by using pread (Chris Wilson) - Free gtt_pattern buffer too. Cc: Chris Wilson <chris@chris-wilson.co.uk> Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> --- tests/gem_mmap_gtt.c | 104 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c index 115e398..32d24b4 100644 --- a/tests/gem_mmap_gtt.c +++ b/tests/gem_mmap_gtt.c @@ -41,6 +41,10 @@ #include "drmtest.h" #include "igt_debugfs.h" +#ifndef PAGE_SIZE +#define PAGE_SIZE 4096 +#endif + static int OBJECT_SIZE = 16*1024*1024; static void @@ -55,6 +59,20 @@ set_domain_cpu(int fd, uint32_t handle) gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); } +static void +pread_bo(int fd, int handle, void *buf, int offset, int size) +{ + struct drm_i915_gem_pread gem_pread; + + memset(&gem_pread, 0, sizeof(gem_pread)); + gem_pread.handle = handle; + gem_pread.data_ptr = (uintptr_t)buf; + gem_pread.size = size; + gem_pread.offset = offset; + + igt_assert(ioctl(fd, DRM_IOCTL_I915_GEM_PREAD, &gem_pread) == 0); +} + static void * mmap_bo(int fd, uint32_t handle) { @@ -265,6 +283,90 @@ test_write_gtt(int fd) } static void +test_huge_bo(int fd) +{ + uint32_t bo; + char *ptr_cpu; + char *ptr_gtt; + char *cpu_pattern; + char *gtt_pattern; + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / + PAGE_SIZE; + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; + uint64_t last_offset = huge_object_size - PAGE_SIZE; + + cpu_pattern = malloc(PAGE_SIZE); + gtt_pattern = malloc(PAGE_SIZE); + igt_assert(cpu_pattern && gtt_pattern); + memset(cpu_pattern, 0xaa, PAGE_SIZE); + memset(gtt_pattern, ~0xaa, PAGE_SIZE); + + bo = gem_create(fd, huge_object_size); + + /* Test read/write to first/last page with CPU. */ + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, + PROT_READ | PROT_WRITE); + if (!ptr_cpu) { + igt_warn("Not enough free memory to begin huge BO test!\n"); + goto out; + } + + set_domain_cpu(fd, bo); + + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); + + munmap(ptr_cpu, huge_object_size); + ptr_cpu = NULL; + + /* Test read/write to first/last page through GTT after CPU writes. + * Require that previous CPU written values still exist. + */ + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, + PROT_READ | PROT_WRITE); + if (!ptr_gtt) { + igt_debug("Huge BO GTT mapping not supported!\n"); + goto out; + } + + set_domain_gtt(fd, bo); + + igt_assert(memcmp(ptr_gtt , cpu_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_gtt, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + memcpy(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE) == 0); + + munmap(ptr_gtt, huge_object_size); + ptr_gtt = NULL; + + /* Verify the page contents after GTT writes. + * Avoid mapping the object back to CPU domain to avoid huge flush. + */ + pread_bo(fd, bo, cpu_pattern, 0, PAGE_SIZE); + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); + + memset(cpu_pattern, 0x00, PAGE_SIZE); + + pread_bo(fd, bo, cpu_pattern, last_offset, PAGE_SIZE); + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); +out: + gem_close(fd, bo); + free(cpu_pattern); + free(gtt_pattern); +} + +static void test_read(int fd) { void *dst; @@ -402,6 +504,8 @@ igt_main run_without_prefault(fd, test_write_gtt); igt_subtest("write-cpu-read-gtt") test_write_cpu_read_gtt(fd); + igt_subtest("huge-bo") + test_huge_bo(fd); igt_fixture close(fd); -- 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply related [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test 2015-04-07 12:23 [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 2015-04-07 14:08 ` Chris Wilson @ 2015-04-13 11:32 ` Tvrtko Ursulin 2015-04-13 14:22 ` Joonas Lahtinen 2015-04-13 14:22 ` [PATCH i-g-t v4 2/2] " Joonas Lahtinen 1 sibling, 2 replies; 16+ messages in thread From: Tvrtko Ursulin @ 2015-04-13 11:32 UTC (permalink / raw) To: Joonas Lahtinen, intel-gfx Hi, On 04/07/2015 01:23 PM, Joonas Lahtinen wrote: > Add a straightforward test that allocates a BO that is bigger than > (by 1 page currently) the mappable aperture, tests mmap access to it > by CPU directly and through GTT in sequence. > > Currently it is expected for the GTT access to gracefully fail as > all objects are attempted to get pinned to GTT completely for mmap > access. Once the partial view support is merged to kernel, the test > should pass for all parts. > > Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> > --- > tests/gem_mmap_gtt.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 68 insertions(+) > > diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c > index 55c66a2..bf3627c 100644 > --- a/tests/gem_mmap_gtt.c > +++ b/tests/gem_mmap_gtt.c > @@ -41,6 +41,10 @@ > #include "drmtest.h" > #include "igt_debugfs.h" > > +#ifndef PAGE_SIZE > +#define PAGE_SIZE 4096 > +#endif > + > static int OBJECT_SIZE = 16*1024*1024; > > static void set_domain(int fd, uint32_t handle) > @@ -258,6 +262,68 @@ test_write_gtt(int fd) > } > > static void > +test_huge_bo(int fd) > +{ > + uint32_t bo; > + char *ptr_cpu; > + char *ptr_gtt; > + char *cpu_pattern; > + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / > + PAGE_SIZE; > + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; > + uint64_t last_offset = huge_object_size - PAGE_SIZE; > + > + cpu_pattern = malloc(PAGE_SIZE); > + igt_assert(cpu_pattern); I'd be tempted to use 4k from the stack for simplicity. > + memset(cpu_pattern, 0xaa, PAGE_SIZE); > + > + bo = gem_create(fd, huge_object_size); > + > + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, > + PROT_READ | PROT_WRITE); > + if (!ptr_cpu) { > + igt_warn("Not enough free memory for huge BO test!\n"); > + goto out; Free address space or free memory? Also, igt_require so test skips in that case? > + } > + > + /* Test read/write to first/last page with CPU. */ > + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); > + > + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); > + > + munmap(ptr_cpu, huge_object_size); > + ptr_cpu = NULL; > + > + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, > + PROT_READ | PROT_WRITE); > + if (!ptr_gtt) { > + igt_debug("Huge BO GTT mapping not supported!\n"); > + goto out; igt_require as above? Hm, although ideally test would be able to detect the feature (once it is added to the kernel) so it could assert here. > + } > + > + /* Test read/write to first/last page through GTT. */ > + set_domain(fd, bo); > + > + igt_assert(memcmp(ptr_gtt, cpu_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + memset(ptr_gtt, 0x55, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + memset(ptr_gtt + last_offset, 0x55, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt, ptr_gtt + last_offset, PAGE_SIZE) == 0); Comments for the above would be nice just to explain what is being tested and how. Won't the last test has side effects with partial views since it is accessing beginning and end of the object? Would it be better to memcmp against a pattern on stack or in heap like cpu_pattern? Will you support two simultaneous partial views or the last memcmp will cause a lot of partial view creation/destruction? > + > + munmap(ptr_gtt, huge_object_size); > +out: > + gem_close(fd, bo); > + free(cpu_pattern); > +} > + > +static void > test_read(int fd) > { > void *dst; > @@ -395,6 +461,8 @@ igt_main > run_without_prefault(fd, test_write_gtt); > igt_subtest("write-cpu-read-gtt") > test_write_cpu_read_gtt(fd); > + igt_subtest("huge-bo") > + test_huge_bo(fd); > > igt_fixture > close(fd); > Regards, Tvrtko _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test 2015-04-13 11:32 ` [PATCH i-g-t] " Tvrtko Ursulin @ 2015-04-13 14:22 ` Joonas Lahtinen 2015-04-13 14:49 ` Tvrtko Ursulin 2015-04-13 14:22 ` [PATCH i-g-t v4 2/2] " Joonas Lahtinen 1 sibling, 1 reply; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-13 14:22 UTC (permalink / raw) To: Tvrtko Ursulin; +Cc: intel-gfx On ma, 2015-04-13 at 12:32 +0100, Tvrtko Ursulin wrote: > Hi, > > On 04/07/2015 01:23 PM, Joonas Lahtinen wrote: > > Add a straightforward test that allocates a BO that is bigger than > > (by 1 page currently) the mappable aperture, tests mmap access to it > > by CPU directly and through GTT in sequence. > > > > Currently it is expected for the GTT access to gracefully fail as > > all objects are attempted to get pinned to GTT completely for mmap > > access. Once the partial view support is merged to kernel, the test > > should pass for all parts. > > > > Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> > > --- > > tests/gem_mmap_gtt.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++ > > 1 file changed, 68 insertions(+) > > > > diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c > > index 55c66a2..bf3627c 100644 > > --- a/tests/gem_mmap_gtt.c > > +++ b/tests/gem_mmap_gtt.c > > @@ -41,6 +41,10 @@ > > #include "drmtest.h" > > #include "igt_debugfs.h" > > > > +#ifndef PAGE_SIZE > > +#define PAGE_SIZE 4096 > > +#endif > > + > > static int OBJECT_SIZE = 16*1024*1024; > > > > static void set_domain(int fd, uint32_t handle) > > @@ -258,6 +262,68 @@ test_write_gtt(int fd) > > } > > > > static void > > +test_huge_bo(int fd) > > +{ > > + uint32_t bo; > > + char *ptr_cpu; > > + char *ptr_gtt; > > + char *cpu_pattern; > > + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / > > + PAGE_SIZE; > > + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; > > + uint64_t last_offset = huge_object_size - PAGE_SIZE; > > + > > + cpu_pattern = malloc(PAGE_SIZE); > > + igt_assert(cpu_pattern); > > I'd be tempted to use 4k from the stack for simplicity. It's not a nice thing to allocate two 4k objects from stack. So lets just not. > > + memset(cpu_pattern, 0xaa, PAGE_SIZE); > > + > > + bo = gem_create(fd, huge_object_size); > > + > > + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, > > + PROT_READ | PROT_WRITE); > > + if (!ptr_cpu) { > > + igt_warn("Not enough free memory for huge BO test!\n"); > > + goto out; > > Free address space or free memory? > It is not really relevant to the test which condition caused it. But yeah, correcting the error message into 'Can not allocate memory'. > Also, igt_require so test skips in that case? > Ack using igt_require_f. Because the condition is bit unclear without the text. > > + } > > + > > + /* Test read/write to first/last page with CPU. */ > > + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); > > + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); > > + > > + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); > > + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); > > + > > + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); > > + > > + munmap(ptr_cpu, huge_object_size); > > + ptr_cpu = NULL; > > + > > + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, > > + PROT_READ | PROT_WRITE); > > + if (!ptr_gtt) { > > + igt_debug("Huge BO GTT mapping not supported!\n"); > > + goto out; > > igt_require as above? Hm, although ideally test would be able to detect > the feature (once it is added to the kernel) so it could assert here. > I think the point is somewhat that UMP should not need to know/care about it. Before introducing the feature the above will always fail, and after introducing it, it will always succeed (unless there is less than 1MB aperture space available). So I think it should be good as it is. > > + } > > + > > + /* Test read/write to first/last page through GTT. */ > > + set_domain(fd, bo); > > + > > + igt_assert(memcmp(ptr_gtt, cpu_pattern, PAGE_SIZE) == 0); > > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > > + > > + memset(ptr_gtt, 0x55, PAGE_SIZE); > > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > > + > > + memset(ptr_gtt + last_offset, 0x55, PAGE_SIZE); > > + igt_assert(memcmp(ptr_gtt, ptr_gtt + last_offset, PAGE_SIZE) == 0); > > Comments for the above would be nice just to explain what is being > tested and how. > The level of commenting was higher already than I noticed to be in other tests, but I'll add a few more. > Won't the last test has side effects with partial views since it is > accessing beginning and end of the object? Would it be better to memcmp > against a pattern on stack or in heap like cpu_pattern? > > Will you support two simultaneous partial views or the last memcmp will > cause a lot of partial view creation/destruction? Yes, there will be multiple partial views, but it's all internal to the kernel implementation. Above access pattern should be supported. Regards, Joonas > > > + > > + munmap(ptr_gtt, huge_object_size); > > +out: > > + gem_close(fd, bo); > > + free(cpu_pattern); > > +} > > + > > +static void > > test_read(int fd) > > { > > void *dst; > > @@ -395,6 +461,8 @@ igt_main > > run_without_prefault(fd, test_write_gtt); > > igt_subtest("write-cpu-read-gtt") > > test_write_cpu_read_gtt(fd); > > + igt_subtest("huge-bo") > > + test_huge_bo(fd); > > > > igt_fixture > > close(fd); > > > > Regards, > > Tvrtko _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test 2015-04-13 14:22 ` Joonas Lahtinen @ 2015-04-13 14:49 ` Tvrtko Ursulin 2015-04-14 11:14 ` [PATCH i-g-t v5] " Joonas Lahtinen 0 siblings, 1 reply; 16+ messages in thread From: Tvrtko Ursulin @ 2015-04-13 14:49 UTC (permalink / raw) To: Joonas Lahtinen; +Cc: intel-gfx On 04/13/2015 03:22 PM, Joonas Lahtinen wrote: > On ma, 2015-04-13 at 12:32 +0100, Tvrtko Ursulin wrote: >> Hi, >> >> On 04/07/2015 01:23 PM, Joonas Lahtinen wrote: >>> Add a straightforward test that allocates a BO that is bigger than >>> (by 1 page currently) the mappable aperture, tests mmap access to it >>> by CPU directly and through GTT in sequence. >>> >>> Currently it is expected for the GTT access to gracefully fail as >>> all objects are attempted to get pinned to GTT completely for mmap >>> access. Once the partial view support is merged to kernel, the test >>> should pass for all parts. >>> >>> Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> >>> --- >>> tests/gem_mmap_gtt.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++ >>> 1 file changed, 68 insertions(+) >>> >>> diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c >>> index 55c66a2..bf3627c 100644 >>> --- a/tests/gem_mmap_gtt.c >>> +++ b/tests/gem_mmap_gtt.c >>> @@ -41,6 +41,10 @@ >>> #include "drmtest.h" >>> #include "igt_debugfs.h" >>> >>> +#ifndef PAGE_SIZE >>> +#define PAGE_SIZE 4096 >>> +#endif >>> + >>> static int OBJECT_SIZE = 16*1024*1024; >>> >>> static void set_domain(int fd, uint32_t handle) >>> @@ -258,6 +262,68 @@ test_write_gtt(int fd) >>> } >>> >>> static void >>> +test_huge_bo(int fd) >>> +{ >>> + uint32_t bo; >>> + char *ptr_cpu; >>> + char *ptr_gtt; >>> + char *cpu_pattern; >>> + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / >>> + PAGE_SIZE; >>> + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; >>> + uint64_t last_offset = huge_object_size - PAGE_SIZE; >>> + >>> + cpu_pattern = malloc(PAGE_SIZE); >>> + igt_assert(cpu_pattern); >> >> I'd be tempted to use 4k from the stack for simplicity. > > It's not a nice thing to allocate two 4k objects from stack. So lets > just not. Why not? It's not kernel stack but 8MiB default for a simple IGT... and changelog to v3 says otherwise. ;) But ok.. >>> + memset(cpu_pattern, 0xaa, PAGE_SIZE); >>> + >>> + bo = gem_create(fd, huge_object_size); >>> + >>> + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, >>> + PROT_READ | PROT_WRITE); >>> + if (!ptr_cpu) { >>> + igt_warn("Not enough free memory for huge BO test!\n"); >>> + goto out; >> >> Free address space or free memory? >> > > It is not really relevant to the test which condition caused it. But > yeah, correcting the error message into 'Can not allocate memory'. Is it really memory and not address space? >> Also, igt_require so test skips in that case? >> > > Ack using igt_require_f. Because the condition is bit unclear without > the text. > >>> + } >>> + >>> + /* Test read/write to first/last page with CPU. */ >>> + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); >>> + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); >>> + >>> + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); >>> + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); >>> + >>> + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); >>> + >>> + munmap(ptr_cpu, huge_object_size); >>> + ptr_cpu = NULL; >>> + >>> + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, >>> + PROT_READ | PROT_WRITE); >>> + if (!ptr_gtt) { >>> + igt_debug("Huge BO GTT mapping not supported!\n"); >>> + goto out; >> >> igt_require as above? Hm, although ideally test would be able to detect >> the feature (once it is added to the kernel) so it could assert here. >> > > I think the point is somewhat that UMP should not need to know/care > about it. Before introducing the feature the above will always fail, and > after introducing it, it will always succeed (unless there is less than > 1MB aperture space available). So I think it should be good as it is. I suppose there isn't really a way to be smarter in this case. >>> + } >>> + >>> + /* Test read/write to first/last page through GTT. */ >>> + set_domain(fd, bo); >>> + >>> + igt_assert(memcmp(ptr_gtt, cpu_pattern, PAGE_SIZE) == 0); >>> + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); >>> + >>> + memset(ptr_gtt, 0x55, PAGE_SIZE); >>> + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); >>> + >>> + memset(ptr_gtt + last_offset, 0x55, PAGE_SIZE); >>> + igt_assert(memcmp(ptr_gtt, ptr_gtt + last_offset, PAGE_SIZE) == 0); >> >> Comments for the above would be nice just to explain what is being >> tested and how. >> > > The level of commenting was higher already than I noticed to be in other > tests, but I'll add a few more. Thanks, it's best to lead by example! >> Won't the last test has side effects with partial views since it is >> accessing beginning and end of the object? Would it be better to memcmp >> against a pattern on stack or in heap like cpu_pattern? >> >> Will you support two simultaneous partial views or the last memcmp will >> cause a lot of partial view creation/destruction? > > Yes, there will be multiple partial views, but it's all internal to the > kernel implementation. Above access pattern should be supported. Very well then! Regards, Tvrtko _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH i-g-t v5] tests/gem_mmap_gtt: add huge BO test 2015-04-13 14:49 ` Tvrtko Ursulin @ 2015-04-14 11:14 ` Joonas Lahtinen 2015-04-14 11:23 ` Tvrtko Ursulin 2015-04-14 16:51 ` Thomas Wood 0 siblings, 2 replies; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-14 11:14 UTC (permalink / raw) To: intel-gfx Add a straightforward test that allocates a BO that is bigger than (by 1 page currently) the mappable aperture, tests mmap access to it by CPU directly and through GTT in sequence. Currently it is expected for the GTT access to gracefully fail as all objects are attempted to get pinned to GTT completely for mmap access. Once the partial view support is merged to kernel, the test should pass for all parts. v2: - Corrected BO domain handling (Chris Wilson) - Check again after GTT access for added paranoia (Chris Wilson) v3: - Avoid flush by using pread (Chris Wilson) - Free gtt_pattern buffer too. v4: - Add more comments (Tvrtko Ursulin) - Use igt_require (Tvrtko Ursulin) v5: - Remove wrong message from igt_require_f (Tvrtko Ursulin) - After digging deeper to it, just igt_assert that the CPU mapping needs to succeed. Cc: Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com> Cc: Chris Wilson <chris@chris-wilson.co.uk> Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> --- tests/gem_mmap_gtt.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 106 insertions(+) diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c index 115e398..487eecf 100644 --- a/tests/gem_mmap_gtt.c +++ b/tests/gem_mmap_gtt.c @@ -41,6 +41,10 @@ #include "drmtest.h" #include "igt_debugfs.h" +#ifndef PAGE_SIZE +#define PAGE_SIZE 4096 +#endif + static int OBJECT_SIZE = 16*1024*1024; static void @@ -55,6 +59,20 @@ set_domain_cpu(int fd, uint32_t handle) gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); } +static void +pread_bo(int fd, int handle, void *buf, int offset, int size) +{ + struct drm_i915_gem_pread gem_pread; + + memset(&gem_pread, 0, sizeof(gem_pread)); + gem_pread.handle = handle; + gem_pread.data_ptr = (uintptr_t)buf; + gem_pread.size = size; + gem_pread.offset = offset; + + igt_assert(ioctl(fd, DRM_IOCTL_I915_GEM_PREAD, &gem_pread) == 0); +} + static void * mmap_bo(int fd, uint32_t handle) { @@ -265,6 +283,92 @@ test_write_gtt(int fd) } static void +test_huge_bo(int fd) +{ + uint32_t bo; + char *ptr_cpu; + char *ptr_gtt; + char *cpu_pattern; + char *gtt_pattern; + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / + PAGE_SIZE; + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; + uint64_t last_offset = huge_object_size - PAGE_SIZE; + + cpu_pattern = malloc(PAGE_SIZE); + gtt_pattern = malloc(PAGE_SIZE); + igt_assert(cpu_pattern && gtt_pattern); + memset(cpu_pattern, 0xaa, PAGE_SIZE); + memset(gtt_pattern, ~0xaa, PAGE_SIZE); + + bo = gem_create(fd, huge_object_size); + + /* Obtain CPU mapping for the object. */ + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, + PROT_READ | PROT_WRITE); + igt_assert(ptr_cpu); + + set_domain_cpu(fd, bo); + + /* Write first page through the mapping and assert reading it back + * works. */ + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); + + /* Write last page through the mapping and assert reading it back + * works. */ + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + /* Cross check that accessing two simultaneous pages works. */ + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); + + munmap(ptr_cpu, huge_object_size); + ptr_cpu = NULL; + + /* Obtain mapping for the object through GTT. */ + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, + PROT_READ | PROT_WRITE); + igt_require_f(ptr_gtt, "Huge BO GTT mapping not supported.\n"); + + set_domain_gtt(fd, bo); + + /* Access through GTT should still provide the CPU written values. */ + igt_assert(memcmp(ptr_gtt , cpu_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + /* Try replacing first page through GTT mapping and make sure other page + * stays intact. */ + memcpy(ptr_gtt, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + /* And make sure that after writing, both pages contain what they + * should.*/ + memcpy(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE) == 0); + + munmap(ptr_gtt, huge_object_size); + ptr_gtt = NULL; + + /* Verify the page contents after GTT writes by reading without mapping. + * Mapping to CPU domain is avoided not to cause a huge flush. + */ + pread_bo(fd, bo, cpu_pattern, 0, PAGE_SIZE); + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); + + memset(cpu_pattern, 0x00, PAGE_SIZE); + + pread_bo(fd, bo, cpu_pattern, last_offset, PAGE_SIZE); + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); +out: + gem_close(fd, bo); + free(cpu_pattern); + free(gtt_pattern); +} + +static void test_read(int fd) { void *dst; @@ -402,6 +506,8 @@ igt_main run_without_prefault(fd, test_write_gtt); igt_subtest("write-cpu-read-gtt") test_write_cpu_read_gtt(fd); + igt_subtest("huge-bo") + test_huge_bo(fd); igt_fixture close(fd); -- 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply related [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t v5] tests/gem_mmap_gtt: add huge BO test 2015-04-14 11:14 ` [PATCH i-g-t v5] " Joonas Lahtinen @ 2015-04-14 11:23 ` Tvrtko Ursulin 2015-04-14 16:51 ` Thomas Wood 1 sibling, 0 replies; 16+ messages in thread From: Tvrtko Ursulin @ 2015-04-14 11:23 UTC (permalink / raw) To: Joonas Lahtinen, intel-gfx On 04/14/2015 12:14 PM, Joonas Lahtinen wrote: > Add a straightforward test that allocates a BO that is bigger than > (by 1 page currently) the mappable aperture, tests mmap access to it > by CPU directly and through GTT in sequence. > > Currently it is expected for the GTT access to gracefully fail as > all objects are attempted to get pinned to GTT completely for mmap > access. Once the partial view support is merged to kernel, the test > should pass for all parts. > > v2: > - Corrected BO domain handling (Chris Wilson) > - Check again after GTT access for added paranoia (Chris Wilson) > > v3: > - Avoid flush by using pread (Chris Wilson) > - Free gtt_pattern buffer too. > > v4: > - Add more comments (Tvrtko Ursulin) > - Use igt_require (Tvrtko Ursulin) > > v5: > - Remove wrong message from igt_require_f (Tvrtko Ursulin) > - After digging deeper to it, just igt_assert that the CPU > mapping needs to succeed. > > Cc: Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com> > Cc: Chris Wilson <chris@chris-wilson.co.uk> > Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> > --- > tests/gem_mmap_gtt.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 106 insertions(+) > > diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c > index 115e398..487eecf 100644 > --- a/tests/gem_mmap_gtt.c > +++ b/tests/gem_mmap_gtt.c > @@ -41,6 +41,10 @@ > #include "drmtest.h" > #include "igt_debugfs.h" > > +#ifndef PAGE_SIZE > +#define PAGE_SIZE 4096 > +#endif > + > static int OBJECT_SIZE = 16*1024*1024; > > static void > @@ -55,6 +59,20 @@ set_domain_cpu(int fd, uint32_t handle) > gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); > } > > +static void > +pread_bo(int fd, int handle, void *buf, int offset, int size) > +{ > + struct drm_i915_gem_pread gem_pread; > + > + memset(&gem_pread, 0, sizeof(gem_pread)); > + gem_pread.handle = handle; > + gem_pread.data_ptr = (uintptr_t)buf; > + gem_pread.size = size; > + gem_pread.offset = offset; > + > + igt_assert(ioctl(fd, DRM_IOCTL_I915_GEM_PREAD, &gem_pread) == 0); > +} > + > static void * > mmap_bo(int fd, uint32_t handle) > { > @@ -265,6 +283,92 @@ test_write_gtt(int fd) > } > > static void > +test_huge_bo(int fd) > +{ > + uint32_t bo; > + char *ptr_cpu; > + char *ptr_gtt; > + char *cpu_pattern; > + char *gtt_pattern; > + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / > + PAGE_SIZE; > + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; > + uint64_t last_offset = huge_object_size - PAGE_SIZE; > + > + cpu_pattern = malloc(PAGE_SIZE); > + gtt_pattern = malloc(PAGE_SIZE); > + igt_assert(cpu_pattern && gtt_pattern); > + memset(cpu_pattern, 0xaa, PAGE_SIZE); > + memset(gtt_pattern, ~0xaa, PAGE_SIZE); > + > + bo = gem_create(fd, huge_object_size); > + > + /* Obtain CPU mapping for the object. */ > + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, > + PROT_READ | PROT_WRITE); > + igt_assert(ptr_cpu); > + > + set_domain_cpu(fd, bo); > + > + /* Write first page through the mapping and assert reading it back > + * works. */ > + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); > + > + /* Write last page through the mapping and assert reading it back > + * works. */ > + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + /* Cross check that accessing two simultaneous pages works. */ > + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); > + > + munmap(ptr_cpu, huge_object_size); > + ptr_cpu = NULL; > + > + /* Obtain mapping for the object through GTT. */ > + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, > + PROT_READ | PROT_WRITE); > + igt_require_f(ptr_gtt, "Huge BO GTT mapping not supported.\n"); > + > + set_domain_gtt(fd, bo); > + > + /* Access through GTT should still provide the CPU written values. */ > + igt_assert(memcmp(ptr_gtt , cpu_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + /* Try replacing first page through GTT mapping and make sure other page > + * stays intact. */ > + memcpy(ptr_gtt, gtt_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + /* And make sure that after writing, both pages contain what they > + * should.*/ > + memcpy(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE) == 0); > + > + munmap(ptr_gtt, huge_object_size); > + ptr_gtt = NULL; > + > + /* Verify the page contents after GTT writes by reading without mapping. > + * Mapping to CPU domain is avoided not to cause a huge flush. > + */ > + pread_bo(fd, bo, cpu_pattern, 0, PAGE_SIZE); > + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); > + > + memset(cpu_pattern, 0x00, PAGE_SIZE); > + > + pread_bo(fd, bo, cpu_pattern, last_offset, PAGE_SIZE); > + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); > +out: > + gem_close(fd, bo); > + free(cpu_pattern); > + free(gtt_pattern); > +} > + > +static void > test_read(int fd) > { > void *dst; > @@ -402,6 +506,8 @@ igt_main > run_without_prefault(fd, test_write_gtt); > igt_subtest("write-cpu-read-gtt") > test_write_cpu_read_gtt(fd); > + igt_subtest("huge-bo") > + test_huge_bo(fd); > > igt_fixture > close(fd); > I suspect in the future you may want to create a dedicated test for partial views since there will be many more specific test cases, but for now: Reviewed-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com> Regards, Tvrtko _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [PATCH i-g-t v5] tests/gem_mmap_gtt: add huge BO test 2015-04-14 11:14 ` [PATCH i-g-t v5] " Joonas Lahtinen 2015-04-14 11:23 ` Tvrtko Ursulin @ 2015-04-14 16:51 ` Thomas Wood 1 sibling, 0 replies; 16+ messages in thread From: Thomas Wood @ 2015-04-14 16:51 UTC (permalink / raw) To: Joonas Lahtinen; +Cc: intel-gfx On 14 April 2015 at 12:14, Joonas Lahtinen <joonas.lahtinen@linux.intel.com> wrote: > Add a straightforward test that allocates a BO that is bigger than > (by 1 page currently) the mappable aperture, tests mmap access to it > by CPU directly and through GTT in sequence. > > Currently it is expected for the GTT access to gracefully fail as > all objects are attempted to get pinned to GTT completely for mmap > access. Once the partial view support is merged to kernel, the test > should pass for all parts. > > v2: > - Corrected BO domain handling (Chris Wilson) > - Check again after GTT access for added paranoia (Chris Wilson) > > v3: > - Avoid flush by using pread (Chris Wilson) > - Free gtt_pattern buffer too. > > v4: > - Add more comments (Tvrtko Ursulin) > - Use igt_require (Tvrtko Ursulin) > > v5: > - Remove wrong message from igt_require_f (Tvrtko Ursulin) > - After digging deeper to it, just igt_assert that the CPU > mapping needs to succeed. > > Cc: Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com> > Cc: Chris Wilson <chris@chris-wilson.co.uk> > Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> > --- > tests/gem_mmap_gtt.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 106 insertions(+) > > diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c > index 115e398..487eecf 100644 > --- a/tests/gem_mmap_gtt.c > +++ b/tests/gem_mmap_gtt.c > @@ -41,6 +41,10 @@ > #include "drmtest.h" > #include "igt_debugfs.h" > > +#ifndef PAGE_SIZE > +#define PAGE_SIZE 4096 > +#endif > + > static int OBJECT_SIZE = 16*1024*1024; > > static void > @@ -55,6 +59,20 @@ set_domain_cpu(int fd, uint32_t handle) > gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); > } > > +static void > +pread_bo(int fd, int handle, void *buf, int offset, int size) > +{ > + struct drm_i915_gem_pread gem_pread; > + > + memset(&gem_pread, 0, sizeof(gem_pread)); > + gem_pread.handle = handle; > + gem_pread.data_ptr = (uintptr_t)buf; > + gem_pread.size = size; > + gem_pread.offset = offset; > + > + igt_assert(ioctl(fd, DRM_IOCTL_I915_GEM_PREAD, &gem_pread) == 0); > +} > + > static void * > mmap_bo(int fd, uint32_t handle) > { > @@ -265,6 +283,92 @@ test_write_gtt(int fd) > } > > static void > +test_huge_bo(int fd) > +{ > + uint32_t bo; > + char *ptr_cpu; > + char *ptr_gtt; > + char *cpu_pattern; > + char *gtt_pattern; > + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / > + PAGE_SIZE; > + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; > + uint64_t last_offset = huge_object_size - PAGE_SIZE; > + > + cpu_pattern = malloc(PAGE_SIZE); > + gtt_pattern = malloc(PAGE_SIZE); > + igt_assert(cpu_pattern && gtt_pattern); > + memset(cpu_pattern, 0xaa, PAGE_SIZE); > + memset(gtt_pattern, ~0xaa, PAGE_SIZE); > + > + bo = gem_create(fd, huge_object_size); > + > + /* Obtain CPU mapping for the object. */ > + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, > + PROT_READ | PROT_WRITE); > + igt_assert(ptr_cpu); > + > + set_domain_cpu(fd, bo); > + > + /* Write first page through the mapping and assert reading it back > + * works. */ > + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); > + > + /* Write last page through the mapping and assert reading it back > + * works. */ > + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + /* Cross check that accessing two simultaneous pages works. */ > + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); > + > + munmap(ptr_cpu, huge_object_size); > + ptr_cpu = NULL; > + > + /* Obtain mapping for the object through GTT. */ > + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, > + PROT_READ | PROT_WRITE); > + igt_require_f(ptr_gtt, "Huge BO GTT mapping not supported.\n"); > + > + set_domain_gtt(fd, bo); > + > + /* Access through GTT should still provide the CPU written values. */ > + igt_assert(memcmp(ptr_gtt , cpu_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + /* Try replacing first page through GTT mapping and make sure other page > + * stays intact. */ > + memcpy(ptr_gtt, gtt_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); > + > + /* And make sure that after writing, both pages contain what they > + * should.*/ > + memcpy(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE); > + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); > + igt_assert(memcmp(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE) == 0); > + > + munmap(ptr_gtt, huge_object_size); > + ptr_gtt = NULL; > + > + /* Verify the page contents after GTT writes by reading without mapping. > + * Mapping to CPU domain is avoided not to cause a huge flush. > + */ > + pread_bo(fd, bo, cpu_pattern, 0, PAGE_SIZE); > + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); > + > + memset(cpu_pattern, 0x00, PAGE_SIZE); > + > + pread_bo(fd, bo, cpu_pattern, last_offset, PAGE_SIZE); > + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); > +out: I removed the unused label here and pushed this and the BO domain setting functions patch. > + gem_close(fd, bo); > + free(cpu_pattern); > + free(gtt_pattern); > +} > + > +static void > test_read(int fd) > { > void *dst; > @@ -402,6 +506,8 @@ igt_main > run_without_prefault(fd, test_write_gtt); > igt_subtest("write-cpu-read-gtt") > test_write_cpu_read_gtt(fd); > + igt_subtest("huge-bo") > + test_huge_bo(fd); > > igt_fixture > close(fd); > -- > 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH i-g-t v4 2/2] tests/gem_mmap_gtt: add huge BO test 2015-04-13 11:32 ` [PATCH i-g-t] " Tvrtko Ursulin 2015-04-13 14:22 ` Joonas Lahtinen @ 2015-04-13 14:22 ` Joonas Lahtinen 1 sibling, 0 replies; 16+ messages in thread From: Joonas Lahtinen @ 2015-04-13 14:22 UTC (permalink / raw) To: intel-gfx Add a straightforward test that allocates a BO that is bigger than (by 1 page currently) the mappable aperture, tests mmap access to it by CPU directly and through GTT in sequence. Currently it is expected for the GTT access to gracefully fail as all objects are attempted to get pinned to GTT completely for mmap access. Once the partial view support is merged to kernel, the test should pass for all parts. v2: - Corrected BO domain handling (Chris Wilson) - Check again after GTT access for added paranoia (Chris Wilson) v3: - Avoid flush by using pread (Chris Wilson) - Free gtt_pattern buffer too. v4: - Add more comments (Tvrtko Ursulin) - Use igt_require (Tvrtko Ursulin) Cc: Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com> Cc: Chris Wilson <chris@chris-wilson.co.uk> Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com> --- tests/gem_mmap_gtt.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 106 insertions(+) diff --git a/tests/gem_mmap_gtt.c b/tests/gem_mmap_gtt.c index 115e398..5888c7d 100644 --- a/tests/gem_mmap_gtt.c +++ b/tests/gem_mmap_gtt.c @@ -41,6 +41,10 @@ #include "drmtest.h" #include "igt_debugfs.h" +#ifndef PAGE_SIZE +#define PAGE_SIZE 4096 +#endif + static int OBJECT_SIZE = 16*1024*1024; static void @@ -55,6 +59,20 @@ set_domain_cpu(int fd, uint32_t handle) gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU); } +static void +pread_bo(int fd, int handle, void *buf, int offset, int size) +{ + struct drm_i915_gem_pread gem_pread; + + memset(&gem_pread, 0, sizeof(gem_pread)); + gem_pread.handle = handle; + gem_pread.data_ptr = (uintptr_t)buf; + gem_pread.size = size; + gem_pread.offset = offset; + + igt_assert(ioctl(fd, DRM_IOCTL_I915_GEM_PREAD, &gem_pread) == 0); +} + static void * mmap_bo(int fd, uint32_t handle) { @@ -265,6 +283,92 @@ test_write_gtt(int fd) } static void +test_huge_bo(int fd) +{ + uint32_t bo; + char *ptr_cpu; + char *ptr_gtt; + char *cpu_pattern; + char *gtt_pattern; + uint64_t mappable_aperture_pages = gem_mappable_aperture_size() / + PAGE_SIZE; + uint64_t huge_object_size = (mappable_aperture_pages + 1) * PAGE_SIZE; + uint64_t last_offset = huge_object_size - PAGE_SIZE; + + cpu_pattern = malloc(PAGE_SIZE); + gtt_pattern = malloc(PAGE_SIZE); + igt_assert(cpu_pattern && gtt_pattern); + memset(cpu_pattern, 0xaa, PAGE_SIZE); + memset(gtt_pattern, ~0xaa, PAGE_SIZE); + + bo = gem_create(fd, huge_object_size); + + /* Obtain CPU mapping for the object. */ + ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size, + PROT_READ | PROT_WRITE); + igt_require_f(ptr_cpu, "Can not allocate memory for test.\n"); + + set_domain_cpu(fd, bo); + + /* Write first page through the mapping and assert reading it back + * works. */ + memcpy(ptr_cpu, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu, cpu_pattern, PAGE_SIZE) == 0); + + /* Write last page through the mapping and assert reading it back + * works. */ + memcpy(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_cpu + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + /* Cross check that accessing two simultaneous pages works. */ + igt_assert(memcmp(ptr_cpu, ptr_cpu + last_offset, PAGE_SIZE) == 0); + + munmap(ptr_cpu, huge_object_size); + ptr_cpu = NULL; + + /* Obtain mapping for the object through GTT. */ + ptr_gtt = gem_mmap__gtt(fd, bo, huge_object_size, + PROT_READ | PROT_WRITE); + igt_require_f(ptr_gtt, "Huge BO GTT mapping not supported.\n"); + + set_domain_gtt(fd, bo); + + /* Access through GTT should still provide the CPU written values. */ + igt_assert(memcmp(ptr_gtt , cpu_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + /* Try replacing first page through GTT mapping and make sure other page + * stays intact. */ + memcpy(ptr_gtt, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, cpu_pattern, PAGE_SIZE) == 0); + + /* And make sure that after writing, both pages contain what they + * should.*/ + memcpy(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE); + igt_assert(memcmp(ptr_gtt , gtt_pattern, PAGE_SIZE) == 0); + igt_assert(memcmp(ptr_gtt + last_offset, gtt_pattern, PAGE_SIZE) == 0); + + munmap(ptr_gtt, huge_object_size); + ptr_gtt = NULL; + + /* Verify the page contents after GTT writes by reading without mapping. + * Mapping to CPU domain is avoided not to cause a huge flush. + */ + pread_bo(fd, bo, cpu_pattern, 0, PAGE_SIZE); + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); + + memset(cpu_pattern, 0x00, PAGE_SIZE); + + pread_bo(fd, bo, cpu_pattern, last_offset, PAGE_SIZE); + igt_assert(memcmp(cpu_pattern, gtt_pattern, PAGE_SIZE) == 0); +out: + gem_close(fd, bo); + free(cpu_pattern); + free(gtt_pattern); +} + +static void test_read(int fd) { void *dst; @@ -402,6 +506,8 @@ igt_main run_without_prefault(fd, test_write_gtt); igt_subtest("write-cpu-read-gtt") test_write_cpu_read_gtt(fd); + igt_subtest("huge-bo") + test_huge_bo(fd); igt_fixture close(fd); -- 1.9.3 _______________________________________________ Intel-gfx mailing list Intel-gfx@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/intel-gfx ^ permalink raw reply related [flat|nested] 16+ messages in thread
end of thread, other threads:[~2015-04-14 16:52 UTC | newest] Thread overview: 16+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2015-04-07 12:23 [PATCH i-g-t] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 2015-04-07 14:08 ` Chris Wilson 2015-04-08 10:45 ` Joonas Lahtinen 2015-04-08 10:50 ` [PATCH i-g-t v2 1/2] tests/gem_mmap_gtt: Clarify BO domain setting functions Joonas Lahtinen 2015-04-08 10:51 ` [PATCH i-g-t v2 2/2] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 2015-04-08 11:00 ` Chris Wilson 2015-04-08 12:55 ` [PATCH i-g-t v3 1/2] tests/gem_mmap_gtt: clarify BO domain setting functions Joonas Lahtinen 2015-04-13 6:03 ` Joonas Lahtinen 2015-04-08 12:57 ` [PATCH i-g-t v3 2/2] tests/gem_mmap_gtt: add huge BO test Joonas Lahtinen 2015-04-13 11:32 ` [PATCH i-g-t] " Tvrtko Ursulin 2015-04-13 14:22 ` Joonas Lahtinen 2015-04-13 14:49 ` Tvrtko Ursulin 2015-04-14 11:14 ` [PATCH i-g-t v5] " Joonas Lahtinen 2015-04-14 11:23 ` Tvrtko Ursulin 2015-04-14 16:51 ` Thomas Wood 2015-04-13 14:22 ` [PATCH i-g-t v4 2/2] " Joonas Lahtinen
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.