[igt-dev] [PATCH i-g-t] tests/gem_evict_everything fix for mlocked-* subtests

[igt-dev] [PATCH i-g-t] tests/gem_evict_everything fix for mlocked-* subtests

[Ewelina Musial]

Add check to avoid locking biggest mem size than is available.
Trying to allocate size returned by intel_get_avail_ram_mb()
triggers OOM killer. It looks like available RAM is not fully free
so my idea is to decrease this size of 1024MB and before allocating
increase mem size in loop till will be maximally big.

Also, changed surface_count. Few thousands of iterations is not
necessary and is taking a lot of time. This change should cover
previous functionality.

Using __igt_waitchildren() instead of igt_waitchildren() avoids
failing test if OOM killer stops process run by igt_fork() (OOM killer
is expected).

__igt_waitchildren() is implemented by Chris in other patch so this will
be failing now. I will update this patch after merging his code :)

Signed-off-by: Ewelina Musial <ewelina.musial@intel.com>
---
 tests/eviction_common.c      | 51 ++++++++++++++++++++++++++++++++++++++------
 tests/gem_evict_everything.c |  6 +++---
 2 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/tests/eviction_common.c b/tests/eviction_common.c
index 300eb03d..7ae48654 100644
--- a/tests/eviction_common.c
+++ b/tests/eviction_common.c
@@ -134,14 +134,20 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 			      uint64_t surface_count)
 {
 	unsigned int *can_mlock;
-	uint64_t sz, pin;
+	uint64_t sz, pin, *update_pin = 0;
+	bool flag = false;
 
 	intel_require_memory(surface_count, surface_size, CHECK_RAM);
 
 	sz = surface_size*surface_count;
-	pin = intel_get_avail_ram_mb();
+	pin = intel_get_avail_ram_mb() - 1024;
 	pin *= 1024 * 1024;
 	igt_require(pin > sz);
+
+	update_pin = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+	igt_assert(update_pin != MAP_FAILED);
+	*update_pin = pin;
+
 	pin -= sz;
 
 	igt_debug("Pinning [%'lld, %'lld] MiB\n",
@@ -151,16 +157,48 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 	can_mlock = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
 	igt_assert(can_mlock != MAP_FAILED);
 
+	igt_fork(child, 1)
+	{
+		void *lock;
+		uint64_t update_step = (5 << 22);
+
+		do {
+			lock = malloc(*update_pin + update_step);
+			if (lock && !mlock(lock, *update_pin + update_step)) {
+				free(lock);
+				*update_pin += update_step;
+			} else {
+				/* If mlock() fails this fork will be killed
+				 * and flag state will not be changed but to
+				 * better understanding it is good to put it
+				 * here.
+				 */
+				flag = true;
+			}
+		} while (!flag);
+	}
+
+	__igt_waitchildren();
+	igt_require(*update_pin);
+
 	igt_fork(child, 1) {
 		void *locked;
 
-		locked = malloc(pin + sz);
-		if (locked != NULL && !mlock(locked, pin + sz))
+		locked = malloc(*update_pin);
+		if (locked && !mlock(locked, *update_pin)) {
 			*can_mlock = 1;
+			if (*update_pin >= pin + sz)
+				pin = *update_pin - sz;
+			else
+				exit(1);
+		}
 	}
+
 	igt_waitchildren();
+
 	igt_require(*can_mlock);
 	munmap(can_mlock, 4096);
+	munmap(update_pin, 4096);
 
 	igt_fork(child, 1) {
 		void *locked;
@@ -172,7 +210,7 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 		igt_assert(bo);
 
 		locked = malloc(pin);
-		if (locked == NULL || mlock(locked, pin))
+		if (!locked || mlock(locked, pin))
 			exit(ENOSPC);
 
 		for (n = 0; n < surface_count; n++)
@@ -190,8 +228,9 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 			 */
 
 			locked = malloc(surface_size);
-			if (locked == NULL || mlock(locked, surface_size))
+			if (!locked || mlock(locked, surface_size))
 				free(locked);
+
 		}
 
 		for (n = 0; n < surface_count; n++)
diff --git a/tests/gem_evict_everything.c b/tests/gem_evict_everything.c
index f3607648..9552a061 100644
--- a/tests/gem_evict_everything.c
+++ b/tests/gem_evict_everything.c
@@ -190,7 +190,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 
 		igt_fork_hang_detector(fd);
 	}
@@ -230,7 +230,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 	}
 
 	igt_fork_signal_helper();
@@ -261,7 +261,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 	}
 
 	igt_subtest("mlocked-hang")
-- 
2.14.4

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH i-g-t] tests/gem_evict_everything fix for mlocked-* subtests

[Chris Wilson]

