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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libitm/] [clone.cc] - Blame information for rev 848

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 737 jeremybenn
/* Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
2
   Contributed by Richard Henderson <rth@redhat.com>.
3
 
4
   This file is part of the GNU Transactional Memory Library (libitm).
5
 
6
   Libitm 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 of the License, or
9
   (at your option) any later version.
10
 
11
   Libitm 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
#include "libitm_i.h"
26
 
27
using namespace GTM;
28
 
29
struct clone_entry
30
{
31
  void *orig, *clone;
32
};
33
 
34
struct clone_table
35
{
36
  clone_entry *table;
37
  size_t size;
38
  clone_table *next;
39
};
40
 
41
static clone_table *all_tables;
42
 
43
static void *
44
find_clone (void *ptr)
45
{
46
  clone_table *table;
47
 
48
  for (table = all_tables; table ; table = table->next)
49
    {
50
      clone_entry *t = table->table;
51
      size_t lo = 0, hi = table->size, i;
52
 
53
      /* Quick test for whether PTR is present in this table.  */
54
      if (ptr < t[0].orig || ptr > t[hi - 1].orig)
55
        continue;
56
 
57
      /* Otherwise binary search.  */
58
      while (lo < hi)
59
        {
60
          i = (lo + hi) / 2;
61
          if (ptr < t[i].orig)
62
            hi = i;
63
          else if (ptr > t[i].orig)
64
            lo = i + 1;
65
          else
66
            return t[i].clone;
67
        }
68
 
69
      /* Given the quick test above, if we don't find the entry in
70
         this table then it doesn't exist.  */
71
      break;
72
    }
73
 
74
  return NULL;
75
}
76
 
77
 
78
void * ITM_REGPARM
79
_ITM_getTMCloneOrIrrevocable (void *ptr)
80
{
81
  void *ret = find_clone (ptr);
82
  if (ret)
83
    return ret;
84
 
85
  gtm_thr()->serialirr_mode ();
86
 
87
  return ptr;
88
}
89
 
90
void * ITM_REGPARM
91
_ITM_getTMCloneSafe (void *ptr)
92
{
93
  void *ret = find_clone (ptr);
94
  if (ret == NULL)
95
    abort ();
96
  return ret;
97
}
98
 
99
static int
100
clone_entry_compare (const void *a, const void *b)
101
{
102
  const clone_entry *aa = (const clone_entry *)a;
103
  const clone_entry *bb = (const clone_entry *)b;
104
 
105
  if (aa->orig < bb->orig)
106
    return -1;
107
  else if (aa->orig > bb->orig)
108
    return 1;
109
  else
110
    return 0;
111
}
112
 
113
namespace {
114
 
115
// Within find_clone, we know that we are inside a transaction.  Because
116
// of that, we have already synchronized with serial_lock.  By taking the
117
// serial_lock for write, we exclude all transactions while we make this
118
// change to the clone tables, without having to synchronize on a separate
119
// lock.  Do be careful not to attempt a recursive write lock.
120
 
121
class ExcludeTransaction
122
{
123
  bool do_lock;
124
 
125
 public:
126
  ExcludeTransaction()
127
  {
128
    gtm_thread *tx = gtm_thr();
129
    do_lock = !(tx && (tx->state & gtm_thread::STATE_SERIAL));
130
 
131
    if (do_lock)
132
      gtm_thread::serial_lock.write_lock ();
133
  }
134
 
135
  ~ExcludeTransaction()
136
  {
137
    if (do_lock)
138
      gtm_thread::serial_lock.write_unlock ();
139
  }
140
};
141
 
142
} // end anon namespace
143
 
144
 
145
void
146
_ITM_registerTMCloneTable (void *xent, size_t size)
147
{
148
  clone_entry *ent = static_cast<clone_entry *>(xent);
149
  clone_table *table;
150
 
151
  table = (clone_table *) xmalloc (sizeof (clone_table));
152
  table->table = ent;
153
  table->size = size;
154
 
155
  qsort (ent, size, sizeof (clone_entry), clone_entry_compare);
156
 
157
  // Hold the serial_lock while we update the ALL_TABLES datastructure.
158
  {
159
    ExcludeTransaction exclude;
160
    table->next = all_tables;
161
    all_tables = table;
162
  }
163
}
164
 
165
void
166
_ITM_deregisterTMCloneTable (void *xent)
167
{
168
  clone_entry *ent = static_cast<clone_entry *>(xent);
169
  clone_table *tab;
170
 
171
  // Hold the serial_lock while we update the ALL_TABLES datastructure.
172
  {
173
    ExcludeTransaction exclude;
174
    clone_table **pprev;
175
 
176
    for (pprev = &all_tables;
177
         tab = *pprev, tab->table != ent;
178
         pprev = &tab->next)
179
      continue;
180
    *pprev = tab->next;
181
  }
182
 
183
  free (tab);
184
}

powered by: WebSVN 2.1.0

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