You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
135 lines
3.7 KiB
135 lines
3.7 KiB
//
|
|
// Copyright (c) 2017 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
#ifndef _conversions_h
|
|
#define _conversions_h
|
|
|
|
#include "compat.h"
|
|
|
|
#include "errorHelpers.h"
|
|
#include "mt19937.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
|
|
/* Note: the next three all have to match in size and order!! */
|
|
|
|
enum ExplicitTypes
|
|
{
|
|
kBool = 0,
|
|
kChar,
|
|
kUChar,
|
|
kUnsignedChar,
|
|
kShort,
|
|
kUShort,
|
|
kUnsignedShort,
|
|
kInt,
|
|
kUInt,
|
|
kUnsignedInt,
|
|
kLong,
|
|
kULong,
|
|
kUnsignedLong,
|
|
kFloat,
|
|
kHalf,
|
|
kDouble,
|
|
kNumExplicitTypes
|
|
};
|
|
|
|
typedef enum ExplicitTypes ExplicitType;
|
|
|
|
enum RoundingTypes
|
|
{
|
|
kRoundToEven = 0,
|
|
kRoundToZero,
|
|
kRoundToPosInf,
|
|
kRoundToNegInf,
|
|
kRoundToNearest,
|
|
|
|
kNumRoundingTypes,
|
|
|
|
kDefaultRoundingType = kRoundToNearest
|
|
};
|
|
|
|
typedef enum RoundingTypes RoundingType;
|
|
|
|
extern void print_type_to_string(ExplicitType type, void *data, char *string);
|
|
extern size_t get_explicit_type_size(ExplicitType type);
|
|
extern const char *get_explicit_type_name(ExplicitType type);
|
|
extern void convert_explicit_value(void *inRaw, void *outRaw,
|
|
ExplicitType inType, bool saturate,
|
|
RoundingType roundType,
|
|
ExplicitType outType);
|
|
|
|
extern void generate_random_data(ExplicitType type, size_t count, MTdata d,
|
|
void *outData);
|
|
extern void *create_random_data(ExplicitType type, MTdata d, size_t count);
|
|
|
|
extern cl_long read_upscale_signed(void *inRaw, ExplicitType inType);
|
|
extern cl_ulong read_upscale_unsigned(void *inRaw, ExplicitType inType);
|
|
extern float read_as_float(void *inRaw, ExplicitType inType);
|
|
|
|
extern float get_random_float(float low, float high, MTdata d);
|
|
extern double get_random_double(double low, double high, MTdata d);
|
|
extern float any_float(MTdata d);
|
|
extern double any_double(MTdata d);
|
|
|
|
extern int random_in_range(int minV, int maxV, MTdata d);
|
|
|
|
size_t get_random_size_t(size_t low, size_t high, MTdata d);
|
|
|
|
// Note: though this takes a double, this is for use with single precision tests
|
|
static inline int IsFloatSubnormal(float x)
|
|
{
|
|
#if 2 == FLT_RADIX
|
|
// Do this in integer to avoid problems with FTZ behavior
|
|
union {
|
|
float d;
|
|
uint32_t u;
|
|
} u;
|
|
u.d = fabsf(x);
|
|
return (u.u - 1) < 0x007fffffU;
|
|
#else
|
|
// rely on floating point hardware for non-radix2 non-IEEE-754 hardware --
|
|
// will fail if you flush subnormals to zero
|
|
return fabs(x) < (double)FLT_MIN && x != 0.0;
|
|
#endif
|
|
}
|
|
|
|
static inline int IsDoubleSubnormal(double x)
|
|
{
|
|
#if 2 == FLT_RADIX
|
|
// Do this in integer to avoid problems with FTZ behavior
|
|
union {
|
|
double d;
|
|
uint64_t u;
|
|
} u;
|
|
u.d = fabs(x);
|
|
return (u.u - 1) < 0x000fffffffffffffULL;
|
|
#else
|
|
// rely on floating point hardware for non-radix2 non-IEEE-754 hardware --
|
|
// will fail if you flush subnormals to zero
|
|
return fabs(x) < (double)DBL_MIN && x != 0.0;
|
|
#endif
|
|
}
|
|
|
|
static inline int IsHalfSubnormal(cl_half x)
|
|
{
|
|
// this relies on interger overflow to exclude 0 as a subnormal
|
|
return ((x & 0x7fffU) - 1U) < 0x03ffU;
|
|
}
|
|
|
|
#endif // _conversions_h
|