Quoting Ewelina Musial (2018-06-07 14:21:41)
> Add check to avoid locking biggest mem size than is available.
> Trying to allocate size returned by intel_get_avail_ram_mb()
> triggers OOM killer. It looks like available RAM is not fully free
> so my idea is to decrease this size of 1024MB and before allocating
> increase mem size in loop till will be maximally big.
> 
> Also, changed surface_count. Few thousands of iterations is not
> necessary and is taking a lot of time. This change should cover
> previous functionality.
> 
> Using __igt_waitchildren() instead of igt_waitchildren() avoids
> failing test if OOM killer stops process run by igt_fork() (OOM killer
> is expected).
> 
> __igt_waitchildren() is implemented by Chris in other patch so this will
> be failing now. I will update this patch after merging his code :)
> 
> Signed-off-by: Ewelina Musial <ewelina.musial@intel.com>
> ---
>  tests/eviction_common.c      | 51 ++++++++++++++++++++++++++++++++++++++------
>  tests/gem_evict_everything.c |  6 +++---
>  2 files changed, 48 insertions(+), 9 deletions(-)
> 
> diff --git a/tests/eviction_common.c b/tests/eviction_common.c
> index 300eb03d..7ae48654 100644
> --- a/tests/eviction_common.c
> +++ b/tests/eviction_common.c
> @@ -134,14 +134,20 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
>                               uint64_t surface_count)
>  {
>         unsigned int *can_mlock;
> -       uint64_t sz, pin;
> +       uint64_t sz, pin, *update_pin = 0;
> +       bool flag = false;
>  
>         intel_require_memory(surface_count, surface_size, CHECK_RAM);
>  
>         sz = surface_size*surface_count;
> -       pin = intel_get_avail_ram_mb();
> +       pin = intel_get_avail_ram_mb() - 1024;
>         pin *= 1024 * 1024;
>         igt_require(pin > sz);
> +
> +       update_pin = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
> +       igt_assert(update_pin != MAP_FAILED);
> +       *update_pin = pin;
> +
>         pin -= sz;
>  
>         igt_debug("Pinning [%'lld, %'lld] MiB\n",
> @@ -151,16 +157,48 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
>         can_mlock = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
>         igt_assert(can_mlock != MAP_FAILED);
>  
> +       igt_fork(child, 1)
> +       {
> +               void *lock;
> +               uint64_t update_step = (5 << 22);

5 * 4 MiB

Any particular reason? Just curious.

We try to follow the kernel coding style (K&R braces, just the right
amount of brackets, and start multiline comments with
/*
 * Hello World!
 */)

> +
> +               do {
> +                       lock = malloc(*update_pin + update_step);
> +                       if (lock && !mlock(lock, *update_pin + update_step)) {
> +                               free(lock);
> +                               *update_pin += update_step;
> +                       } else {
> +                               /* If mlock() fails this fork will be killed
> +                                * and flag state will not be changed but to
> +                                * better understanding it is good to put it
> +                                * here.
> +                                */
> +                               flag = true;
> +                       }
> +               } while (!flag);
> +       }

flag is only used inside this loop; a separate process no less, so the
value set above doesn't reach here anyway.

You can kill flag entirely and make that a break; inside a
do { } while (1);

> +
> +       __igt_waitchildren();
> +       igt_require(*update_pin);
> +
>         igt_fork(child, 1) {
>                 void *locked;
>  
> -               locked = malloc(pin + sz);
> -               if (locked != NULL && !mlock(locked, pin + sz))
> +               locked = malloc(*update_pin);
> +               if (locked && !mlock(locked, *update_pin)) {
>                         *can_mlock = 1;
> +                       if (*update_pin >= pin + sz)
> +                               pin = *update_pin - sz;
> +                       else
> +                               exit(1);
> +               }
>         }
> +
>         igt_waitchildren();

I typically place the igt_waitchildren() tight against the igt_fork()
loop unless the code is very, very busy.

Overall, looks to be the same approach as the discovery mechanism I
used. So it should work so long as the kernel's oomkiller doesn't kill
everything on the system other than our child.
-Chris
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✗ Fi.CI.BAT: failure for tests/gem_evict_everything fix for mlocked-* subtests

[Patchwork]

== Series Details ==

Series: tests/gem_evict_everything fix for mlocked-* subtests
URL   : https://patchwork.freedesktop.org/series/44406/
State : failure

== Summary ==

IGT patchset build failed on latest successful build
d1a93aa7e1507de76c6c71be15931cc4b90111bb lib/igt_fb: Round to nearest when clamping rgb

ninja: Entering directory `build'
[1/338] Generating version.h with a custom command.
[2/206] Linking target tests/gem_evict_everything.
FAILED: tests/gem_evict_everything 
ccache cc  -o tests/gem_evict_everything 'tests/gem_evict_everything@exe/gem_evict_everything.c.o' -Wl,--no-undefined -Wl,--as-needed -Wl,--start-group lib/libigt.so -pthread -lcairo -lglib-2.0 -L/opt/igt/lib -ldrm -lkmod -lprocps -ludev -lunwind -lpciaccess -lm -lrt -L/opt/igt/lib -ldrm_intel -ldrm -lgsl -lgslcblas -lm -lpixman-1 -lpixman-1 -L/usr/lib/x86_64-linux-gnu -lxmlrpc_client -lxmlrpc -lxmlrpc_xmlparse -lxmlrpc_xmltok -lxmlrpc_util -lcurl -Wl,--end-group -ldrm_nouveau -lpixman-1 -L/usr/lib/x86_64-linux-gnu -lxmlrpc_client -lxmlrpc -lxmlrpc_xmlparse -lxmlrpc_xmltok -lxmlrpc_util -lcurl '-Wl,-rpath,$ORIGIN/../lib:XXXXXXXXXXXXXXXXXXXX' -Wl,-rpath-link,/home/cidrm/igt-gpu-tools/build/lib  
tests/gem_evict_everything@exe/gem_evict_everything.c.o: In function `mlocked_evictions':
/home/cidrm/igt-gpu-tools/build/../tests/eviction_common.c:181: undefined reference to `__igt_waitchildren'
collect2: error: ld returned 1 exit status
ninja: build stopped: subcommand failed.

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH i-g-t] tests/gem_evict_everything fix for mlocked-* subtests

[Ewelina Musial]

On Thu, Jun 07, 2018 at 03:07:31PM +0100, Chris Wilson wrote:
> Quoting Ewelina Musial (2018-06-07 14:21:41)
> > Add check to avoid locking biggest mem size than is available.
> > Trying to allocate size returned by intel_get_avail_ram_mb()
> > triggers OOM killer. It looks like available RAM is not fully free
> > so my idea is to decrease this size of 1024MB and before allocating
> > increase mem size in loop till will be maximally big.
> > 
> > Also, changed surface_count. Few thousands of iterations is not
> > necessary and is taking a lot of time. This change should cover
> > previous functionality.
> > 
> > Using __igt_waitchildren() instead of igt_waitchildren() avoids
> > failing test if OOM killer stops process run by igt_fork() (OOM killer
> > is expected).
> > 
> > __igt_waitchildren() is implemented by Chris in other patch so this will
> > be failing now. I will update this patch after merging his code :)
> > 
> > Signed-off-by: Ewelina Musial <ewelina.musial@intel.com>
> > ---
> >  tests/eviction_common.c      | 51 ++++++++++++++++++++++++++++++++++++++------
> >  tests/gem_evict_everything.c |  6 +++---
> >  2 files changed, 48 insertions(+), 9 deletions(-)
> > 
> > diff --git a/tests/eviction_common.c b/tests/eviction_common.c
> > index 300eb03d..7ae48654 100644
> > --- a/tests/eviction_common.c
> > +++ b/tests/eviction_common.c
> > @@ -134,14 +134,20 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
> >                               uint64_t surface_count)
> >  {
> >         unsigned int *can_mlock;
> > -       uint64_t sz, pin;
> > +       uint64_t sz, pin, *update_pin = 0;
> > +       bool flag = false;
> >  
> >         intel_require_memory(surface_count, surface_size, CHECK_RAM);
> >  
> >         sz = surface_size*surface_count;
> > -       pin = intel_get_avail_ram_mb();
> > +       pin = intel_get_avail_ram_mb() - 1024;
> >         pin *= 1024 * 1024;
> >         igt_require(pin > sz);
> > +
> > +       update_pin = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
> > +       igt_assert(update_pin != MAP_FAILED);
> > +       *update_pin = pin;
> > +
> >         pin -= sz;
> >  
> >         igt_debug("Pinning [%'lld, %'lld] MiB\n",
> > @@ -151,16 +157,48 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
> >         can_mlock = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
> >         igt_assert(can_mlock != MAP_FAILED);
> >  
> > +       igt_fork(child, 1)
> > +       {
> > +               void *lock;
> > +               uint64_t update_step = (5 << 22);
> 
> 5 * 4 MiB
> 
> Any particular reason? Just curious.

Not really, if that value is too small this process will take a loooong time,
if will be too big rest of test could loose sense so I just tried to choose
    some optimal one.
> 
> We try to follow the kernel coding style (K&R braces, just the right
> amount of brackets, and start multiline comments with
> /*
>  * Hello World!
>  */)
> 
You are right, thanks :)

> > +
> > +               do {
> > +                       lock = malloc(*update_pin + update_step);
> > +                       if (lock && !mlock(lock, *update_pin + update_step)) {
> > +                               free(lock);
> > +                               *update_pin += update_step;
> > +                       } else {
> > +                               /* If mlock() fails this fork will be killed
> > +                                * and flag state will not be changed but to
> > +                                * better understanding it is good to put it
> > +                                * here.
> > +                                */
> > +                               flag = true;
> > +                       }
> > +               } while (!flag);
> > +       }
> 
> flag is only used inside this loop; a separate process no less, so the
> value set above doesn't reach here anyway.
> 
> You can kill flag entirely and make that a break; inside a
> do { } while (1);

Sounds good, I will use your suggestion
> 
> > +
> > +       __igt_waitchildren();
> > +       igt_require(*update_pin);
> > +
> >         igt_fork(child, 1) {
> >                 void *locked;
> >  
> > -               locked = malloc(pin + sz);
> > -               if (locked != NULL && !mlock(locked, pin + sz))
> > +               locked = malloc(*update_pin);
> > +               if (locked && !mlock(locked, *update_pin)) {
> >                         *can_mlock = 1;
> > +                       if (*update_pin >= pin + sz)
> > +                               pin = *update_pin - sz;
> > +                       else
> > +                               exit(1);
> > +               }
> >         }
> > +
> >         igt_waitchildren();
> 
> I typically place the igt_waitchildren() tight against the igt_fork()
> loop unless the code is very, very busy.
> 
> Overall, looks to be the same approach as the discovery mechanism I
> used. So it should work so long as the kernel's oomkiller doesn't kill
> everything on the system other than our child.
> -Chris

-Ewelina
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [PATCH i-g-t v2] tests/gem_evict_everything fix for mlocked-* subtests

[Ewelina Musial]

Add check to avoid locking biggest mem size than is available.
Trying to allocate size returned by intel_get_avail_ram_mb()
triggers OOM killer. It looks like available RAM is not fully free
so my idea is to decrease this size of 1024MB and before allocating
increase mem size in loop till will be maximally big.

Also, changed surface_count. Few thousands of iterations is not
necessary and is taking a lot of time. This change should cover
previous functionality.

Using __igt_waitchildren() instead of igt_waitchildren() avoids
failing test if OOM killer stops process run by igt_fork() (OOM killer
is expected).

__igt_waitchildren() is implemented by Chris in other patch so this will
be failing now. I will update this patch after merging his code :)

v2: Remove flag variable and do some cosmetic changes (Chris)

References: https://bugs.freedesktop.org/show_bug.cgi?id=101857
Signed-off-by: Ewelina Musial <ewelina.musial@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Michal Winiarski <michal.winiarski@intel.com>
---
 tests/eviction_common.c      | 43 ++++++++++++++++++++++++++++++++++++-------
 tests/gem_evict_everything.c |  6 +++---
 2 files changed, 39 insertions(+), 10 deletions(-)

diff --git a/tests/eviction_common.c b/tests/eviction_common.c
index 300eb03d..b99cfae1 100644
--- a/tests/eviction_common.c
+++ b/tests/eviction_common.c
@@ -134,14 +134,19 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 			      uint64_t surface_count)
 {
 	unsigned int *can_mlock;
-	uint64_t sz, pin;
+	uint64_t sz, pin, *update_pin = 0;
 
 	intel_require_memory(surface_count, surface_size, CHECK_RAM);
 
 	sz = surface_size*surface_count;
-	pin = intel_get_avail_ram_mb();
+	pin = intel_get_avail_ram_mb() - 1024;
 	pin *= 1024 * 1024;
 	igt_require(pin > sz);
+
+	update_pin = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+	igt_assert(update_pin != MAP_FAILED);
+	*update_pin = pin;
+
 	pin -= sz;
 
 	igt_debug("Pinning [%'lld, %'lld] MiB\n",
@@ -151,16 +156,40 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 	can_mlock = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
 	igt_assert(can_mlock != MAP_FAILED);
 
+	igt_fork(child, 1)
+	{
+		void *lock;
+		uint64_t update_step = (5 << 22);
+
+		do {
+			lock = malloc(*update_pin + update_step);
+			if (lock && !mlock(lock, *update_pin + update_step)) {
+				free(lock);
+				*update_pin += update_step;
+			} 
+		} while (1);
+	}
+	__igt_waitchildren();
+
+	igt_require(*update_pin);
+
 	igt_fork(child, 1) {
 		void *locked;
 
-		locked = malloc(pin + sz);
-		if (locked != NULL && !mlock(locked, pin + sz))
+		locked = malloc(*update_pin);
+		if (locked && !mlock(locked, *update_pin)) {
 			*can_mlock = 1;
+			if (*update_pin >= pin + sz)
+				pin = *update_pin - sz;
+			else
+				exit(1);
+		}
 	}
 	igt_waitchildren();
+
 	igt_require(*can_mlock);
 	munmap(can_mlock, 4096);
+	munmap(update_pin, 4096);
 
 	igt_fork(child, 1) {
 		void *locked;
@@ -172,7 +201,7 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 		igt_assert(bo);
 
 		locked = malloc(pin);
-		if (locked == NULL || mlock(locked, pin))
+		if (!locked || mlock(locked, pin))
 			exit(ENOSPC);
 
 		for (n = 0; n < surface_count; n++)
@@ -190,14 +219,14 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 			 */
 
 			locked = malloc(surface_size);
-			if (locked == NULL || mlock(locked, surface_size))
+			if (!locked || mlock(locked, surface_size))
 				free(locked);
+
 		}
 
 		for (n = 0; n < surface_count; n++)
 			ops->close(fd, bo[n]);
 	}
-
 	igt_waitchildren();
 }
 
diff --git a/tests/gem_evict_everything.c b/tests/gem_evict_everything.c
index f3607648..9552a061 100644
--- a/tests/gem_evict_everything.c
+++ b/tests/gem_evict_everything.c
@@ -190,7 +190,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 
 		igt_fork_hang_detector(fd);
 	}
@@ -230,7 +230,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 	}
 
 	igt_fork_signal_helper();
@@ -261,7 +261,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 	}
 
 	igt_subtest("mlocked-hang")
-- 
2.14.4

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✗ Fi.CI.BAT: failure for tests/gem_evict_everything fix for mlocked-* subtests (rev2)

[Patchwork]

== Series Details ==

Series: tests/gem_evict_everything fix for mlocked-* subtests (rev2)
URL   : https://patchwork.freedesktop.org/series/44406/
State : failure

== Summary ==

IGT patchset build failed on latest successful build
093fa482371795c3aa246509994eb21907f501b9 tests/kms_plane: crc check plane pixel formats

ninja: Entering directory `build'
[1/338] Generating version.h with a custom command.
[2/195] Linking target tests/gem_evict_everything.
FAILED: tests/gem_evict_everything 
ccache cc  -o tests/gem_evict_everything 'tests/gem_evict_everything@exe/gem_evict_everything.c.o' -Wl,--no-undefined -Wl,--as-needed -Wl,--start-group lib/libigt.so -pthread -lcairo -lglib-2.0 -L/opt/igt/lib -ldrm -lkmod -lprocps -ludev -lunwind -lpciaccess -lm -lrt -L/opt/igt/lib -ldrm_intel -ldrm -lgsl -lgslcblas -lm -lpixman-1 -lpixman-1 -L/usr/lib/x86_64-linux-gnu -lxmlrpc_client -lxmlrpc -lxmlrpc_xmlparse -lxmlrpc_xmltok -lxmlrpc_util -lcurl -Wl,--end-group -ldrm_nouveau -lpixman-1 -L/usr/lib/x86_64-linux-gnu -lxmlrpc_client -lxmlrpc -lxmlrpc_xmlparse -lxmlrpc_xmltok -lxmlrpc_util -lcurl '-Wl,-rpath,$ORIGIN/../lib:XXXXXXXXXXXXXXXXXXXX' -Wl,-rpath-link,/home/cidrm/igt-gpu-tools/build/lib  
tests/gem_evict_everything@exe/gem_evict_everything.c.o: In function `mlocked_evictions':
/home/cidrm/igt-gpu-tools/build/../tests/eviction_common.c:172: undefined reference to `__igt_waitchildren'
collect2: error: ld returned 1 exit status
ninja: build stopped: subcommand failed.

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [PATCH i-g-t v3] tests/gem_evict_everything fix for mlocked-* subtests

[Ewelina Musial]

Add check to avoid locking biggest mem size than is available.
Trying to allocate size returned by intel_get_avail_ram_mb()
triggers OOM killer. It looks like available RAM is not fully free
so my idea is to decrease this size of 1024MB and before allocating
increase mem size in loop till will be maximally big.

Also, changed surface_count. Few thousands of iterations is not
necessary and is taking a lot of time. This change should cover
previous functionality.

Using __igt_waitchildren() instead of igt_waitchildren() avoids
failing test if OOM killer stops process run by igt_fork() (OOM killer
is expected).

v2: Remove flag variable and do some cosmetic changes (Chris)

v3: Rebase after merging __igt_waitchildren() functionality

References: https://bugs.freedesktop.org/show_bug.cgi?id=101857
Signed-off-by: Ewelina Musial <ewelina.musial@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Michal Winiarski <michal.winiarski@intel.com>
---
 tests/eviction_common.c      | 43 ++++++++++++++++++++++++++++++++++++-------
 tests/gem_evict_everything.c |  6 +++---
 2 files changed, 39 insertions(+), 10 deletions(-)

diff --git a/tests/eviction_common.c b/tests/eviction_common.c
index 300eb03d..8982865a 100644
--- a/tests/eviction_common.c
+++ b/tests/eviction_common.c
@@ -134,14 +134,19 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 			      uint64_t surface_count)
 {
 	unsigned int *can_mlock;
-	uint64_t sz, pin;
+	uint64_t sz, pin, *update_pin = 0;
 
 	intel_require_memory(surface_count, surface_size, CHECK_RAM);
 
 	sz = surface_size*surface_count;
-	pin = intel_get_avail_ram_mb();
+	pin = intel_get_avail_ram_mb() - 1024;
 	pin *= 1024 * 1024;
 	igt_require(pin > sz);
+
+	update_pin = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+	igt_assert(update_pin != MAP_FAILED);
+	*update_pin = pin;
+
 	pin -= sz;
 
 	igt_debug("Pinning [%'lld, %'lld] MiB\n",
@@ -151,16 +156,40 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 	can_mlock = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
 	igt_assert(can_mlock != MAP_FAILED);
 
+	igt_fork(child, 1)
+	{
+		void *lock;
+		uint64_t update_step = (5 << 22);
+
+		do {
+			lock = malloc(*update_pin + update_step);
+			if (lock && !mlock(lock, *update_pin + update_step)) {
+				free(lock);
+				*update_pin += update_step;
+			}
+		} while (1);
+	}
+	__igt_waitchildren();
+
+	igt_require(*update_pin);
+
 	igt_fork(child, 1) {
 		void *locked;
 
-		locked = malloc(pin + sz);
-		if (locked != NULL && !mlock(locked, pin + sz))
+		locked = malloc(*update_pin);
+		if (locked && !mlock(locked, *update_pin)) {
 			*can_mlock = 1;
+			if (*update_pin >= pin + sz)
+				pin = *update_pin - sz;
+			else
+				exit(1);
+		}
 	}
 	igt_waitchildren();
+
 	igt_require(*can_mlock);
 	munmap(can_mlock, 4096);
+	munmap(update_pin, 4096);
 
 	igt_fork(child, 1) {
 		void *locked;
@@ -172,7 +201,7 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 		igt_assert(bo);
 
 		locked = malloc(pin);
-		if (locked == NULL || mlock(locked, pin))
+		if (!locked || mlock(locked, pin))
 			exit(ENOSPC);
 
 		for (n = 0; n < surface_count; n++)
@@ -190,14 +219,14 @@ static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
 			 */
 
 			locked = malloc(surface_size);
-			if (locked == NULL || mlock(locked, surface_size))
+			if (!locked || mlock(locked, surface_size))
 				free(locked);
+
 		}
 
 		for (n = 0; n < surface_count; n++)
 			ops->close(fd, bo[n]);
 	}
-
 	igt_waitchildren();
 }
 
diff --git a/tests/gem_evict_everything.c b/tests/gem_evict_everything.c
index f3607648..9552a061 100644
--- a/tests/gem_evict_everything.c
+++ b/tests/gem_evict_everything.c
@@ -190,7 +190,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 
 		igt_fork_hang_detector(fd);
 	}
