Subversion Repositories openrisc_2011-10-31

// { dg-do run }

// { dg-do run }

// { dg-require-effective-target tls_runtime }

// { dg-require-effective-target tls_runtime }

#include 

#include 

#include 

#include 

#define N 10

#define N 10

#define THR 4

#define THR 4

struct B

struct B

{

{

  B& operator=(const B &);

  B& operator=(const B &);

};

};

static B *base;

static B *base;

static B *threadbase;

static B *threadbase;

static int singlethread;

static int singlethread;

#pragma omp threadprivate(threadbase)

#pragma omp threadprivate(threadbase)

static unsigned cmask[THR];

static unsigned cmask[THR];

B& B::operator= (const B &b)

B& B::operator= (const B &b)

{

{

  unsigned sindex = &b - base;

  unsigned sindex = &b - base;

  unsigned tindex = this - threadbase;

  unsigned tindex = this - threadbase;

  assert(sindex < N);

  assert(sindex < N);

  assert(sindex == tindex);

  assert(sindex == tindex);

  cmask[omp_get_thread_num ()] |= 1u << tindex;

  cmask[omp_get_thread_num ()] |= 1u << tindex;

  return *this;

  return *this;

}

}

void foo()

void foo()

{

{

  #pragma omp parallel

  #pragma omp parallel

    {

    {

      B b[N];

      B b[N];

      threadbase = b;

      threadbase = b;

      #pragma omp single copyprivate(b)

      #pragma omp single copyprivate(b)

        {

        {

          assert(omp_get_num_threads () == THR);

          assert(omp_get_num_threads () == THR);

          singlethread = omp_get_thread_num ();

          singlethread = omp_get_thread_num ();

          base = b;

          base = b;

        }

        }

    }

    }

}

}

int main()

int main()

{

{

  omp_set_dynamic (0);

  omp_set_dynamic (0);

  omp_set_num_threads (THR);

  omp_set_num_threads (THR);

  foo();

  foo();

  for (int i = 0; i < THR; ++i)

  for (int i = 0; i < THR; ++i)

    if (i == singlethread)

    if (i == singlethread)

      assert(cmask[singlethread] == 0);

      assert(cmask[singlethread] == 0);

    else

    else

      assert(cmask[i] == (1u << N) - 1);

      assert(cmask[i] == (1u << N) - 1);

  return 0;

  return 0;

}

}