From: Brian Starkey <brian.star...@arm.com>

To use writeback buffers as a CRC source, we need to be able to hash
them. Implement a simple FVA-1a hashing routine for this purpose.
Doing a bytewise hash on the framebuffer directly can be very slow if
the memory is noncached. By making a copy of each line in the FB first
(which can take advantage of word-access speedup), we can do the hash
on a cached copy, which is much faster (10x speedup on my platform).

v6: use igt_memcpy_from_wc() instead of plain memcpy, as suggested by
    Chris Wilson

Signed-off-by: Brian Starkey <brian.star...@arm.com>
[rebased and updated to the most recent API]
Signed-off-by: Liviu Dudau <liviu.du...@arm.com>
---
 lib/igt_fb.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_fb.h |  3 +++
 2 files changed, 69 insertions(+)

diff --git a/lib/igt_fb.c b/lib/igt_fb.c
index 5cd1829a3..044fd57de 100644
--- a/lib/igt_fb.c
+++ b/lib/igt_fb.c
@@ -2379,6 +2379,72 @@ bool igt_fb_supported_format(uint32_t drm_format)
        return false;
 }
 
+/*
+ * This implements the FNV-1a hashing algorithm instead of CRC, for
+ * simplicity
+ * http://www.isthe.com/chongo/tech/comp/fnv/index.html
+ *
+ * hash = offset_basis
+ * for each octet_of_data to be hashed
+ *         hash = hash xor octet_of_data
+ *         hash = hash * FNV_prime
+ * return hash
+ *
+ * 32 bit offset_basis = 2166136261
+ * 32 bit FNV_prime = 224 + 28 + 0x93 = 16777619
+ */
+int igt_fb_get_crc(struct igt_fb *fb, igt_crc_t *crc)
+{
+#define FNV1a_OFFSET_BIAS 2166136261
+#define FNV1a_PRIME 16777619
+       uint32_t hash;
+       void *map;
+       char *ptr, *line = NULL;
+       int x, y, cpp = igt_drm_format_to_bpp(fb->drm_format) / 8;
+       uint32_t stride = calc_plane_stride(fb, 0);
+
+       if (fb->is_dumb)
+               map = kmstest_dumb_map_buffer(fb->fd, fb->gem_handle, fb->size,
+                                             PROT_READ);
+       else
+               map = gem_mmap__gtt(fb->fd, fb->gem_handle, fb->size,
+                                   PROT_READ);
+       ptr = map;
+
+       /*
+        * Framebuffers are often uncached, which can make byte-wise accesses
+        * very slow. We copy each line of the FB into a local buffer to speed
+        * up the hashing.
+        */
+       line = malloc(stride);
+       if (!line) {
+               munmap(map, fb->size);
+               return -ENOMEM;
+       }
+
+       hash = FNV1a_OFFSET_BIAS;
+
+       for (y = 0; y < fb->height; y++, ptr += stride) {
+
+               igt_memcpy_from_wc(line, ptr, stride);
+
+               for (x = 0; x < fb->width * cpp; x++) {
+                       hash ^= line[x];
+                       hash *= FNV1a_PRIME;
+               }
+       }
+
+       crc->n_words = 1;
+       crc->crc[0] = hash;
+
+       free(line);
+       munmap(map, fb->size);
+
+       return 0;
+#undef FNV1a_OFFSET_BIAS
+#undef FNV1a_PRIME
+}
+
 /**
  * igt_format_is_yuv:
  * @drm_format: drm fourcc
diff --git a/lib/igt_fb.h b/lib/igt_fb.h
index 9f027deba..948c5380c 100644
--- a/lib/igt_fb.h
+++ b/lib/igt_fb.h
@@ -37,6 +37,7 @@
 #include <i915_drm.h>
 
 #include "igt_color_encoding.h"
+#include "igt_debugfs.h"
 
 /**
  * igt_fb_t:
@@ -173,5 +174,7 @@ const char *igt_format_str(uint32_t drm_format);
 bool igt_fb_supported_format(uint32_t drm_format);
 bool igt_format_is_yuv(uint32_t drm_format);
 
+int igt_fb_get_crc(struct igt_fb *fb, igt_crc_t *crc);
+
 #endif /* __IGT_FB_H__ */
 
-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reply via email to