@@ -230,7 +230,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 	}
 
 	igt_fork_signal_helper();
@@ -261,7 +261,7 @@ igt_main
 		count = gem_aperture_size(fd);
 		if (count >> 32)
 			count = MAX_32b;
-		count = 3 * count / size / 4;
+		count = count / size / 4;
 	}
 
 	igt_subtest("mlocked-hang")
-- 
2.14.4

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✗ Fi.CI.BAT: failure for tests/gem_evict_everything fix for mlocked-* subtests (rev3)

[Patchwork]

== Series Details ==

Series: tests/gem_evict_everything fix for mlocked-* subtests (rev3)
URL   : https://patchwork.freedesktop.org/series/44406/
State : failure

== Summary ==

IGT patchset build failed on latest successful build
7b6838781441cfbc7f6c18f421f127dfb02b44cf igt/drv_suspend: Suspend under memory pressure

The Meson build system
Version: 0.45.1
Source dir: /home/cidrm/igt-gpu-tools
Build dir: /home/cidrm/igt-gpu-tools/build
Build type: native build
Project name: igt-gpu-tools
Native C compiler: ccache cc (gcc 7.3.0 "cc (Ubuntu 7.3.0-16ubuntu3) 7.3.0")
Appending CPPFLAGS from environment: '-I/home/cidrm/kernel_headers/include'
Build machine cpu family: x86_64
Build machine cpu: x86_64
Compiler for C supports argument -Wno-unused-parameter: YES
Compiler for C supports argument -Wno-sign-compare: YES
Compiler for C supports argument -Wno-missing-field-initializers: YES
Compiler for C supports argument -Wno-clobbered: YES
Compiler for C supports argument -Wno-type-limits: YES
Compiler for C supports argument -Wimplicit-fallthrough=0: YES
Found pkg-config: /usr/bin/pkg-config (0.29.1)
Native dependency libdrm found: YES 2.4.92
Native dependency libdrm_intel found: YES 2.4.92
Native dependency libdrm_nouveau found: YES 2.4.91
Native dependency libdrm_amdgpu found: YES 2.4.91
Native dependency pciaccess found: YES 0.14
Native dependency libkmod found: YES 24
Native dependency libprocps found: YES 3.3.12

