flywithu/ntel-gpu-tools
1
0
Fork 0
mirror of https://github.com/tiagovignatti/intel-gpu-tools.git synced 2025-06-09 00:46:17 +00:00
Code Issues Releases Wiki Activity

tests/gem_userptr_blits: Polish

Browse Source 
- Drop return values for test functions - we rely on the implicit
  control flow from igt_ checks.
- Don't use assert directly, this upsets the test flow logic (and
  results in a CRASH result instead of FAIL).

Cc: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
This commit is contained in:
Daniel Vetter 2014-07-15 10:12:55 +02:00
parent abbfecb015
commit 43784baa13
1 changed files with 19 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
tests/gem_userptr_blits.c
View File

@ -42,7 +42,6 @@
#include <fcntl.h> #include <fcntl.h>
#include <inttypes.h> #include <inttypes.h>
#include <errno.h> #include <errno.h>
#include <assert.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/time.h> #include <sys/time.h>
#include <sys/mman.h> #include <sys/mman.h>
@ -442,7 +441,7 @@ static int has_userptr(int fd)
uint32_t oldflags; uint32_t oldflags;
int ret; int ret;
assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0); igt_assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
oldflags = userptr_flags; oldflags = userptr_flags;
gem_userptr_test_unsynchronized(); gem_userptr_test_unsynchronized();
ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle); ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
@ -530,9 +529,9 @@ static int test_invalid_mapping(int fd)
ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE); ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
if (ptr == NULL) if (ptr == NULL)
gem_close(fd, handle); gem_close(fd, handle);
assert(ptr != NULL); igt_assert(ptr != NULL);
assert(((unsigned long)ptr & (PAGE_SIZE - 1)) == 0); igt_assert(((unsigned long)ptr & (PAGE_SIZE - 1)) == 0);
assert((sizeof(linear) & (PAGE_SIZE - 1)) == 0); igt_assert((sizeof(linear) & (PAGE_SIZE - 1)) == 0);
ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle2); ret = gem_userptr(fd, ptr, sizeof(linear), 0, &handle2);
igt_assert(ret == 0); igt_assert(ret == 0);
copy(fd, handle, handle, ~0); /* QQQ Precise errno? */ copy(fd, handle, handle, ~0); /* QQQ Precise errno? */
@ -601,7 +600,7 @@ static int test_forbidden_ops(int fd)
struct drm_i915_gem_pread gem_pread; struct drm_i915_gem_pread gem_pread;
struct drm_i915_gem_pwrite gem_pwrite; struct drm_i915_gem_pwrite gem_pwrite;
assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0); igt_assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE) == 0);
ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle); ret = gem_userptr(fd, ptr, PAGE_SIZE, 0, &handle);
igt_assert(ret == 0); igt_assert(ret == 0);
@ -716,7 +715,7 @@ static void sigbus(int sig, siginfo_t *info, void *param)
if (orig_sigbus) if (orig_sigbus)
orig_sigbus(sig, info, param); orig_sigbus(sig, info, param);
assert(0); igt_assert(0);
} }
static int test_dmabuf(void) static int test_dmabuf(void)
@ -763,15 +762,15 @@ static int test_dmabuf(void)
sigact.sa_sigaction = sigbus; sigact.sa_sigaction = sigbus;
sigact.sa_flags = SA_SIGINFO; sigact.sa_flags = SA_SIGINFO;
ret = sigaction(SIGBUS, &sigact, &orig_sigact); ret = sigaction(SIGBUS, &sigact, &orig_sigact);
assert(ret == 0); igt_assert(ret == 0);
orig_sigbus = orig_sigact.sa_sigaction; orig_sigbus = orig_sigact.sa_sigaction;
sigbus_cnt = 0; sigbus_cnt = 0;
check_bo(fd2, handle_import1, 0, fd2, handle_import1); check_bo(fd2, handle_import1, 0, fd2, handle_import1);
assert(sigbus_cnt > 0); igt_assert(sigbus_cnt > 0);
sigact.sa_sigaction = orig_sigbus; sigact.sa_sigaction = orig_sigbus;
sigact.sa_flags = SA_SIGINFO; sigact.sa_flags = SA_SIGINFO;
ret = sigaction(SIGBUS, &sigact, &orig_sigact); ret = sigaction(SIGBUS, &sigact, &orig_sigact);
assert(ret == 0); igt_assert(ret == 0);
gem_close(fd2, handle_import1); gem_close(fd2, handle_import1);
close(fd1); close(fd1);
@ -788,7 +787,7 @@ static int test_usage_restrictions(int fd)
int ret; int ret;
uint32_t handle; uint32_t handle;
assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE * 2) == 0); igt_assert(posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE * 2) == 0);
/* Address not aligned. */ /* Address not aligned. */
ret = gem_userptr(fd, (char *)ptr + 1, PAGE_SIZE, 0, &handle); ret = gem_userptr(fd, (char *)ptr + 1, PAGE_SIZE, 0, &handle);
@ -987,7 +986,7 @@ static void test_major_evictions(int fd, int size, int count)
major_evictions(fd, &fault_ops, size, count); major_evictions(fd, &fault_ops, size, count);
} }
static int test_overlap(int fd, int expected) static void test_overlap(int fd, int expected)
{ {
char *ptr; char *ptr;
int ret; int ret;
@ -1023,11 +1022,9 @@ static int test_overlap(int fd, int expected)
gem_close(fd, handle); gem_close(fd, handle);
free(ptr); free(ptr);
return 0;
} }
static int test_unmap(int fd, int expected) static void test_unmap(int fd, int expected)
{ {
char *ptr, *bo_ptr; char *ptr, *bo_ptr;
const unsigned int num_obj = 3; const unsigned int num_obj = 3;
@ -1038,7 +1035,7 @@ static int test_unmap(int fd, int expected)
ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE, ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
assert(ptr != MAP_FAILED); igt_assert(ptr != MAP_FAILED);
bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE); bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
@ -1053,18 +1050,16 @@ static int test_unmap(int fd, int expected)
copy(fd, bo[num_obj], bo[i], 0); copy(fd, bo[num_obj], bo[i], 0);
ret = munmap(ptr, map_size); ret = munmap(ptr, map_size);
assert(ret == 0); igt_assert(ret == 0);
for (i = 0; i < num_obj; i++) for (i = 0; i < num_obj; i++)
copy(fd, bo[num_obj], bo[i], expected); copy(fd, bo[num_obj], bo[i], expected);
for (i = 0; i < (num_obj + 1); i++) for (i = 0; i < (num_obj + 1); i++)
gem_close(fd, bo[i]); gem_close(fd, bo[i]);
return 0;
} }
static int test_unmap_after_close(int fd) static void test_unmap_after_close(int fd)
{ {
char *ptr, *bo_ptr; char *ptr, *bo_ptr;
const unsigned int num_obj = 3; const unsigned int num_obj = 3;
@ -1075,7 +1070,7 @@ static int test_unmap_after_close(int fd)
ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE, ptr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
assert(ptr != MAP_FAILED); igt_assert(ptr != MAP_FAILED);
bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE); bo_ptr = (char *)ALIGN((unsigned long)ptr, PAGE_SIZE);
@ -1093,19 +1088,15 @@ static int test_unmap_after_close(int fd)
gem_close(fd, bo[i]); gem_close(fd, bo[i]);
ret = munmap(ptr, map_size); ret = munmap(ptr, map_size);
assert(ret == 0); igt_assert(ret == 0);
return 0;
} }
static int test_unmap_cycles(int fd, int expected) static void test_unmap_cycles(int fd, int expected)
{ {
int i; int i;
for (i = 0; i < 1000; i++) for (i = 0; i < 1000; i++)
test_unmap(fd, expected); test_unmap(fd, expected);
return 0;
} }
static void *mm_stress_thread(void *data) static void *mm_stress_thread(void *data)
@ -1125,7 +1116,7 @@ static void *mm_stress_thread(void *data)
return NULL; return NULL;
} }
static int test_stress_mm(int fd) static void test_stress_mm(int fd)
{ {
int ret; int ret;
pthread_t t; pthread_t t;
@ -1151,8 +1142,6 @@ static int test_stress_mm(int fd)
igt_assert(ret == 0); igt_assert(ret == 0);
ret = pthread_join(t, NULL); ret = pthread_join(t, NULL);
igt_assert(ret == 0); igt_assert(ret == 0);
return 0;
} }
unsigned int total_ram; unsigned int total_ram;