← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/xid.cc

  • Committer: Joe Daly
  • Date: 2010-01-06 02:20:42 UTC
  • mto: This revision was merged to the branch mainline in revision 1267.
  • Revision ID: skinny.moey@gmail.com-20100106022042-8ov23wc4aq8f9k7d
rename hash_algorithm to algorithm

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/xid.cc
22
22
 
23
23
#include <drizzled/my_hash.h>
24
24
#include <drizzled/xid.h>
 
25
#include "drizzled/internal/my_pthread.h"
25
26
#include "drizzled/charset.h"
26
27
#include "drizzled/global_charset_info.h"
27
28
#include "drizzled/charset_info.h"
28
29
 
29
 
#include <boost/thread/mutex.hpp>
30
 
 
31
 
namespace drizzled
32
 
{
 
30
XID::XID()
 
31
{}
33
32
 
34
33
bool XID::eq(XID *xid)
35
34
{
116
115
/***************************************************************************
117
116
  Handling of XA id cacheing
118
117
***************************************************************************/
119
 
boost::mutex LOCK_xid_cache;
 
118
pthread_mutex_t LOCK_xid_cache;
120
119
HASH xid_cache;
121
120
 
122
 
unsigned char *xid_get_hash_key(const unsigned char *, size_t *, bool);
123
 
void xid_free_hash(void *);
 
121
extern "C" unsigned char *xid_get_hash_key(const unsigned char *, size_t *, bool);
 
122
extern "C" void xid_free_hash(void *);
124
123
 
125
124
unsigned char *xid_get_hash_key(const unsigned char *ptr, size_t *length,
126
125
                        bool )
138
137
 
139
138
bool xid_cache_init()
140
139
{
 
140
  pthread_mutex_init(&LOCK_xid_cache, MY_MUTEX_INIT_FAST);
141
141
  return hash_init(&xid_cache, &my_charset_bin, 100, 0, 0,
142
142
                   xid_get_hash_key, xid_free_hash, 0) != 0;
143
143
}
147
147
  if (hash_inited(&xid_cache))
148
148
  {
149
149
    hash_free(&xid_cache);
 
150
    pthread_mutex_destroy(&LOCK_xid_cache);
150
151
  }
151
152
}
152
153
 
153
154
XID_STATE *xid_cache_search(XID *xid)
154
155
{
155
 
  LOCK_xid_cache.lock();
 
156
  pthread_mutex_lock(&LOCK_xid_cache);
156
157
  XID_STATE *res=(XID_STATE *)hash_search(&xid_cache, xid->key(), xid->key_length());
157
 
  LOCK_xid_cache.unlock();
 
158
  pthread_mutex_unlock(&LOCK_xid_cache);
158
159
  return res;
159
160
}
160
161
 
162
163
{
163
164
  XID_STATE *xs;
164
165
  bool res;
165
 
  LOCK_xid_cache.lock();
 
166
  pthread_mutex_lock(&LOCK_xid_cache);
166
167
  if (hash_search(&xid_cache, xid->key(), xid->key_length()))
167
 
  {
168
168
    res= false;
169
 
  }
170
169
  else if ((xs = new XID_STATE) == NULL)
171
 
  {
172
170
    res= true;
173
 
  }
174
171
  else
175
172
  {
176
173
    xs->xa_state=xa_state;
178
175
    xs->in_session=0;
179
176
    res= my_hash_insert(&xid_cache, (unsigned char*)xs);
180
177
  }
181
 
  LOCK_xid_cache.unlock();
 
178
  pthread_mutex_unlock(&LOCK_xid_cache);
182
179
  return res;
183
180
}
184
181
 
185
182
bool xid_cache_insert(XID_STATE *xid_state)
186
183
{
187
 
  LOCK_xid_cache.lock();
 
184
  pthread_mutex_lock(&LOCK_xid_cache);
188
185
  bool res=my_hash_insert(&xid_cache, (unsigned char*)xid_state);
189
 
  LOCK_xid_cache.unlock();
 
186
  pthread_mutex_unlock(&LOCK_xid_cache);
190
187
  return res;
191
188
}
192
189
 
193
190
void xid_cache_delete(XID_STATE *xid_state)
194
191
{
195
 
  LOCK_xid_cache.lock();
 
192
  pthread_mutex_lock(&LOCK_xid_cache);
196
193
  hash_delete(&xid_cache, (unsigned char *)xid_state);
197
 
  LOCK_xid_cache.unlock();
 
194
  pthread_mutex_unlock(&LOCK_xid_cache);
198
195
}
199
 
 
200
 
} /* namespace drizzled */