Impressum run_parallel.h Sprache: C

/*
* Copyright (c) 2003-2005 Hewlett-Packard Development Company, L.P.
*
* This file is covered by the GNU general public license, version 2.
* see COPYING for details.
*/

#if defined(_MSC_VER) || \
    defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__) || \
    defined(_WIN32_WINCE)
#  define USE_WINTHREADS
#elif defined(__vxworks)
#  define USE_VXTHREADS
#else
#  define USE_PTHREADS
#endif

#include <stdlib.h>
#include <stdio.h>

#ifdef USE_PTHREADS
# include <pthread.h>
#endif

#ifdef USE_VXTHREADS
# include <vxworks.h>
# include <taskLib.h>
#endif

#ifdef USE_WINTHREADS
# include <windows.h>
#endif

#include "atomic_ops.h"

#if !defined(AO_ATOMIC_OPS_H) && !defined(CPPCHECK)
# error Wrong atomic_ops.h included.
#endif

#if (defined(_WIN32_WCE) || defined(__MINGW32CE__)) && !defined(AO_HAVE_abort)
# define abort() _exit(-1) /* there is no abort() in WinCE */
#endif

#ifndef AO_PTRDIFF_T
# define AO_PTRDIFF_T ptrdiff_t
#endif

#ifndef MAX_NTHREADS
# define MAX_NTHREADS 100
#endif

typedef void * (* thr_func)(void *);

typedef int (* test_func)(void);    /* Returns != 0 on success */

void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name);

#ifdef USE_PTHREADS
void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name)
{
  pthread_attr_t attr;
  pthread_t thr[MAX_NTHREADS];
  int i;

  printf("Testing %s\n", name);
  if (nthreads > MAX_NTHREADS)
    {
      fprintf(stderr, "run_parallel: requested too many threads\n");
      abort();
    }

# ifdef _HPUX_SOURCE
   /* Default stack size is too small, especially with the 64 bit ABI */
   /* Increase it.                                                    */
    if (pthread_default_stacksize_np(1024*1024, 0) != 0)
      {
        fprintf(stderr, "pthread_default_stacksize_np failed. "
                        "OK after first call.\n");
      }
# endif

  pthread_attr_init(&attr);

  for (i = 0; i < nthreads; ++i)
    {
      int code = pthread_create(thr + i, &attr, f1, (void *)(long)i);
      if (code != 0)
      {
        fprintf(stderr, "pthread_create returned %d, thread %d\n", code, i);
        abort();
      }
    }
  for (i = 0; i < nthreads; ++i)
    {
      int code = pthread_join(thr[i], NULL);
      if (code != 0)
      {
        fprintf(stderr, "pthread_join returned %d, thread %d\n", code, i);
        abort();
      }
    }
  if (t())
    {
      printf("Succeeded\n");
    }
  else
    {
      fprintf(stderr, "Failed\n");
      abort();
    }
  return 0;
}
#endif /* USE_PTHREADS */

#ifdef USE_VXTHREADS
void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name)
{
  int thr[MAX_NTHREADS];
  int i;

  printf("Testing %s\n", name);
  if (nthreads > MAX_NTHREADS)
    {
      fprintf(stderr, "run_parallel: requested too many threads\n");
      taskSuspend(0);
    }

  for (i = 0; i < nthreads; ++i)
    {
      thr[i] = taskSpawn((char*) name, 180, 0, 32768, (FUNCPTR) f1, i,
                         1, 2, 3, 4, 5, 6, 7, 8, 9);
      if (thr[i] == ERROR)
      {
        fprintf(stderr, "taskSpawn failed with %d, thread %d\n",
                errno, i);
        taskSuspend(0);
      }
    }
  for (i = 0; i < nthreads; ++i)
    {
      while (taskIdVerify(thr[i]) == OK)
        taskDelay(60);
    }
  if (t())
    {
      printf("Succeeded\n");
    }
  else
    {
      fprintf(stderr, "Failed\n");
      taskSuspend(0);
    }
  return 0;
}
#endif /* USE_VXTHREADS */

#ifdef USE_WINTHREADS

struct tramp_args {
  thr_func fn;
  long arg;
};

DWORD WINAPI tramp(LPVOID param)
{
  struct tramp_args *args = (struct tramp_args *)param;

  return (DWORD)(AO_PTRDIFF_T)(*args->fn)((LPVOID)(AO_PTRDIFF_T)args->arg);
}

void * run_parallel(int nthreads, thr_func f1, test_func t, const char *name)
{
  HANDLE thr[MAX_NTHREADS];
  struct tramp_args args[MAX_NTHREADS];
  int i;

  printf("Testing %s\n", name);
  if (nthreads > MAX_NTHREADS)
    {
      fprintf(stderr, "run_parallel: requested too many threads\n");
      abort();
    }

  for (i = 0; i < nthreads; ++i)
    {
      args[i].fn = f1;
      args[i].arg = i;
      if ((thr[i] = CreateThread(NULL, 0, tramp, (LPVOID)(args+i), 0, NULL))
          == NULL)
        {
          fprintf(stderr, "CreateThread failed with %lu, thread %d\n",
                  (unsigned long)GetLastError(), i);
          abort();
        }
    }
  for (i = 0; i < nthreads; ++i)
    {
      DWORD code = WaitForSingleObject(thr[i], INFINITE);
      if (code != WAIT_OBJECT_0)
      {
        fprintf(stderr, "WaitForSingleObject returned %lu, thread %d\n",
                (unsigned long)code, i);
        abort();
      }
    }
  if (t())
    {
      printf("Succeeded\n");
    }
  else
    {
      fprintf(stderr, "Failed\n");
      abort();
    }
  return 0;
}
#endif /* USE_WINTHREADS */

quality94%

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.