thread_code.c - Android社区 - https://www.androidos.net.cn/

/*
 * Copyright (C) Bull S.A. 2001
 * Copyright (c) International Business Machines  Corp., 2001
 *
 *   This program is free software;  you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program;  if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/******************************************************************************/
/*                                                                            */
/* Dec-03-2001  Created: Jacky Malcles & Jean Noel Cordenner                  */
/*              These tests are adapted from AIX float PVT tests.             */
/*                                                                            */
/******************************************************************************/
#include "tfloat.h"

#define SAFE_FREE(p) { if (p) { free(p); (p)=NULL; } }
/*
 * allocates a buffer and read a file to it
 * input parameters:
 *	fname: name of the file to read
 *	data:  pointer where buffer addr. will be returned
 *
 * uses also external variable datadir to build file pathname
 *
 * returns:
 *	0 in case of failure
 *	# of bytes read elsewhere
 */
static size_t read_file(char *fname, void **data)
{
	struct stat bufstat;
	char path[PATH_MAX];
	size_t fsize;
	void *buffer;
	int fd;
	int maxretries = 1;

(void)sprintf(path, "%s/%s", datadir, fname);

errno = 0;

while (stat(path, &bufstat)) {
		if (errno == ETIMEDOUT || errno == EINTR || errno == 0) {
			printf("Error stat'ing %s: %s\n",
			       path, strerror(errno));
			pthread_testcancel();
			/* retrying... */
			if (maxretries--)
				continue;
		}
		return (size_t) 0;
	}

fsize = bufstat.st_size;
	if (!fsize) {
		errno = ENOENT;
		return (size_t) 0;
	}

while ((buffer = malloc(fsize)) == NULL) {
		if (errno == EINTR || errno == 0) {
			printf("Error malloc'ing: %s\n", strerror(errno));
			pthread_testcancel();
			/* retrying... */
			if (maxretries--)
				continue;
		}
		return (size_t) 0;
	}

while ((fd = open(path, O_RDONLY)) < 0) {
		if (errno == ETIMEDOUT || errno == EINTR || errno == 0) {
			printf("Error opening %s: %s\n", path, strerror(errno));
			pthread_testcancel();
			/* retrying... */
			if (maxretries--)
				continue;
		}
		SAFE_FREE(buffer);
		return (size_t) 0;
	}

while (read(fd, buffer, fsize) != fsize) {
		if (errno == ETIMEDOUT || errno == EINTR || errno == 0) {
			printf("Error reading %s: %s\n", path, strerror(errno));
			pthread_testcancel();
			/* retrying... */
			if (lseek(fd, (off_t) 0, SEEK_SET) == (off_t) 0) {
				if (maxretries--)
					continue;
			}
		}
		(void)close(fd);
		SAFE_FREE(buffer);
		return (size_t) 0;
	}

(void)close(fd);
	*data = buffer;
	return fsize;
}

/* this subroutine is used in compute_xxx functions to check results
   and record errors if appropriate */
static void check_error(TH_DATA * th_data, double e, double r, int index)
{
	double x;
	int pe, pr, px;
	static const char errtmplt[] =
	    "%s failed at index %d: OLD: %2.18e NEW: %2.18e DIFF: %2.18e\n";

x = fabs(r - e);	/* diff expected/computed */

if (x > EPS) {		/* error ? */
		/* compute exponent parts */
		(void)frexp(r, &pr);	/* for computed */
		(void)frexp(x, &px);	/* for difference */
		(void)frexp(e, &pe);	/* for dexected */

if (abs(pe - px) < th_data->th_func.precision ||
		    abs(pr - px) < th_data->th_func.precision) {
			/* not a rounding error */
			++th_data->th_nerror;
			/* record first error only ! */
			if (th_data->th_result == 0) {
				sprintf(th_data->detail_data,
					errtmplt,
					th_data->th_func.fident,
					index, e, r, x);
				th_data->th_result = 1;
			}
		}
	}
}

/*
 * these functions handle the various cases of computation
 * they are called by pthread_code
 */

/* normal case: compares f(input data) to expected data */
static void compute_normal(TH_DATA * th_data, double *din, double *dex,
			   int index)
{
	double d, r, e;

d = din[index];
	e = dex[index];
	r = (*(th_data->th_func.funct)) (d);