← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/sync0rw.ic

Merge Joe, plus I updated the tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/sync0rw.ic
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1995, 2009, Innobase Oy. All Rights Reserved.
4
 
Copyright (C) 2008, Google Inc.
 
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
 
4
Copyright (c) 2008, Google Inc.
5
5
 
6
6
Portions of this file contain modifications contributed and copyrighted by
7
7
Google, Inc. Those modifications are gratefully acknowledged and are described
18
18
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
19
19
 
20
20
You should have received a copy of the GNU General Public License along with
21
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
22
 
St, Fifth Floor, Boston, MA 02110-1301 USA
 
21
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
22
Place, Suite 330, Boston, MA 02111-1307 USA
23
23
 
24
24
*****************************************************************************/
25
25
 
625
625
        rw_x_exit_count++;
626
626
#endif
627
627
}
628
 
 
629
 
#ifdef UNIV_PFS_RWLOCK
630
 
 
631
 
/******************************************************************//**
632
 
Performance schema instrumented wrap function for rw_lock_create_func().
633
 
NOTE! Please use the corresponding macro rw_lock_create(), not directly
634
 
this function! */
635
 
UNIV_INLINE
636
 
void
637
 
pfs_rw_lock_create_func(
638
 
/*====================*/
639
 
        mysql_pfs_key_t key,            /*!< in: key registered with
640
 
                                        performance schema */
641
 
        rw_lock_t*      lock,           /*!< in: pointer to memory */
642
 
# ifdef UNIV_DEBUG
643
 
#  ifdef UNIV_SYNC_DEBUG
644
 
        ulint           level,          /*!< in: level */
645
 
#  endif /* UNIV_SYNC_DEBUG */
646
 
        const char*     cmutex_name,    /*!< in: mutex name */
647
 
# endif /* UNIV_DEBUG */
648
 
        const char*     cfile_name,     /*!< in: file name where created */
649
 
        ulint           cline)          /*!< in: file line where created */
650
 
{
651
 
        /* Initialize the rwlock for performance schema */
652
 
        lock->pfs_psi = (PSI_server && PFS_IS_INSTRUMENTED(key))
653
 
                                ? PSI_server->init_rwlock(key, lock)
654
 
                                : NULL;
655
 
 
656
 
        /* The actual function to initialize an rwlock */
657
 
        rw_lock_create_func(lock,
658
 
# ifdef UNIV_DEBUG
659
 
#  ifdef UNIV_SYNC_DEBUG
660
 
                            level,
661
 
#  endif /* UNIV_SYNC_DEBUG */
662
 
                            cmutex_name,
663
 
# endif /* UNIV_DEBUG */
664
 
                            cfile_name,
665
 
                            cline);
666
 
}
667
 
/******************************************************************//**
668
 
Performance schema instrumented wrap function for rw_lock_x_lock_func()
669
 
NOTE! Please use the corresponding macro rw_lock_x_lock(), not directly
670
 
this function! */
671
 
UNIV_INLINE
672
 
void
673
 
pfs_rw_lock_x_lock_func(
674
 
/*====================*/
675
 
        rw_lock_t*      lock,   /*!< in: pointer to rw-lock */
676
 
        ulint           pass,   /*!< in: pass value; != 0, if the lock will
677
 
                                be passed to another thread to unlock */
678
 
        const char*     file_name,/*!< in: file name where lock requested */
679
 
        ulint           line)   /*!< in: line where requested */
680
 
{
681
 
        struct PSI_rwlock_locker*       locker = NULL;
682
 
        PSI_rwlock_locker_state         state;
683
 
 
684
 
        /* Record the entry of rw x lock request in performance schema */
685
 
        if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) {
686
 
                locker = PSI_server->get_thread_rwlock_locker(
687
 
                        &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK);
688
 
 
689
 
                if (locker) {
690
 
                        PSI_server->start_rwlock_wrwait(locker,
691
 
                                                        file_name, line);
692
 
                }
693
 
        }
694
 
 
695
 
        rw_lock_x_lock_func(lock, pass, file_name, line);