meson.build:44:0: ERROR: Native dependency 'libunwind' not found

A full log can be found at /home/cidrm/igt-gpu-tools/build/meson-logs/meson-log.txt

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.BAT: success for tests/gem_evict_everything fix for mlocked-* subtests (rev3)

[Patchwork]

== Series Details ==

Series: tests/gem_evict_everything fix for mlocked-* subtests (rev3)
URL   : https://patchwork.freedesktop.org/series/44406/
State : success

== Summary ==

= CI Bug Log - changes from CI_DRM_4302 -> IGTPW_1444 =

== Summary - WARNING ==

  Minor unknown changes coming with IGTPW_1444 need to be verified
  manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_1444, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://patchwork.freedesktop.org/api/1.0/series/44406/revisions/3/mbox/

== Possible new issues ==

  Here are the unknown changes that may have been introduced in IGTPW_1444:

  === IGT changes ===

    ==== Warnings ====

    igt@gem_exec_gttfill@basic:
      fi-pnv-d510:        SKIP -> PASS

    igt@gem_mmap_gtt@basic-small-bo-tiledy:
      fi-gdg-551:         PASS -> SKIP

    
== Known issues ==

  Here are the changes found in IGTPW_1444 that come from known issues:

  === IGT changes ===

    ==== Issues hit ====

    igt@gem_exec_suspend@basic-s3:
      fi-skl-gvtdvm:      NOTRUN -> INCOMPLETE (fdo#105600, fdo#104108)

    igt@kms_frontbuffer_tracking@basic:
      fi-hsw-peppy:       PASS -> DMESG-FAIL (fdo#106103, fdo#102614)

    igt@prime_vgem@basic-fence-read:
      fi-glk-j4005:       PASS -> DMESG-WARN (fdo#106000)

    
    ==== Possible fixes ====

    igt@gem_mmap_gtt@basic-small-bo-tiledx:
      fi-gdg-551:         FAIL (fdo#102575) -> SKIP

    igt@kms_pipe_crc_basic@read-crc-pipe-b-frame-sequence:
      fi-glk-j4005:       FAIL (fdo#103481) -> PASS

    igt@kms_pipe_crc_basic@read-crc-pipe-c:
      fi-glk-j4005:       DMESG-WARN (fdo#106000, fdo#106097) -> PASS

    igt@kms_pipe_crc_basic@suspend-read-crc-pipe-b:
      fi-cnl-psr:         DMESG-WARN (fdo#104951) -> PASS

    
  fdo#102575 https://bugs.freedesktop.org/show_bug.cgi?id=102575
  fdo#102614 https://bugs.freedesktop.org/show_bug.cgi?id=102614
  fdo#103481 https://bugs.freedesktop.org/show_bug.cgi?id=103481
  fdo#104108 https://bugs.freedesktop.org/show_bug.cgi?id=104108
  fdo#104951 https://bugs.freedesktop.org/show_bug.cgi?id=104951
  fdo#105600 https://bugs.freedesktop.org/show_bug.cgi?id=105600
  fdo#106000 https://bugs.freedesktop.org/show_bug.cgi?id=106000
  fdo#106097 https://bugs.freedesktop.org/show_bug.cgi?id=106097
  fdo#106103 https://bugs.freedesktop.org/show_bug.cgi?id=106103


== Participating hosts (41 -> 38) ==

  Additional (2): fi-bdw-gvtdvm fi-skl-gvtdvm 
  Missing    (5): fi-ctg-p8600 fi-ilk-m540 fi-byt-squawks fi-bsw-cyan fi-skl-6700hq 


== Build changes ==

    * IGT: IGT_4513 -> IGTPW_1444

  CI_DRM_4302: ef129f260b2bd362959651fe8e20e369bf3c977e @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_1444: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1444/
  IGT_4513: 7b6838781441cfbc7f6c18f421f127dfb02b44cf @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1444/issues.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.IGT: success for tests/gem_evict_everything fix for mlocked-* subtests (rev3)

[Patchwork]

== Series Details ==

Series: tests/gem_evict_everything fix for mlocked-* subtests (rev3)
URL   : https://patchwork.freedesktop.org/series/44406/
State : success

== Summary ==

= CI Bug Log - changes from IGT_4513_full -> IGTPW_1444_full =

== Summary - WARNING ==

  Minor unknown changes coming with IGTPW_1444_full need to be verified
  manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_1444_full, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://patchwork.freedesktop.org/api/1.0/series/44406/revisions/3/mbox/

== Possible new issues ==

  Here are the unknown changes that may have been introduced in IGTPW_1444_full:

  === IGT changes ===

    ==== Warnings ====

    igt@gem_exec_schedule@deep-blt:
      shard-kbl:          SKIP -> PASS +1

    igt@gem_mocs_settings@mocs-rc6-vebox:
      shard-kbl:          PASS -> SKIP

    igt@pm_rc6_residency@rc6-accuracy:
      shard-snb:          PASS -> SKIP

    
== Known issues ==

  Here are the changes found in IGTPW_1444_full that come from known issues:

  === IGT changes ===

    ==== Issues hit ====

    igt@gem_render_linear_blits@basic:
      shard-snb:          PASS -> INCOMPLETE (fdo#105411)

    igt@kms_atomic_transition@1x-modeset-transitions-nonblocking:
      shard-glk:          PASS -> FAIL (fdo#105703)

    igt@kms_flip@2x-flip-vs-expired-vblank-interruptible:
      shard-glk:          PASS -> FAIL (fdo#105189)

    igt@kms_flip@plain-flip-ts-check-interruptible:
      shard-glk:          PASS -> FAIL (fdo#100368)

    igt@kms_flip_tiling@flip-to-y-tiled:
      shard-glk:          PASS -> FAIL (fdo#103822, fdo#104724) +1

    igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-mmap-wc:
      shard-glk:          PASS -> FAIL (fdo#103167, fdo#104724)

    igt@kms_setmode@basic:
      shard-apl:          PASS -> FAIL (fdo#99912)

    
    ==== Possible fixes ====

    igt@drv_suspend@shrink:
      shard-glk:          INCOMPLETE (k.org#198133, fdo#103359) -> PASS

    igt@gem_exec_big:
      shard-hsw:          INCOMPLETE (fdo#103540) -> PASS

    igt@kms_cursor_legacy@2x-nonblocking-modeset-vs-cursor-atomic:
      shard-glk:          FAIL (fdo#106509, fdo#105454) -> PASS

    igt@kms_flip@2x-flip-vs-blocking-wf-vblank:
      shard-glk:          FAIL (fdo#100368) -> PASS

    igt@kms_flip@plain-flip-ts-check:
      shard-hsw:          FAIL (fdo#100368) -> PASS

    igt@kms_flip_tiling@flip-x-tiled:
      shard-glk:          FAIL (fdo#104724) -> PASS

    igt@kms_rotation_crc@sprite-rotation-180:
      shard-snb:          FAIL (fdo#103925, fdo#104724) -> PASS +1

    igt@perf@polling:
      shard-hsw:          FAIL (fdo#102252) -> PASS

    
    ==== Warnings ====

    igt@gem_eio@suspend:
      shard-snb:          FAIL (fdo#105957) -> DMESG-FAIL (fdo#106808)

    
  fdo#100368 https://bugs.freedesktop.org/show_bug.cgi?id=100368
  fdo#102252 https://bugs.freedesktop.org/show_bug.cgi?id=102252
  fdo#103167 https://bugs.freedesktop.org/show_bug.cgi?id=103167
  fdo#103359 https://bugs.freedesktop.org/show_bug.cgi?id=103359
  fdo#103540 https://bugs.freedesktop.org/show_bug.cgi?id=103540
  fdo#103822 https://bugs.freedesktop.org/show_bug.cgi?id=103822
  fdo#103925 https://bugs.freedesktop.org/show_bug.cgi?id=103925
  fdo#104724 https://bugs.freedesktop.org/show_bug.cgi?id=104724
  fdo#105189 https://bugs.freedesktop.org/show_bug.cgi?id=105189
  fdo#105411 https://bugs.freedesktop.org/show_bug.cgi?id=105411
  fdo#105454 https://bugs.freedesktop.org/show_bug.cgi?id=105454
  fdo#105703 https://bugs.freedesktop.org/show_bug.cgi?id=105703
  fdo#105957 https://bugs.freedesktop.org/show_bug.cgi?id=105957
  fdo#106509 https://bugs.freedesktop.org/show_bug.cgi?id=106509
  fdo#106808 https://bugs.freedesktop.org/show_bug.cgi?id=106808
  fdo#99912 https://bugs.freedesktop.org/show_bug.cgi?id=99912
  k.org#198133 https://bugzilla.kernel.org/show_bug.cgi?id=198133


== Participating hosts (5 -> 5) ==

  No changes in participating hosts


== Build changes ==

    * IGT: IGT_4513 -> IGTPW_1444
    * Linux: CI_DRM_4294 -> CI_DRM_4302

  CI_DRM_4294: af0889384edc6de2f91494325d571c66dffea83f @ git://anongit.freedesktop.org/gfx-ci/linux
  CI_DRM_4302: ef129f260b2bd362959651fe8e20e369bf3c977e @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_1444: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1444/
  IGT_4513: 7b6838781441cfbc7f6c18f421f127dfb02b44cf @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1444/shards.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev