56#include <drizzled/internal/my_sys.h>
57#include <drizzled/internal/thread_var.h>
58#include <drizzled/statistics_variables.h>
59#include <drizzled/pthread_globals.h>
61#include <drizzled/session.h>
64#include <drizzled/internal/m_string.h>
70#include <drizzled/util/test.h>
72#include <boost/interprocess/sync/sharable_lock.hpp>
73#include <boost/version.hpp>
79uint64_t table_lock_wait_timeout;
80static enum thr_lock_type thr_upgraded_concurrent_insert_lock = TL_WRITE;
83uint64_t max_write_lock_count= UINT64_MAX;
100 lock->read.last= &lock->read.data;
101 lock->read_wait.last= &lock->read_wait.data;
102 lock->write_wait.last= &lock->write_wait.data;
103 lock->write.last= &lock->write.data;
107void THR_LOCK_INFO::init()
109 thread_id= internal::my_thread_var2()->id;
115void THR_LOCK_DATA::init(
THR_LOCK *lock_arg,
void *param_arg)
120 status_param= param_arg;
128 for ( ; data ; data=data->next)
130 if (thr_lock_owner_equal(data->owner, owner))
141 boost::condition_variable_any *cond= &session.getThreadVar()->suspend;
142 enum enum_thr_lock_result result= THR_LOCK_ABORTED;
143 bool can_deadlock= test(data->owner->info->n_cursors);
147 data->prev= wait->last;
148 wait->last= &data->next;
151 current_global_counters.locks_waited++;
154 session.getThreadVar()->current_mutex= data->lock->native_handle();
155 session.getThreadVar()->current_cond= &session.getThreadVar()->suspend;
156 data->cond= &session.getThreadVar()->suspend;;
158 while (not session.getThreadVar()->abort)
160 boost::mutex::scoped_lock scoped(*data->lock->native_handle(), boost::adopt_lock_t());
165#if BOOST_VERSION >= 105000
166 xtime_get(&xt, boost::TIME_UTC_);
168 xtime_get(&xt, boost::TIME_UTC);
170 xt.sec += table_lock_wait_timeout;
171 if (not cond->timed_wait(scoped, xt))
173 result= THR_LOCK_WAIT_TIMEOUT;
195 if (data->cond == NULL)
202 if (data->cond || data->type == TL_UNLOCK)
206 if (((*data->prev)=data->next))
208 data->next->prev= data->prev;
212 wait->last=data->prev;
214 data->type= TL_UNLOCK;
220 result= THR_LOCK_SUCCESS;
222 data->lock->unlock();
225 boost::mutex::scoped_lock scopedLock(session.getThreadVar()->mutex);
226 session.getThreadVar()->current_mutex= NULL;
227 session.getThreadVar()->current_cond= NULL;
236 enum enum_thr_lock_result result= THR_LOCK_SUCCESS;
242 data->type=lock_type;
245 if ((
int) lock_type <= (
int) TL_READ_NO_INSERT)
248 if (lock->write.data)
259 if (thr_lock_owner_equal(data->owner, lock->write.data->owner) ||
260 (lock->write.data->type <= TL_WRITE_CONCURRENT_INSERT &&
261 (((
int) lock_type <= (
int) TL_READ_WITH_SHARED_LOCKS) ||
262 (lock->write.data->type != TL_WRITE_CONCURRENT_INSERT &&
263 lock->write.data->type != TL_WRITE_ALLOW_READ))))
265 (*lock->read.last)=data;
266 data->prev=lock->read.last;
267 lock->read.last= &data->next;
268 if (lock_type == TL_READ_NO_INSERT)
269 lock->read_no_write_count++;
270 current_global_counters.locks_immediate++;
273 if (lock->write.data->type == TL_WRITE_ONLY)
276 data->type=TL_UNLOCK;
277 result= THR_LOCK_ABORTED;
281 else if (!lock->write_wait.data ||
282 lock->write_wait.data->type <= TL_WRITE_DEFAULT ||
283 have_old_read_lock(lock->read.data, data->owner))
285 (*lock->read.last)=data;
286 data->prev=lock->read.last;
287 lock->read.last= &data->next;
288 if (lock_type == TL_READ_NO_INSERT)
289 lock->read_no_write_count++;
290 current_global_counters.locks_immediate++;
298 wait_queue= &lock->read_wait;
302 if (lock_type == TL_WRITE_CONCURRENT_INSERT)
303 data->type=lock_type= thr_upgraded_concurrent_insert_lock;
305 if (lock->write.data)
307 if (lock->write.data->type == TL_WRITE_ONLY)
310 if (!thr_lock_owner_equal(data->owner, lock->write.data->owner))
313 data->type=TL_UNLOCK;
314 result= THR_LOCK_ABORTED;
324 if (thr_lock_owner_equal(data->owner, lock->write.data->owner) ||
325 (lock_type == TL_WRITE_ALLOW_WRITE &&
326 !lock->write_wait.data &&
327 lock->write.data->type == TL_WRITE_ALLOW_WRITE))
334 (*lock->write.last)=data;
335 data->prev=lock->write.last;
336 lock->write.last= &data->next;
337 current_global_counters.locks_immediate++;
343 if (!lock->write_wait.data)
345 if (!lock->read.data ||
346 (lock_type <= TL_WRITE_CONCURRENT_INSERT &&
347 ((lock_type != TL_WRITE_CONCURRENT_INSERT &&
348 lock_type != TL_WRITE_ALLOW_WRITE) ||
349 !lock->read_no_write_count)))
351 (*lock->write.last)=data;
352 data->prev=lock->write.last;
353 lock->write.last= &data->next;
354 current_global_counters.locks_immediate++;
359 wait_queue= &lock->write_wait;
367 lock_owner= lock->read.data ? lock->read.data : lock->write.data;
368 if (lock_owner && lock_owner->owner->info == owner->info)
370 result= THR_LOCK_DEADLOCK;
375 return(wait_for_lock(session, wait_queue, data));
384static void free_all_read_locks(
THR_LOCK *lock,
bool using_concurrent_insert)
389 (*lock->read.last)=data;
390 data->prev=lock->read.last;
391 lock->read.last=lock->read_wait.last;
394 lock->read_wait.last= &lock->read_wait.data;
398 boost::condition_variable_any *cond= data->cond;
399 if ((
int) data->type == (
int) TL_READ_NO_INSERT)
401 if (using_concurrent_insert)
407 if (((*data->prev)=data->next))
408 data->next->prev=data->prev;
410 lock->read.last=data->prev;
411 *lock->read_wait.last= data;
412 data->prev= lock->read_wait.last;
413 lock->read_wait.last= &data->next;
416 lock->read_no_write_count++;
420 }
while ((data=data->next));
421 *lock->read_wait.last=0;
422 if (!lock->read_wait.data)
423 lock->write_lock_count=0;
431 enum thr_lock_type lock_type=data->type;
434 if (((*data->prev)=data->next))
435 data->next->prev= data->prev;
436 else if (lock_type <= TL_READ_NO_INSERT)
437 lock->read.last=data->prev;
439 lock->write.last=data->prev;
440 if (lock_type >= TL_WRITE_CONCURRENT_INSERT)
444 if (lock_type == TL_READ_NO_INSERT)
445 lock->read_no_write_count--;
446 data->type=TL_UNLOCK;
463 enum thr_lock_type lock_type;
465 if (!lock->write.data)
467 data=lock->write_wait.data;
468 if (!lock->read.data)
472 (!lock->read_wait.data || lock->read_wait.data->type <= TL_READ_WITH_SHARED_LOCKS))
474 if (lock->write_lock_count++ > max_write_lock_count)
477 lock->write_lock_count=0;
478 if (lock->read_wait.data)
480 free_all_read_locks(lock,0);
486 if (((*data->prev)=data->next))
487 data->next->prev= data->prev;
489 lock->write_wait.last=data->prev;
490 (*lock->write.last)=data;
491 data->prev=lock->write.last;
493 lock->write.last= &data->next;
496 boost::condition_variable_any *cond= data->cond;
500 if (data->type != TL_WRITE_ALLOW_WRITE ||
501 !lock->write_wait.data ||
502 lock->write_wait.data->type != TL_WRITE_ALLOW_WRITE)
504 data=lock->write_wait.data;
506 if (data->type >= TL_WRITE)
510 if (lock->read_wait.data)
511 free_all_read_locks(lock,
513 (data->type == TL_WRITE_CONCURRENT_INSERT ||
514 data->type == TL_WRITE_ALLOW_WRITE));
517 (lock_type=data->type) <= TL_WRITE_CONCURRENT_INSERT &&
518 ((lock_type != TL_WRITE_CONCURRENT_INSERT &&
519 lock_type != TL_WRITE_ALLOW_WRITE) ||
520 !lock->read_no_write_count))
523 boost::condition_variable_any *cond= data->cond;
524 if (((*data->prev)=data->next))
525 data->next->prev= data->prev;
527 lock->write_wait.last=data->prev;
528 (*lock->write.last)=data;
529 data->prev=lock->write.last;
530 lock->write.last= &data->next;
534 }
while (lock_type == TL_WRITE_ALLOW_WRITE &&
535 (data=lock->write_wait.data) &&
536 data->type == TL_WRITE_ALLOW_WRITE);
537 if (lock->read_wait.data)
538 free_all_read_locks(lock,
539 (lock_type == TL_WRITE_CONCURRENT_INSERT ||
540 lock_type == TL_WRITE_ALLOW_WRITE));
542 else if (!data && lock->read_wait.data)
544 free_all_read_locks(lock,0);
559#define LOCK_CMP(A,B) ((unsigned char*) (A->lock) - (uint32_t) ((A)->type) < (unsigned char*) (B->lock)- (uint32_t) ((B)->type))
561static void sort_locks(THR_LOCK_DATA **data,uint32_t count)
563 THR_LOCK_DATA **pos,**end,**prev,*tmp;
567 for (pos=data+1,end=data+count; pos < end ; pos++)
570 if (LOCK_CMP(tmp,pos[-1]))
575 }
while (--prev != data && LOCK_CMP(tmp,prev[-1]));
582enum enum_thr_lock_result
587 sort_locks(data,count);
589 for (pos=data,end=data+count; pos < end ; pos++)
591 enum enum_thr_lock_result result= thr_lock(session, *pos, owner, (*pos)->type);
592 if (result != THR_LOCK_SUCCESS)
594 thr_multi_unlock(data,(uint32_t) (pos-data));
598 return(THR_LOCK_SUCCESS);
607 for (pos=data,end=data+count; pos < end ; pos++)
609 if ((*pos)->type != TL_UNLOCK)
614void DrizzleLock::unlock(uint32_t count)
616 THR_LOCK_DATA **pos,**end;
618 for (pos= getLocks(),end= getLocks()+count; pos < end ; pos++)
620 if ((*pos)->type != TL_UNLOCK)
630void THR_LOCK::abort_locks()
632 boost::mutex::scoped_lock scopedLock(mutex);
634 for (THR_LOCK_DATA *local_data= read_wait.data; local_data ; local_data= local_data->next)
636 local_data->type= TL_UNLOCK;
638 local_data->cond->notify_one();
639 local_data->cond= NULL;
641 for (THR_LOCK_DATA *local_data= write_wait.data; local_data ; local_data= local_data->next)
643 local_data->type= TL_UNLOCK;
644 local_data->cond->notify_one();
645 local_data->cond= NULL;
647 read_wait.last= &read_wait.data;
648 write_wait.last= &write_wait.data;
649 read_wait.data= write_wait.data=0;
651 write.data->type=TL_WRITE_ONLY;
661bool THR_LOCK::abort_locks_for_thread(uint64_t thread_id_arg)
665 boost::mutex::scoped_lock scopedLock(mutex);
666 for (THR_LOCK_DATA *local_data= read_wait.data; local_data ; local_data= local_data->next)
668 if (local_data->owner->info->thread_id == thread_id_arg)
670 local_data->type= TL_UNLOCK;
673 local_data->cond->notify_one();
676 if (((*local_data->prev)= local_data->next))
677 local_data->next->prev= local_data->prev;
679 read_wait.last= local_data->prev;
682 for (THR_LOCK_DATA *local_data= write_wait.data; local_data ; local_data= local_data->next)
684 if (local_data->owner->info->thread_id == thread_id_arg)
686 local_data->type= TL_UNLOCK;
688 local_data->cond->notify_one();
689 local_data->cond= NULL;
691 if (((*local_data->prev)= local_data->next))
692 local_data->next->prev= local_data->prev;
694 write_wait.last= local_data->prev;
TODO: Rename this file - func.h is stupid.
static void wake_up_waiters(THR_LOCK *lock)
Wake up all threads which pending requests for the lock can be satisfied.