diff --git a/test/stress-test.c b/test/stress-test.c index 1f03c75..4a2c2a9 100644 --- a/test/stress-test.c +++ b/test/stress-test.c @@ -254,15 +254,24 @@ create_random_bits_image (alpha_preference_t alpha_preference) indexed = NULL; if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_COLOR) { - indexed = malloc (sizeof (pixman_indexed_t)); + indexed = (pixman_indexed_t *)malloc (sizeof (pixman_indexed_t)); - initialize_palette (indexed, PIXMAN_FORMAT_BPP (format), TRUE); + if (initialize_palette (indexed, PIXMAN_FORMAT_BPP (format), TRUE) == FALSE) + { + free (indexed); + return NULL; + } } else if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_GRAY) { - indexed = malloc (sizeof (pixman_indexed_t)); + indexed = (pixman_indexed_t *)malloc (sizeof (pixman_indexed_t)); + + if (initialize_palette (indexed, PIXMAN_FORMAT_BPP (format), FALSE) == FALSE) - initialize_palette (indexed, PIXMAN_FORMAT_BPP (format), FALSE); + { + free (indexed); + return NULL; + } } else { @@ -304,7 +313,7 @@ create_random_bits_image (alpha_preference_t alpha_preference) case 2: /* Zero-filled */ stride = width * PIXMAN_FORMAT_BPP (format) + prng_rand_n (17); stride = (stride + 3) & (~3); - bits = fence_malloc (height * stride); + bits = (uint32_t *)fence_malloc (height * stride); if (!bits) return NULL; memset (bits, 0, height * stride); @@ -313,7 +322,7 @@ create_random_bits_image (alpha_preference_t alpha_preference) case 3: /* Filled with 0xFF */ stride = width * PIXMAN_FORMAT_BPP (format) + prng_rand_n (17); stride = (stride + 3) & (~3); - bits = fence_malloc (height * stride); + bits = (uint32_t *)fence_malloc (height * stride); if (!bits) return NULL; memset (bits, 0xff, height * stride); @@ -321,7 +330,7 @@ create_random_bits_image (alpha_preference_t alpha_preference) case 4: /* bits is a bad pointer, has read/write functions */ stride = 232; - bits = (void *)0x01; + bits = (uint32_t *)0x01; read_func = fake_reader; write_func = fake_writer; break; @@ -329,7 +338,7 @@ create_random_bits_image (alpha_preference_t alpha_preference) case 5: /* bits is a real pointer, has read/write functions */ stride = width * PIXMAN_FORMAT_BPP (format) + prng_rand_n (17); stride = (stride + 3) & (~3); - bits = fence_malloc (height * stride); + bits = (uint32_t *)fence_malloc (height * stride); if (!bits) return NULL; memset (bits, 0xff, height * stride); @@ -356,7 +365,7 @@ create_random_bits_image (alpha_preference_t alpha_preference) int height = prng_rand_n (4); n_coefficients = width * height + 2; - coefficients = malloc (n_coefficients * sizeof (pixman_fixed_t)); + coefficients = (pixman_fixed_t *)malloc (n_coefficients * sizeof (pixman_fixed_t)); if (coefficients) { @@ -377,12 +386,16 @@ create_random_bits_image (alpha_preference_t alpha_preference) /* Finally create the image */ image = pixman_image_create_bits (format, width, height, bits, stride); if (!image) + { + free (coefficients); return NULL; + } pixman_image_set_indexed (image, indexed); pixman_image_set_destroy_function (image, destroy, indexed); pixman_image_set_accessors (image, read_func, write_func); pixman_image_set_filter (image, filter, coefficients, n_coefficients); + free (coefficients); return image; } @@ -614,7 +627,7 @@ create_random_stops (int *n_stops) step = pixman_fixed_1 / *n_stops; - stops = malloc (*n_stops * sizeof (pixman_gradient_stop_t)); + stops = (pixman_gradient_stop_t *)malloc (*n_stops * sizeof (pixman_gradient_stop_t)); s = 0; for (i = 0; i < (*n_stops) - 1; ++i) @@ -767,7 +780,7 @@ create_random_trapezoids (int *n_traps, int height, int width) *n_traps = prng_rand_n (16) + 1; - trapezoids = malloc (sizeof (pixman_trapezoid_t) * *n_traps); + trapezoids = (pixman_trapezoid_t *)malloc (sizeof (pixman_trapezoid_t) * *n_traps); for (i = 0; i < *n_traps; ++i) { @@ -844,26 +857,24 @@ static const pixman_op_t op_list[] = }; static void -run_test (uint32_t seed, pixman_bool_t verbose, uint32_t mod) +run_test (const uint8_t *data, size_t size) { pixman_image_t *source, *mask, *dest; pixman_op_t op; - if (verbose) - { - if (mod == 0 || (seed % mod) == 0) - printf ("Seed 0x%08x\n", seed); - } - source = mask = dest = NULL; - prng_srand (seed); + random_data = data; + size_data = size; + running_data = 0; + + prng_srand (0xFFFFFFFF); - if (prng_rand_n (8) == 0) + if (prng_rand_n (2) == 0) { int n_traps; pixman_trapezoid_t *trapezoids; - int p = prng_rand_n (3); + int p = prng_rand_n (2); if (p == 0) dest = create_random_bits_image (DONT_CARE); @@ -944,97 +955,44 @@ out: pixman_image_unref (dest); } -static pixman_bool_t -get_int (char *s, uint32_t *i) -{ - char *end; - int p; - - p = strtol (s, &end, 0); - - if (end != s && *end == 0) - { - *i = p; - return TRUE; - } - return FALSE; -} int main (int argc, char **argv) { - int verbose = FALSE; - uint32_t seed = 1; - uint32_t n_tests = 8000; - uint32_t mod = 0; - pixman_bool_t use_threads = TRUE; - int32_t i; - - pixman_disable_out_of_bounds_workaround (); - - enable_divbyzero_exceptions(); + FILE *file; + uint8_t *buffer; + size_t fileLen; - if (getenv ("VERBOSE") != NULL) - verbose = TRUE; - - for (i = 1; i < argc; ++i) + printf("%s\n", argv[1]); + file = fopen(argv[1], "rb"); + if (!file) { - if (strcmp (argv[i], "-v") == 0) - { - verbose = TRUE; - - if (i + 1 < argc) - { - get_int (argv[i + 1], &mod); - i++; - } - } - else if (strcmp (argv[i], "-s") == 0 && i + 1 < argc) - { - get_int (argv[i + 1], &seed); - use_threads = FALSE; - i++; - } - else if (strcmp (argv[i], "-n") == 0 && i + 1 < argc) - { - get_int (argv[i + 1], &n_tests); - i++; - } - else - { - if (strcmp (argv[i], "-h") != 0) - printf ("Unknown option '%s'\n\n", argv[i]); - - printf ("Options:\n\n" - "-n Number of tests to run\n" - "-s Seed of first test (ignored if PIXMAN_RANDOMIZE_TESTS is set)\n" - "-v Print out seeds\n" - "-v Print out every n'th seed\n\n"); - - exit (-1); - } + fprintf(stderr, "Unable to open file %s", argv[1]); + return 0; } - if (getenv ("PIXMAN_RANDOMIZE_TESTS")) + //Get file length + fseek(file, 0, SEEK_END); + fileLen=ftell(file); + fseek(file, 0, SEEK_SET); + + //Allocate memory + buffer=(char *)malloc(fileLen+1); + if (!buffer) { - seed = get_random_seed(); - printf ("First seed: 0x%08x\n", seed); + fprintf(stderr, "Memory error!"); + fclose(file); + return 0; } - if (use_threads) - { -#ifdef USE_OPENMP -# pragma omp parallel for default(none) shared(verbose, n_tests, mod, seed) -#endif - for (i = 0; i < (int32_t)n_tests; ++i) - run_test (seed + i, verbose, mod); - } - else - { - for (i = 0; i < (int32_t)n_tests; ++i) - run_test (seed + i, verbose, mod); - } + //Read file contents into buffer + fread(buffer, fileLen, 1, file); + fclose(file); + + run_test (buffer, fileLen); + free(buffer); + return 0; } diff --git a/test/utils-prng.c b/test/utils-prng.c index c27b5be..244efa1 100644 --- a/test/utils-prng.c +++ b/test/utils-prng.c @@ -27,9 +27,15 @@ #include "utils.h" #include "utils-prng.h" +/* #if defined(HAVE_GCC_VECTOR_EXTENSIONS) && defined(__SSE2__) #include #endif +*/ + +const uint8_t *random_data; +size_t size_data; +size_t running_data; void smallprng_srand_r (smallprng_t *x, uint32_t seed) { @@ -52,6 +58,7 @@ void smallprng_srand_r (smallprng_t *x, uint32_t seed) */ void prng_srand_r (prng_t *x, uint32_t seed) { +/* #ifdef HAVE_GCC_VECTOR_EXTENSIONS int i; prng_rand_128_data_t dummy; @@ -64,17 +71,19 @@ void prng_srand_r (prng_t *x, uint32_t seed) for (i = 0; i < 20; ++i) prng_rand_128_r (x, &dummy); #else +*/ smallprng_srand_r (&x->p0, seed); smallprng_srand_r (&x->p1, (seed = seed * 1103515245 + 12345)); smallprng_srand_r (&x->p2, (seed = seed * 1103515245 + 12345)); smallprng_srand_r (&x->p3, (seed = seed * 1103515245 + 12345)); smallprng_srand_r (&x->p4, (seed = seed * 1103515245 + 12345)); -#endif +// #endif } static force_inline void store_rand_128_data (void *addr, prng_rand_128_data_t *d, int aligned) { +/* #ifdef HAVE_GCC_VECTOR_EXTENSIONS if (aligned) { @@ -84,12 +93,13 @@ store_rand_128_data (void *addr, prng_rand_128_data_t *d, int aligned) else { #ifdef __SSE2__ - /* workaround for http://gcc.gnu.org/PR55614 */ + // workaround for http://gcc.gnu.org/PR55614 _mm_storeu_si128 (addr, _mm_loadu_si128 ((__m128i *)d)); return; #endif } #endif +*/ /* we could try something better for unaligned writes (packed attribute), * but GCC is not very reliable: http://gcc.gnu.org/PR55454 */ memcpy (addr, d, 16); @@ -120,6 +130,7 @@ randmemset_internal (prng_t *prng, { prng_rand_128_r (&local_prng, &t); prng_rand_128_r (&local_prng, &randdata); +/* #ifdef HAVE_GCC_VECTOR_EXTENSIONS if (flags & RANDMEMSET_MORE_FF) { @@ -156,6 +167,7 @@ randmemset_internal (prng_t *prng, randdata.vw &= ((t.vw << 30) >= const_40000000); } #else +*/ #define PROCESS_ONE_LANE(i) \ if (flags & RANDMEMSET_MORE_FF) \ { \ @@ -190,7 +202,7 @@ randmemset_internal (prng_t *prng, PROCESS_ONE_LANE (1) PROCESS_ONE_LANE (2) PROCESS_ONE_LANE (3) -#endif +//#endif } if (is_little_endian ()) { @@ -199,6 +211,7 @@ randmemset_internal (prng_t *prng, } else { + /* #ifdef HAVE_GCC_VECTOR_EXTENSIONS const uint8x16 bswap_shufflemask = { @@ -208,6 +221,7 @@ randmemset_internal (prng_t *prng, store_rand_128_data (buf, &randdata, aligned); buf += 16; #else +*/ uint8_t t1, t2, t3, t4; #define STORE_ONE_LANE(i) \ t1 = randdata.b[i * 4 + 3]; \ @@ -223,7 +237,7 @@ randmemset_internal (prng_t *prng, STORE_ONE_LANE (1) STORE_ONE_LANE (2) STORE_ONE_LANE (3) -#endif +//#endif } size -= 16; } diff --git a/test/utils-prng.h b/test/utils-prng.h index f9ae8dd..356d327 100644 --- a/test/utils-prng.h +++ b/test/utils-prng.h @@ -77,12 +77,18 @@ #include "pixman-private.h" +extern const uint8_t *random_data; +extern size_t size_data; +extern size_t running_data; + /*****************************************************************************/ +/* #ifdef HAVE_GCC_VECTOR_EXTENSIONS typedef uint32_t uint32x4 __attribute__ ((vector_size(16))); typedef uint8_t uint8x16 __attribute__ ((vector_size(16))); #endif +*/ typedef struct { @@ -91,11 +97,13 @@ typedef struct typedef struct { +/* #ifdef HAVE_GCC_VECTOR_EXTENSIONS uint32x4 a, b, c, d; #else +*/ smallprng_t p1, p2, p3, p4; -#endif +//#endif smallprng_t p0; } prng_t; @@ -103,22 +111,40 @@ typedef union { uint8_t b[16]; uint32_t w[4]; + /* #ifdef HAVE_GCC_VECTOR_EXTENSIONS uint8x16 vb; uint32x4 vw; #endif +*/ } prng_rand_128_data_t; /*****************************************************************************/ +static inline uint8_t +get_rand_data_8() { + uint8_t retour = random_data[running_data]; + running_data = (running_data + 1) % size_data; + return retour; +} + +static inline uint32_t +get_rand_data_32() { + uint8_t un = get_rand_data_8(); + uint8_t deux = get_rand_data_8(); + uint8_t trois = get_rand_data_8(); + uint8_t quatre = get_rand_data_8(); + return (un << 24) + (deux << 16) + (trois << 8) + (quatre); +} + static force_inline uint32_t smallprng_rand_r (smallprng_t *x) { - uint32_t e = x->a - ((x->b << 27) + (x->b >> (32 - 27))); - x->a = x->b ^ ((x->c << 17) ^ (x->c >> (32 - 17))); - x->b = x->c + x->d; - x->c = x->d + e; - x->d = e + x->a; + x->a = get_rand_data_32(); + x->b = get_rand_data_32(); + x->c = get_rand_data_32(); + x->d = get_rand_data_32(); + return x->d; } @@ -133,6 +159,7 @@ prng_rand_r (prng_t *x) static force_inline void prng_rand_128_r (prng_t *x, prng_rand_128_data_t *data) { +/* #ifdef HAVE_GCC_VECTOR_EXTENSIONS uint32x4 e = x->a - ((x->b << 27) + (x->b >> (32 - 27))); x->a = x->b ^ ((x->c << 17) ^ (x->c >> (32 - 17))); @@ -141,11 +168,12 @@ prng_rand_128_r (prng_t *x, prng_rand_128_data_t *data) x->d = e + x->a; data->vw = x->d; #else +*/ data->w[0] = smallprng_rand_r (&x->p1); data->w[1] = smallprng_rand_r (&x->p2); data->w[2] = smallprng_rand_r (&x->p3); data->w[3] = smallprng_rand_r (&x->p4); -#endif +//#endif } typedef enum diff --git a/test/utils.c b/test/utils.c index f8e42a5..e547d3f 100644 --- a/test/utils.c +++ b/test/utils.c @@ -1025,7 +1025,7 @@ convert_linear_to_srgb (double c) return 1.055 * pow (c, 1.0/2.4) - 0.055; } -void +int initialize_palette (pixman_indexed_t *palette, uint32_t depth, int is_rgb) { int i; @@ -1041,6 +1041,7 @@ initialize_palette (pixman_indexed_t *palette, uint32_t depth, int is_rgb) uint32_t rgba24; pixman_bool_t retry; uint32_t i15; + size_t size_data_i = size_data; /* We filled the rgb->index map with random numbers, but we * do need the ability to round trip, that is if some indexed @@ -1060,6 +1061,10 @@ initialize_palette (pixman_indexed_t *palette, uint32_t depth, int is_rgb) retry = 1; else retry = 0; + if (size_data_i == 0) { + return FALSE; + } + size_data_i--; } while (retry); palette->rgba[i] = rgba24; @@ -1070,6 +1075,8 @@ initialize_palette (pixman_indexed_t *palette, uint32_t depth, int is_rgb) { assert (palette->ent[CONVERT_15 (palette->rgba[i], is_rgb)] == i); } + + return TRUE; } struct operator_entry { diff --git a/test/utils.h b/test/utils.h index e299d1d..43eca8a 100644 --- a/test/utils.h +++ b/test/utils.h @@ -205,7 +205,7 @@ convert_srgb_to_linear (double component); double convert_linear_to_srgb (double component); -void +int initialize_palette (pixman_indexed_t *palette, uint32_t depth, int is_rgb); pixman_format_code_t