696
 
 
697
 
        if (locker) {
698
 
                PSI_server->end_rwlock_wrwait(locker, 0);
699
 
        }
700
 
}
701
 
/******************************************************************//**
702
 
Performance schema instrumented wrap function for
703
 
rw_lock_x_lock_func_nowait()
704
 
NOTE! Please use the corresponding macro rw_lock_x_lock_func(),
705
 
not directly this function!
706
 
@return TRUE if success */
707
 
UNIV_INLINE
708
 
ibool
709
 
pfs_rw_lock_x_lock_func_nowait(
710
 
/*===========================*/
711
 
        rw_lock_t*      lock,   /*!< in: pointer to rw-lock */
712
 
        const char*     file_name,/*!< in: file name where lock
713
 
                                requested */
714
 
        ulint           line)   /*!< in: line where requested */
715
 
{
716
 
        struct PSI_rwlock_locker*       locker = NULL;
717
 
        PSI_rwlock_locker_state         state;
718
 
        ibool   ret;
719
 
 
720
 
        /* Record the entry of rw x lock request in performance schema */
721
 
        if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) {
722
 
                locker = PSI_server->get_thread_rwlock_locker(
723
 
                        &state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK);
724
 
 
725
 
                if (locker) {
726
 
                        PSI_server->start_rwlock_wrwait(locker,
727
 
                                                        file_name, line);
728
 
                }
729
 
        }
730
 
 
731
 
        ret = rw_lock_x_lock_func_nowait(lock, file_name, line);
732
 
 
733
 
        if (locker) {
734
 
                PSI_server->end_rwlock_wrwait(locker, 0);
735
 
        }
736
 
 
737
 
        return(ret);
738
 
}
739
 
/******************************************************************//**
740
 
Performance schema instrumented wrap function for rw_lock_free_func()
741
 
NOTE! Please use the corresponding macro rw_lock_free(), not directly
742
 
this function! */
743
 
UNIV_INLINE
744
 
void
745
 
pfs_rw_lock_free_func(
746
 
/*==================*/
747
 
        rw_lock_t*      lock)   /*!< in: pointer to rw-lock */
748
 
{
749
 
        if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) {
750
 
                PSI_server->destroy_rwlock(lock->pfs_psi);
751
 
                lock->pfs_psi = NULL;
752
 
        }
753
 
 
754
 
        rw_lock_free_func(lock);
755
 
}
756
 
/******************************************************************//**
757
 
Performance schema instrumented wrap function for rw_lock_s_lock_func()
758
 
NOTE! Please use the corresponding macro rw_lock_s_lock(), not
759
 
directly this function! */
760
 
UNIV_INLINE
761
 
void
762
 
pfs_rw_lock_s_lock_func(
763
 
/*====================*/
764
 
        rw_lock_t*      lock,   /*!< in: pointer to rw-lock */
765
 
        ulint           pass,   /*!< in: pass value; != 0, if the
766
 
                                lock will be passed to another
767
 
                                thread to unlock */
768
 
        const char*     file_name,/*!< in: file name where lock
769
 
                                requested */
770
 
        ulint           line)   /*!< in: line where requested */
771
 
{
772
 
        struct PSI_rwlock_locker*       locker = NULL;
773
 
        PSI_rwlock_locker_state         state;
774
 
 
775
 
        /* Instrumented to inform we are aquiring a shared rwlock */
776
 
        if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) {
777
 
                locker = PSI_server->get_thread_rwlock_locker(
778
 
                        &state, lock->pfs_psi, PSI_RWLOCK_READLOCK);
779
 
                if (locker) {
780
 
                        PSI_server->start_rwlock_rdwait(locker,
781
 
                                                        file_name, line);
782
 
                }
783
 
        }
784
 
 
785
 
        rw_lock_s_lock_func(lock, pass, file_name, line);
786
 
 
787
 
        if (locker) {
788
 
                PSI_server->end_rwlock_rdwait(locker, 0);
789
 
        }
790
 
}
791
 
