438 lines
11 KiB
C
438 lines
11 KiB
C
/*
|
|
* 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"
|
|
|
|
#include "test.h"
|
|
|
|
#define SAFE_FREE(p) { if (p) { free(p); (p)=NULL; } }
|
|
/* LTP status reporting */
|
|
char *TCID; /* Test program identifier. */
|
|
int TST_TOTAL = 1; /* Total number of test cases. */
|
|
|
|
/* To avoid extensive modifications to the code, use this bodge */
|
|
#define exit(x) myexit(x)
|
|
|
|
void myexit(int x)
|
|
{
|
|
if (x)
|
|
tst_resm(TFAIL, "Test failed");
|
|
else
|
|
tst_resm(TPASS, "Test passed");
|
|
tst_exit();
|
|
}
|
|
|
|
TH_DATA *pcom;
|
|
TH_DATA **tabcom;
|
|
TH_DATA **tabcour;
|
|
#ifndef PATH_MAX
|
|
#define PATH_MAX 1024
|
|
#endif
|
|
char datadir[PATH_MAX]; /* DATA directory */
|
|
|
|
#ifndef PTHREAD_THREADS_MAX
|
|
#define PTHREAD_THREADS_MAX 1024
|
|
#endif
|
|
#define DEFAULT_NUM_THREADS 20
|
|
int num_threads = DEFAULT_NUM_THREADS;
|
|
int num_loops = 500;
|
|
|
|
int sig_cancel = 0; /* flag set by handle_signals to tell initial thread
|
|
to stop creating new threads (signal caught) */
|
|
|
|
int indice = 0; /* # of threads created, to be canceled by handle_signals
|
|
or waited for by initial thread */
|
|
|
|
pthread_mutex_t sig_mutex;
|
|
pthread_t *threads;
|
|
|
|
int debug = 0;
|
|
int true = 1;
|
|
|
|
static void *handle_signals(void *);
|
|
|
|
static void sys_error(const char *, int);
|
|
|
|
const double EPS = 0.1e-300;
|
|
|
|
const int nb_func = NB_FUNC;
|
|
|
|
int generate(char *datadir, char *bin_path)
|
|
{
|
|
char *cmdline;
|
|
char *fmt = "cd %s; %s/%s %s";
|
|
|
|
cmdline = malloc(2 * strlen(bin_path) + strlen(datadir) + strlen(GENERATOR) + strlen(fmt));
|
|
if (cmdline == NULL)
|
|
return (1);
|
|
sprintf(cmdline, fmt, datadir, bin_path, GENERATOR, bin_path);
|
|
system(cmdline);
|
|
free(cmdline);
|
|
return (0);
|
|
}
|
|
|
|
static void cleanup(void)
|
|
{
|
|
tst_rmdir();
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int opt = 0;
|
|
pid_t pid;
|
|
|
|
char *bin_path, *ltproot;
|
|
void *exit_value;
|
|
pthread_attr_t newattr;
|
|
pthread_t sig_hand;
|
|
size_t stacksize = 2093056;
|
|
int th_num;
|
|
int retvalend = 0;
|
|
int retval = 0;
|
|
int error = 0;
|
|
/*int time=1; */
|
|
int i;
|
|
|
|
/* Generate test ID from invocation name */
|
|
if ((TCID = strrchr(argv[0], '/')) != NULL)
|
|
TCID++;
|
|
else
|
|
TCID = argv[0];
|
|
ltproot = getenv("LTPROOT");
|
|
if (ltproot == NULL || strlen(ltproot) == 0) {
|
|
tst_brkm(TBROK, NULL,
|
|
"You must set $LTPROOT before executing this test");
|
|
}
|
|
bin_path = malloc(strlen(ltproot) + 16);
|
|
if (bin_path == NULL) {
|
|
tst_brkm(TBROK | TERRNO, NULL, "malloc failed");
|
|
}
|
|
sprintf(bin_path, "%s/testcases/bin", ltproot);
|
|
|
|
tst_tmpdir();
|
|
|
|
setbuf(stdout, NULL);
|
|
setbuf(stderr, NULL);
|
|
datadir[0] = '.';
|
|
datadir[1] = '\0';
|
|
|
|
if (argc != 1) {
|
|
while ((opt = getopt(argc, argv, "vn:l:D:?")) != EOF) {
|
|
switch (opt) {
|
|
case 'D':
|
|
strncpy(datadir, optarg, PATH_MAX);
|
|
break;
|
|
case 'l':
|
|
num_loops = atoi(optarg);
|
|
break;
|
|
case 'n':
|
|
num_threads = atoi(optarg);
|
|
break;
|
|
case 'v':
|
|
++debug; /* verbose mode */
|
|
break;
|
|
default:
|
|
fprintf(stderr,
|
|
"usage: %s [-n number_of_threads] [-v]\n",
|
|
argv[0]);
|
|
fprintf(stderr, "[-l number_of_loops] ");
|
|
fprintf(stderr, "[-D DATAs absolute path]\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
switch (pid = fork()) {
|
|
case -1:
|
|
tst_brkm(TBROK | TERRNO, cleanup, "fork failed");
|
|
case 0:
|
|
generate(datadir, bin_path);
|
|
exit(0);
|
|
default:
|
|
waitpid(pid, NULL, 0);
|
|
}
|
|
SAFE_FREE(bin_path);
|
|
|
|
if (debug) {
|
|
tst_resm(TINFO,
|
|
"%s: will run for %d loops; using %s as a data directory",
|
|
argv[0], num_loops, datadir);
|
|
}
|
|
if (num_threads <= 0) {
|
|
tst_resm(TWARN,
|
|
"num_threads undefined or incorrect, using \"1\"");
|
|
num_threads = 1;
|
|
}
|
|
|
|
if (nb_func * num_threads > PTHREAD_THREADS_MAX - 2)
|
|
while (nb_func * num_threads > PTHREAD_THREADS_MAX - 2)
|
|
num_threads--;
|
|
if (debug)
|
|
tst_resm(TINFO,
|
|
"%s: will run %d functions, %d threads per function",
|
|
argv[0], nb_func, num_threads);
|
|
|
|
retval = pthread_mutex_init(&sig_mutex, NULL);
|
|
if (retval != 0)
|
|
sys_error("main : mutex_init(&sig_mutex) FAILED", __LINE__);
|
|
|
|
retval = pthread_create(&sig_hand, NULL, handle_signals, NULL);
|
|
if (retval != 0)
|
|
sys_error("main : create(&sig_hand) FAILED", __LINE__);
|
|
|
|
/*
|
|
* Start all calculation threads...
|
|
*/
|
|
threads = malloc(nb_func * num_threads * sizeof(pthread_t));
|
|
if (threads == NULL)
|
|
tst_brkm(TFAIL | TERRNO, cleanup, "malloc failed");
|
|
|
|
tabcom = malloc((sizeof(TH_DATA *) * nb_func * num_threads));
|
|
if (!tabcom)
|
|
tst_brkm(TFAIL | TERRNO, cleanup, "malloc failed");
|
|
tabcour = tabcom;
|
|
|
|
retval = pthread_attr_init(&newattr);
|
|
if (retval != 0)
|
|
sys_error("main : attr_init(&newattr) FAILED", __LINE__);
|
|
|
|
if (pthread_attr_setstacksize(&newattr, stacksize))
|
|
sys_error("main: pthread_attr_setstacksize failed", __LINE__);
|
|
|
|
retval = pthread_attr_setdetachstate(&newattr, PTHREAD_CREATE_JOINABLE);
|
|
if (retval != 0)
|
|
sys_error("main : attr_setdetachstate(&newattr) FAILED",
|
|
__LINE__);
|
|
|
|
/* run the nb_func functions on num_threads */
|
|
|
|
indice = 0;
|
|
for (i = 0; i < nb_func; i++) {
|
|
|
|
for (th_num = 0; th_num < num_threads; th_num++) {
|
|
|
|
/* allocate struct of commucation with the thread */
|
|
pcom = calloc(1, sizeof(TH_DATA));
|
|
if (pcom == NULL)
|
|
tst_brkm(TFAIL | TERRNO, cleanup,
|
|
"calloc failed");
|
|
*tabcour = (TH_DATA *) pcom;
|
|
tabcour++;
|
|
/*
|
|
* update structure of communication
|
|
*/
|
|
pcom->th_num = th_num;
|
|
pcom->th_func = th_func[i];
|
|
|
|
pthread_mutex_lock(&sig_mutex);
|
|
|
|
if (sig_cancel) { /* stop processing right now! */
|
|
pthread_mutex_unlock(&sig_mutex);
|
|
goto finished;
|
|
}
|
|
retval = pthread_create(&threads[indice], &newattr,
|
|
thread_code, (void *)pcom);
|
|
if (retval != 0)
|
|
sys_error("main : create FAILED", __LINE__);
|
|
indice++;
|
|
pthread_mutex_unlock(&sig_mutex);
|
|
|
|
} /* num_threads */
|
|
} /* for i */
|
|
|
|
/*alarm(60*time); *//* start all threads for TEST_time */
|
|
|
|
/*
|
|
* Wait for the threads finish their task
|
|
* pthread_join () will block
|
|
*/
|
|
|
|
finished:
|
|
if (debug) {
|
|
tst_resm(TINFO,
|
|
"initial thread: Waiting for %d threads to finish",
|
|
indice);
|
|
}
|
|
tabcour = tabcom;
|
|
|
|
for (th_num = 0; th_num < indice; th_num++) {
|
|
retvalend = pthread_join(threads[th_num], &exit_value);
|
|
if (retvalend != 0)
|
|
sys_error("finish : join FAILED", __LINE__);
|
|
|
|
/* test the result in TH_DATA : communication buffer */
|
|
pcom = *tabcour++;
|
|
if (pcom->th_result != 0) {
|
|
error++;
|
|
tst_resm(TFAIL,
|
|
"thread %d (%s) terminated unsuccessfully %d "
|
|
"errors/%d loops\n%s",
|
|
th_num, pcom->th_func.fident, pcom->th_nerror,
|
|
pcom->th_nloop, pcom->detail_data);
|
|
} else if (debug) {
|
|
tst_resm(TINFO,
|
|
"thread %d (%s) terminated successfully %d loops",
|
|
th_num, pcom->th_func.fident,
|
|
pcom->th_nloop - 1);
|
|
}
|
|
SAFE_FREE(pcom);
|
|
|
|
}
|
|
SAFE_FREE(tabcom);
|
|
SAFE_FREE(threads);
|
|
tst_rmdir();
|
|
if (error)
|
|
exit(1);
|
|
else
|
|
exit(0);
|
|
return 0;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------+
|
|
| handle_signals () |
|
|
| ======================================================================|
|
|
| |
|
|
| Function: .... |
|
|
| If SIGALRM or SIGUSR1 or SIGINT : cancel threads |
|
|
| |
|
|
| Updates: .... |
|
|
| |
|
|
+-----------------------------------------------------------------------*/
|
|
static void *handle_signals(void *arg)
|
|
{
|
|
sigset_t signals_set;
|
|
int thd;
|
|
int sig;
|
|
int retvalsig = 0;
|
|
|
|
if (debug)
|
|
tst_resm(TINFO, "signal handler %lu started", pthread_self());
|
|
/*
|
|
* Set up the signals that we want to handle...
|
|
*/
|
|
sigemptyset(&signals_set);
|
|
sigaddset(&signals_set, SIGINT);
|
|
sigaddset(&signals_set, SIGQUIT);
|
|
sigaddset(&signals_set, SIGTERM);
|
|
sigaddset(&signals_set, SIGUSR1);
|
|
sigaddset(&signals_set, SIGALRM);
|
|
while (1) {
|
|
if (debug)
|
|
tst_resm(TINFO, "Signal handler starts waiting...");
|
|
|
|
sigwait(&signals_set, &sig);
|
|
if (debug)
|
|
tst_resm(TINFO, "Signal handler caught signal %d", sig);
|
|
|
|
switch (sig) {
|
|
case SIGALRM:
|
|
case SIGUSR1:
|
|
case SIGINT:
|
|
if (sig_cancel)
|
|
tst_resm(TINFO,
|
|
"Signal handler: already finished; "
|
|
"ignoring signal");
|
|
else {
|
|
/*
|
|
* Have to signal all non started threads...
|
|
*/
|
|
|
|
retvalsig = pthread_mutex_lock(&sig_mutex);
|
|
if (retvalsig != 0)
|
|
sys_error
|
|
("handle_signal : mutex_lock(&sig_mutex) FAILED",
|
|
__LINE__);
|
|
|
|
sig_cancel = 1;
|
|
retvalsig = pthread_mutex_unlock(&sig_mutex);
|
|
if (retvalsig != 0)
|
|
sys_error
|
|
("handle_signal : mutex_unlock(&sig_mutex) FAILED",
|
|
__LINE__);
|
|
|
|
/*
|
|
* ......... and all started
|
|
*/
|
|
for (thd = 0; thd < indice; thd++) {
|
|
if (debug)
|
|
tst_resm(TINFO,
|
|
"signal handler: "
|
|
"cancelling thread (%d of "
|
|
"%d)", thd, indice);
|
|
retvalsig =
|
|
pthread_cancel(threads[thd]);
|
|
if (retvalsig != 0)
|
|
sys_error
|
|
("handle_signal : cancel FAILED",
|
|
__LINE__);
|
|
}
|
|
}
|
|
break;
|
|
case SIGQUIT:
|
|
tst_resm(TINFO,
|
|
"Signal handler: Caught SIGQUIT; doing nothing");
|
|
break;
|
|
case SIGTERM:
|
|
tst_resm(TINFO,
|
|
"Signal handler: Caught SIGTERM; doing nothing");
|
|
break;
|
|
default:
|
|
exit(1);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------+
|
|
| error () |
|
|
| =====================================================================|
|
|
| |
|
|
| Function: Prints out message and exits... |
|
|
| |
|
|
+----------------------------------------------------------------------*/
|
|
static void error(const char *msg, int line)
|
|
{
|
|
tst_brkm(TFAIL, cleanup, "ERROR [line: %d] %s", line, msg);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------+
|
|
| sys_error () |
|
|
| =====================================================================|
|
|
| |
|
|
| Function: Creates system error message and calls error () |
|
|
| |
|
|
+----------------------------------------------------------------------*/
|
|
/*
|
|
* XXX (garrcoop): the way that this is being called is just plain wrong.
|
|
* pthread(5) returns 0 or errnos, not necessarily sets errno to a sensible
|
|
* value.
|
|
*/
|
|
static void sys_error(const char *msg, int line)
|
|
{
|
|
char syserr_msg[256];
|
|
|
|
sprintf(syserr_msg, "%s: %s", msg, strerror(errno));
|
|
error(syserr_msg, line);
|
|
}
|