← Back to branch summary

~drizzle-pbxt/drizzle/drizzle-pbxt-2

« back to all changes in this revision

Viewing changes to mysys/thr_lock.cc

  • Committer: Paul McCullagh
  • Date: 2009-11-10 14:18:39 UTC
  • mfrom: (1038.1.7 drizzle-pbxt-pre-merge)
  • Revision ID: paul.mccullagh@primebase.org-20091110141839-2j3k43b17ag6f605
Merged Drizzle trunk and PBXT 1.0.09

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/thr_lock.cc
87
87
 
88
88
using namespace std;
89
89
 
90
 
bool thr_lock_inited=0;
 
90
bool thr_lock_inited= false;
91
91
uint32_t locks_immediate = 0L, locks_waited = 0L;
92
92
uint64_t table_lock_wait_timeout;
93
 
enum thr_lock_type thr_upgraded_concurrent_insert_lock = TL_WRITE;
 
93
static enum thr_lock_type thr_upgraded_concurrent_insert_lock = TL_WRITE;
94
94
 
95
95
 
96
96
static list<THR_LOCK *> thr_lock_thread_list;          /* List of threads in use */
108
108
 
109
109
bool init_thr_lock()
110
110
{
111
 
  thr_lock_inited=1;
112
 
  return 0;
 
111
  thr_lock_inited= true;
 
112
 
 
113
  return false;
113
114
}
114
115
 
115
116
static inline bool
133
134
  pthread_mutex_lock(&THR_LOCK_lock);           /* Add to locks in use */
134
135
  thr_lock_thread_list.push_front(lock);
135
136
  pthread_mutex_unlock(&THR_LOCK_lock);
136
 
  return;
137
137
}
138
138
 
139
139
 
143
143
  pthread_mutex_lock(&THR_LOCK_lock);
144
144
  thr_lock_thread_list.remove(lock);
145
145
  pthread_mutex_unlock(&THR_LOCK_lock);
146
 
  return;
147
146
}
148
147
 
149
148
 
150
149
void thr_lock_info_init(THR_LOCK_INFO *info)
151
150
{
152
151
  struct st_my_thread_var *tmp= my_thread_var;
153
 
  info->thread=    tmp->pthread_self;
 
152
  info->thread= tmp->pthread_self;
154
153
  info->thread_id= tmp->id;
155
154
  info->n_cursors= 0;
156
155
}
159
158
 
160
159
void thr_lock_data_init(THR_LOCK *lock,THR_LOCK_DATA *data, void *param)
161
160
{
162
 
  data->lock=lock;
163
 
  data->type=TL_UNLOCK;
164
 
  data->owner= 0;                               /* no owner yet */
165
 
  data->status_param=param;
166
 
  data->cond=0;
 
161
  data->lock= lock;
 
162
  data->type= TL_UNLOCK;
 
163
  data->owner= NULL;                               /* no owner yet */
 
164
  data->status_param= param;
 
165
  data->cond= NULL;
167
166
}
168
167
 
169
168
 
173
172
  for ( ; data ; data=data->next)
174
173
  {
175
174
    if (thr_lock_owner_equal(data->owner, owner))
176
 
      return 1;                                 /* Already locked by thread */
 
175
      return true;                                      /* Already locked by thread */
177
176
  }
178
 
  return 0;
 
177
  return false;
179
178
}
180
179
 
181
180
static void wake_up_waiters(THR_LOCK *lock);
232
231
    }
233
232
    if (rc == ETIMEDOUT || rc == ETIME)
234
233
    {
235
 
      /* purecov: begin inspected */
236
234
      result= THR_LOCK_WAIT_TIMEOUT;
237
235
      break;
238
 
      /* purecov: end */
239
236
    }
240
237
  }
241
238
  if (data->cond || data->type == TL_UNLOCK)
260
257
 
261
258
  /* The following must be done after unlock of lock->mutex */
262
259
  pthread_mutex_lock(&thread_var->mutex);
263
 
  thread_var->current_mutex= 0;
264
 
  thread_var->current_cond=  0;
 
260
  thread_var->current_mutex= NULL;
 
261
  thread_var->current_cond= NULL;
265
262
  pthread_mutex_unlock(&thread_var->mutex);
266
263
  return(result);
267
264
}
268
265
 
269
266
 
270
 
enum enum_thr_lock_result
 
267
static enum enum_thr_lock_result
271
268
thr_lock(THR_LOCK_DATA *data, THR_LOCK_OWNER *owner,
272
269
         enum thr_lock_type lock_type)
273
270
{
480
477
 
481
478
        /* Unlock lock and free next thread on same lock */
482
479
 
483
 
void thr_unlock(THR_LOCK_DATA *data)
 
480
static void thr_unlock(THR_LOCK_DATA *data)
484
481
{
485
482
  THR_LOCK *lock=data->lock;
486
483
  enum thr_lock_type lock_type=data->type;
738
735
  TL_WRITE_ONLY to abort any new accesses to the lock
739
736
*/
740
737
 
741
 
void thr_abort_locks(THR_LOCK *lock, bool upgrade_lock)
 
738
void thr_abort_locks(THR_LOCK *lock)
742
739
{
743
740
  THR_LOCK_DATA *data;
744
741
  pthread_mutex_lock(&lock->mutex);
745
742
 
746
743
  for (data=lock->read_wait.data; data ; data=data->next)
747
744
  {
748
 
    data->type=TL_UNLOCK;                       /* Mark killed */
 
745
    data->type= TL_UNLOCK;                      /* Mark killed */
749
746
    /* It's safe to signal the cond first: we're still holding the mutex. */
750
747
    pthread_cond_signal(data->cond);
751
 
    data->cond=0;                               /* Removed from list */
 
748
    data->cond= NULL;                           /* Removed from list */
752
749
  }
753
750
  for (data=lock->write_wait.data; data ; data=data->next)
754
751
  {
755
752
    data->type=TL_UNLOCK;
756
753
    pthread_cond_signal(data->cond);
757
 
    data->cond=0;
 
754
    data->cond= NULL;
758
755
  }
759
756
  lock->read_wait.last= &lock->read_wait.data;
760
757
  lock->write_wait.last= &lock->write_wait.data;
761
758
  lock->read_wait.data=lock->write_wait.data=0;
762
 
  if (upgrade_lock && lock->write.data)
 
759
  if (lock->write.data)
763
760
    lock->write.data->type=TL_WRITE_ONLY;
764
761
  pthread_mutex_unlock(&lock->mutex);
765
762
  return;
780
777
  pthread_mutex_lock(&lock->mutex);
781
778
  for (data= lock->read_wait.data; data ; data= data->next)
782
779
  {
783
 
    if (data->owner->info->thread_id == thread_id)    /* purecov: tested */
 
780
    if (data->owner->info->thread_id == thread_id)
784
781
    {
785
782
      data->type= TL_UNLOCK;                    /* Mark killed */
786
783
      /* It's safe to signal the cond first: we're still holding the mutex. */
796
793
  }
797
794
  for (data= lock->write_wait.data; data ; data= data->next)
798
795
  {
799
 
    if (data->owner->info->thread_id == thread_id) /* purecov: tested */
 
796
    if (data->owner->info->thread_id == thread_id)
800
797
    {
801
798
      data->type= TL_UNLOCK;
802
799
      found= true;
803
800
      pthread_cond_signal(data->cond);
804
 
      data->cond= 0;
 
801
      data->cond= NULL;
805
802
 
806
803
      if (((*data->prev)= data->next))
807
804
        data->next->prev= data->prev;