/******************************************************************//**
792
 
Performance schema instrumented wrap function for rw_lock_s_lock_func()
793
 
NOTE! Please use the corresponding macro rw_lock_s_lock(), not
794
 
directly this function!
795
 
@return TRUE if success */
796
 
UNIV_INLINE
797
 
ibool
798
 
pfs_rw_lock_s_lock_low(
799
 
/*===================*/
800
 
        rw_lock_t*      lock,   /*!< in: pointer to rw-lock */
801
 
        ulint           pass,   /*!< in: pass value; != 0, if the
802
 
                                lock will be passed to another
803
 
                                thread to unlock */
804
 
        const char*     file_name, /*!< in: file name where lock requested */
805
 
        ulint           line)   /*!< in: line where requested */
806
 
{
807
 
        struct PSI_rwlock_locker*       locker = NULL;
808
 
        PSI_rwlock_locker_state         state;
809
 
        ibool   ret;
810
 
 
811
 
        /* Instrumented to inform we are aquiring a shared rwlock */
812
 
        if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) {
813
 
                locker = PSI_server->get_thread_rwlock_locker(
814
 
                        &state, lock->pfs_psi, PSI_RWLOCK_READLOCK);
815
 
                if (locker) {
816
 
                        PSI_server->start_rwlock_rdwait(locker,
817
 
                                                        file_name, line);
818
 
                }
819
 
        }
820
 
 
821
 
        ret = rw_lock_s_lock_low(lock, pass, file_name, line);
822
 
 
823
 
        if (locker) {
824
 
                PSI_server->end_rwlock_rdwait(locker, 0);
825
 
        }
826
 
 
827
 
        return(ret);
828
 
}
829
 
 
830
 
/******************************************************************//**
831
 
Performance schema instrumented wrap function for rw_lock_x_unlock_func()
832
 
NOTE! Please use the corresponding macro rw_lock_x_unlock(), not directly
833
 
this function! */
834
 
UNIV_INLINE
835
 
void
836
 
pfs_rw_lock_x_unlock_func(
837
 
/*======================*/
838
 
#ifdef UNIV_SYNC_DEBUG
839
 
        ulint           pass,   /*!< in: pass value; != 0, if the
840
 
                                lock may have been passed to another
841
 
                                thread to unlock */
842
 
#endif
843
 
        rw_lock_t*      lock)   /*!< in/out: rw-lock */
844
 
{
845
 
        /* Inform performance schema we are unlocking the lock */
846
 
        if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) {
847
 
                PSI_server->unlock_rwlock(lock->pfs_psi);
848
 
        }
849
 
 
850
 
        rw_lock_x_unlock_func(
851
 
#ifdef UNIV_SYNC_DEBUG
852
 
                pass,
853
 
#endif
854
 
                lock);
855
 
}
856
 
 
857
 
/******************************************************************//**
858
 
Performance schema instrumented wrap function for rw_lock_s_unlock_func()
859
 
NOTE! Please use the corresponding macro pfs_rw_lock_s_unlock(), not
860
 
directly this function! */
861
 
UNIV_INLINE
862
 
void
863
 
pfs_rw_lock_s_unlock_func(
864
 
/*======================*/
865
 
#ifdef UNIV_SYNC_DEBUG
866
 
        ulint           pass,   /*!< in: pass value; != 0, if the
867
 
                                lock may have been passed to another
868
 
                                thread to unlock */
869
 
#endif
870
 
        rw_lock_t*      lock)   /*!< in/out: rw-lock */
871
 
{
872
 
        /* Inform performance schema we are unlocking the lock */
873
 
        if (UNIV_LIKELY(PSI_server && lock->pfs_psi)) {
874
 
                PSI_server->unlock_rwlock(lock->pfs_psi);
875
 
        }
876
 
 
877
 
        rw_lock_s_unlock_func(
878
 
#ifdef UNIV_SYNC_DEBUG
879
 
                pass,
880
 
#endif
881
 
                lock);
882
 
 
883
 
}
884
 
#endif /* UNIV_PFS_RWLOCK */