*/
-#include "lp_bld_const.h"
+#include "util/u_cpu_detect.h"
+#include "util/u_math.h"
+
+#include "gallivm/lp_bld_const.h"
+#include "gallivm/lp_bld_init.h"
#include "lp_test.h"
void
dump_type(FILE *fp,
- union lp_type type)
+ struct lp_type type)
{
fprintf(fp, "%s%s%u%sx%u",
type.sign ? (type.floating || type.fixed ? "" : "s") : "u",
double
-read_elem(union lp_type type, const void *src, unsigned index)
+read_elem(struct lp_type type, const void *src, unsigned index)
{
double scale = lp_const_scale(type);
double value;
void
-write_elem(union lp_type type, void *dst, unsigned index, double value)
+write_elem(struct lp_type type, void *dst, unsigned index, double value)
{
assert(index < type.length);
if(!type.sign && value < 0.0)
value = 0.0;
+ if(type.norm && value < -1.0)
+ value = -1.0;
if(type.norm && value > 1.0)
value = 1.0;
if (type.floating) {
}
else {
double scale = lp_const_scale(type);
- long long lvalue = (long long)round(value*scale);
+ value = round(value*scale);
if(type.sign) {
- lvalue = MIN2(lvalue, (1 << (type.width - 1)) - 1);
+ long long lvalue = (long long)value;
+ lvalue = MIN2(lvalue, ((long long)1 << (type.width - 1)) - 1);
switch(type.width) {
case 8:
*((int8_t *)dst + index) = (int8_t)lvalue;
*((int32_t *)dst + index) = (int32_t)lvalue;
break;
case 64:
- *((int64_t *)dst + index) = (int32_t)lvalue;
+ *((int64_t *)dst + index) = (int64_t)lvalue;
break;
default:
assert(0);
}
}
else {
- lvalue = MIN2(lvalue, (1 << type.width) - 1);
+ unsigned long long lvalue = (long long)value;
+ lvalue = MIN2(lvalue, ((unsigned long long)1 << type.width) - 1);
switch(type.width) {
case 8:
*((uint8_t *)dst + index) = (uint8_t)lvalue;
void
-random_elem(union lp_type type, void *dst, unsigned index)
+random_elem(struct lp_type type, void *dst, unsigned index)
{
double value;
assert(index < type.length);
- value = (double)random()/(double)RAND_MAX;
+ value = (double)rand()/(double)RAND_MAX;
if(!type.norm) {
- unsigned long long mask;
- if (type.floating)
- mask = ~(unsigned long long)0;
- else if (type.fixed)
- mask = ((unsigned long long)1 << (type.width / 2)) - 1;
- else if (type.sign)
- mask = ((unsigned long long)1 << (type.width - 1)) - 1;
- else
- mask = ((unsigned long long)1 << type.width) - 1;
- value += (double)(mask & random());
+ if (type.floating) {
+ value *= 2.0;
+ }
+ else {
+ unsigned long long mask;
+ if (type.fixed)
+ mask = ((unsigned long long)1 << (type.width / 2)) - 1;
+ else if (type.sign)
+ mask = ((unsigned long long)1 << (type.width - 1)) - 1;
+ else
+ mask = ((unsigned long long)1 << type.width) - 1;
+ value += (double)(mask & rand());
+ }
}
if(!type.sign)
- if(random() & 1)
+ if(rand() & 1)
value = -value;
write_elem(type, dst, index, value);
}
void
-read_vec(union lp_type type, const void *src, double *dst)
+read_vec(struct lp_type type, const void *src, double *dst)
{
unsigned i;
for (i = 0; i < type.length; ++i)
void
-write_vec(union lp_type type, void *dst, const double *src)
+write_vec(struct lp_type type, void *dst, const double *src)
{
unsigned i;
for (i = 0; i < type.length; ++i)
float
random_float(void)
{
- return (float)((double)random()/(double)RAND_MAX);
+ return (float)((double)rand()/(double)RAND_MAX);
}
void
-random_vec(union lp_type type, void *dst)
+random_vec(struct lp_type type, void *dst)
{
unsigned i;
for (i = 0; i < type.length; ++i)
boolean
-compare_vec(union lp_type type, const void *res, const void *ref)
+compare_vec_with_eps(struct lp_type type, const void *res, const void *ref, double eps)
{
- double eps;
unsigned i;
-
- if (type.floating) {
- switch(type.width) {
- case 32:
- eps = FLT_EPSILON;
- break;
- case 64:
- eps = DBL_EPSILON;
- break;
- default:
- assert(0);
- eps = 0.0;
- break;
- }
- }
- else {
- double scale = lp_const_scale(type);
- eps = 1.0/scale;
- }
-
+ eps *= type.floating ? 8.0 : 2.0;
for (i = 0; i < type.length; ++i) {
double res_elem = read_elem(type, res, i);
double ref_elem = read_elem(type, ref, i);
- double delta = fabs(res_elem - ref_elem);
- if(delta >= 2.0*eps)
+ double delta = res_elem - ref_elem;
+ if (ref_elem < -1.0 || ref_elem > 1.0) {
+ delta /= ref_elem;
+ }
+ delta = fabs(delta);
+ if (delta >= eps) {
return FALSE;
+ }
}
return TRUE;
}
+boolean
+compare_vec(struct lp_type type, const void *res, const void *ref)
+{
+ double eps = lp_const_eps(type);
+ return compare_vec_with_eps(type, res, ref, eps);
+}
+
+
void
-dump_vec(FILE *fp, union lp_type type, const void *src)
+dump_vec(FILE *fp, struct lp_type type, const void *src)
{
unsigned i;
for (i = 0; i < type.length; ++i) {
fprintf(fp, "%f", value);
}
else {
- if(type.sign) {
+ if(type.sign && !type.norm) {
long long value;
const char *format;
switch(type.width) {
switch(type.width) {
case 8:
value = *((const uint8_t *)src + i);
- format = "%4llu";
+ format = type.norm ? "%2x" : "%4llu";
break;
case 16:
value = *((const uint16_t *)src + i);
- format = "%6llu";
+ format = type.norm ? "%4x" : "%6llx";
break;
case 32:
value = *((const uint32_t *)src + i);
- format = "%11llu";
+ format = type.norm ? "%8x" : "%11llx";
break;
case 64:
value = *((const uint64_t *)src + i);
- format = "%21llu";
+ format = type.norm ? "%16x" : "%21llx";
break;
default:
assert(0);
unsigned long n = 1000;
unsigned i;
boolean success;
+ boolean single = FALSE;
+ struct gallivm_state *gallivm;
for(i = 1; i < argc; ++i) {
if(strcmp(argv[i], "-v") == 0)
++verbose;
+ else if(strcmp(argv[i], "-s") == 0)
+ single = TRUE;
else if(strcmp(argv[i], "-o") == 0)
fp = fopen(argv[++i], "wt");
else
n = atoi(argv[i]);
}
+ lp_build_init();
+
+ gallivm = gallivm_create();
+
+ util_cpu_detect();
+
if(fp) {
/* Warm up the caches */
- test_some(0, NULL, 100);
+ test_some(gallivm, 0, NULL, 100);
write_tsv_header(fp);
}
- if(n)
- success = test_some(verbose, fp, n);
+ if (single)
+ success = test_single(gallivm, verbose, fp);
+ else if (n)
+ success = test_some(gallivm, verbose, fp, n);
else
- success = test_all(verbose, fp);
+ success = test_all(gallivm, verbose, fp);
if(fp)
fclose(fp);
projects / mesa.git / blobdiff