OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [libgomp/] [critical.c] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 273 jeremybenn
/* Copyright (C) 2005, 2009 Free Software Foundation, Inc.
2
   Contributed by Richard Henderson <rth@redhat.com>.
3
 
4
   This file is part of the GNU OpenMP Library (libgomp).
5
 
6
   Libgomp is free software; you can redistribute it and/or modify it
7
   under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3, or (at your option)
9
   any later version.
10
 
11
   Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
12
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
13
   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14
   more details.
15
 
16
   Under Section 7 of GPL version 3, you are granted additional
17
   permissions described in the GCC Runtime Library Exception, version
18
   3.1, as published by the Free Software Foundation.
19
 
20
   You should have received a copy of the GNU General Public License and
21
   a copy of the GCC Runtime Library Exception along with this program;
22
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23
   <http://www.gnu.org/licenses/>.  */
24
 
25
/* This file handles the CRITICAL construct.  */
26
 
27
#include "libgomp.h"
28
#include <stdlib.h>
29
 
30
 
31
static gomp_mutex_t default_lock;
32
 
33
void
34
GOMP_critical_start (void)
35
{
36
  gomp_mutex_lock (&default_lock);
37
}
38
 
39
void
40
GOMP_critical_end (void)
41
{
42
  gomp_mutex_unlock (&default_lock);
43
}
44
 
45
#ifndef HAVE_SYNC_BUILTINS
46
static gomp_mutex_t create_lock_lock;
47
#endif
48
 
49
void
50
GOMP_critical_name_start (void **pptr)
51
{
52
  gomp_mutex_t *plock;
53
 
54
  /* If a mutex fits within the space for a pointer, and is zero initialized,
55
     then use the pointer space directly.  */
56
  if (GOMP_MUTEX_INIT_0
57
      && sizeof (gomp_mutex_t) <= sizeof (void *)
58
      && __alignof (gomp_mutex_t) <= sizeof (void *))
59
    plock = (gomp_mutex_t *)pptr;
60
 
61
  /* Otherwise we have to be prepared to malloc storage.  */
62
  else
63
    {
64
      plock = *pptr;
65
 
66
      if (plock == NULL)
67
        {
68
#ifdef HAVE_SYNC_BUILTINS
69
          gomp_mutex_t *nlock = gomp_malloc (sizeof (gomp_mutex_t));
70
          gomp_mutex_init (nlock);
71
 
72
          plock = __sync_val_compare_and_swap (pptr, NULL, nlock);
73
          if (plock != NULL)
74
            {
75
              gomp_mutex_destroy (nlock);
76
              free (nlock);
77
            }
78
          else
79
            plock = nlock;
80
#else
81
          gomp_mutex_lock (&create_lock_lock);
82
          plock = *pptr;
83
          if (plock == NULL)
84
            {
85
              plock = gomp_malloc (sizeof (gomp_mutex_t));
86
              gomp_mutex_init (plock);
87
              __sync_synchronize ();
88
              *pptr = plock;
89
            }
90
          gomp_mutex_unlock (&create_lock_lock);
91
#endif
92
        }
93
    }
94
 
95
  gomp_mutex_lock (plock);
96
}
97
 
98
void
99
GOMP_critical_name_end (void **pptr)
100
{
101
  gomp_mutex_t *plock;
102
 
103
  /* If a mutex fits within the space for a pointer, and is zero initialized,
104
     then use the pointer space directly.  */
105
  if (GOMP_MUTEX_INIT_0
106
      && sizeof (gomp_mutex_t) <= sizeof (void *)
107
      && __alignof (gomp_mutex_t) <= sizeof (void *))
108
    plock = (gomp_mutex_t *)pptr;
109
  else
110
    plock = *pptr;
111
 
112
  gomp_mutex_unlock (plock);
113
}
114
 
115
/* This mutex is used when atomic operations don't exist for the target
116
   in the mode requested.  The result is not globally atomic, but works so
117
   long as all parallel references are within #pragma omp atomic directives.
118
   According to responses received from omp@openmp.org, appears to be within
119
   spec.  Which makes sense, since that's how several other compilers
120
   handle this situation as well.  */
121
 
122
static gomp_mutex_t atomic_lock;
123
 
124
void
125
GOMP_atomic_start (void)
126
{
127
  gomp_mutex_lock (&atomic_lock);
128
}
129
 
130
void
131
GOMP_atomic_end (void)
132
{
133
  gomp_mutex_unlock (&atomic_lock);
134
}
135
 
136
#if !GOMP_MUTEX_INIT_0
137
static void __attribute__((constructor))
138
initialize_critical (void)
139
{
140
  gomp_mutex_init (&default_lock);
141
  gomp_mutex_init (&atomic_lock);
142
#ifndef HAVE_SYNC_BUILTINS
143
  gomp_mutex_init (&create_lock_lock);
144
#endif
145
}
146
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.