List:Commits« Previous MessageNext Message »
From:Christopher Powers Date:July 12 2010 7:30pm
Subject:Re: bzr commit into mysql-trunk-bugfixing branch (marc.alff:3103)
Bug#55087
View as plain text  
Ok to push pending ok from Jimmy Yang.


On 7/9/10 6:00 PM, Marc Alff wrote:
> #At file:///home/malff/BZR_TREE/mysql-trunk-bugfixing-55087/ based on
> revid:davi.arnaut@stripped
>
>   3103 Marc Alff	2010-07-09
>        Bug#55087 Performance schema: optimization of the instrumentation interface
>
>        This change is for performance optimization.
>
>        Fixed the performance schema instrumentation interface as follows:
>        - simplified mysql_unlock_mutex()
>        - simplified mysql_unlock_rwlock()
>        - simplified mysql_cond_signal()
>        - simplified mysql_cond_broadcast()
>
>        Changed the get_thread_XXX_locker apis to have one extra parameter,
>        to provide memory to the instrumentation implementation.
>        This API change allows to use memory provided by the caller,
>        to avoid having to use thread local storage.
>        Using this extra parameter will be done in a separate fix,
>        this change is for the interface only.
>
>        Adjusted all the code and unit tests accordingly.
>
>      modified:
>        include/mysql/psi/mysql_file.h
>        include/mysql/psi/mysql_thread.h
>        include/mysql/psi/psi.h
>        include/mysql/psi/psi_abi_v1.h.pp
>        include/mysql/psi/psi_abi_v2.h.pp
>        storage/innobase/include/os0file.h
>        storage/innobase/include/os0file.ic
>        storage/innobase/include/sync0rw.ic
>        storage/innobase/include/sync0sync.ic
>        storage/innobase/row/row0merge.c
>        storage/perfschema/pfs.cc
>        storage/perfschema/unittest/pfs-t.cc
> === modified file 'include/mysql/psi/mysql_file.h'
> --- a/include/mysql/psi/mysql_file.h	2010-07-08 21:20:08 +0000
> +++ b/include/mysql/psi/mysql_file.h	2010-07-09 23:00:24 +0000
> @@ -506,9 +506,10 @@ inline_mysql_file_fgets(
>     char *result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_READ);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) size, src_file, src_line);
> @@ -532,9 +533,10 @@ inline_mysql_file_fgetc(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_READ);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 1, src_file, src_line);
> @@ -558,10 +560,11 @@ inline_mysql_file_fputs(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     size_t bytes= 0;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_WRITE);
>       if (likely(locker != NULL))
>       {
> @@ -588,9 +591,10 @@ inline_mysql_file_fputc(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_WRITE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 1, src_file, src_line);
> @@ -614,9 +618,10 @@ inline_mysql_file_fprintf(MYSQL_FILE *fi
>     va_list args;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_WRITE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, __FILE__, __LINE__);
> @@ -642,9 +647,10 @@ inline_mysql_file_vfprintf(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_WRITE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -668,9 +674,10 @@ inline_mysql_file_fflush(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_FLUSH);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -700,9 +707,10 @@ inline_mysql_file_fstat(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(filenr,
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, filenr,
>                                                             PSI_FILE_FSTAT);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -726,9 +734,11 @@ inline_mysql_file_stat(
>     MY_STAT *result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_STAT,
> +    locker= PSI_server->get_thread_file_name_locker(&state,
> +                                                    key, PSI_FILE_STAT,
>                                                       path,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_open_wait(locker, src_file, src_line);
> @@ -752,9 +762,10 @@ inline_mysql_file_chsize(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file,
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
>                                                             PSI_FILE_CHSIZE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) newlength, src_file,
> @@ -784,10 +795,11 @@ inline_mysql_file_fopen(
>       {
>   #ifdef HAVE_PSI_INTERFACE
>         struct PSI_file_locker *locker= NULL;
> +      PSI_file_locker_state state;
>         if (likely(PSI_server != NULL))
>         {
>           locker= PSI_server->get_thread_file_name_locker
> -          (key, PSI_FILE_STREAM_OPEN, filename, that);
> +          (&state, key, PSI_FILE_STREAM_OPEN, filename, that);
>           if (likely(locker != NULL))
>             that->m_psi= PSI_server->start_file_open_wait(locker, src_file,
>                                                           src_line);
> @@ -820,10 +832,11 @@ inline_mysql_file_fclose(
>     {
>   #ifdef HAVE_PSI_INTERFACE
>       struct PSI_file_locker *locker= NULL;
> +    PSI_file_locker_state state;
>       DBUG_ASSERT(file != NULL);
>       if (likely(PSI_server&&  file->m_psi))
>       {
> -      locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +      locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                           PSI_FILE_STREAM_CLOSE);
>         if (likely(locker != NULL))
>           PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -849,9 +862,10 @@ inline_mysql_file_fread(
>     size_t result= 0;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_READ);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, count, src_file, src_line);
> @@ -882,9 +896,10 @@ inline_mysql_file_fwrite(
>     size_t result= 0;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_WRITE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, count, src_file, src_line);
> @@ -915,9 +930,10 @@ inline_mysql_file_fseek(
>     my_off_t result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_SEEK);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -941,9 +957,10 @@ inline_mysql_file_ftell(
>     my_off_t result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server&&  file->m_psi))
>     {
> -    locker= PSI_server->get_thread_file_stream_locker(file->m_psi,
> +    locker= PSI_server->get_thread_file_stream_locker(&state,
> file->m_psi,
>                                                         PSI_FILE_TELL);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -967,9 +984,10 @@ inline_mysql_file_create(
>     File file;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_CREATE,
> +    locker= PSI_server->get_thread_file_name_locker(&state, key,
> PSI_FILE_CREATE,
>                                                       filename,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_open_wait(locker, src_file, src_line);
> @@ -1014,9 +1032,10 @@ inline_mysql_file_open(
>     File file;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_OPEN,
> +    locker= PSI_server->get_thread_file_name_locker(&state, key,
> PSI_FILE_OPEN,
>                                                       filename,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_open_wait(locker, src_file, src_line);
> @@ -1040,9 +1059,10 @@ inline_mysql_file_close(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file,
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
>                                                             PSI_FILE_CLOSE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -1066,9 +1086,10 @@ inline_mysql_file_read(
>     size_t result= 0;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file,
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
>                                                             PSI_FILE_READ);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, count, src_file, src_line);
> @@ -1099,9 +1120,10 @@ inline_mysql_file_write(
>     size_t result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file,
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
>                                                             PSI_FILE_WRITE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, count, src_file, src_line);
> @@ -1132,9 +1154,10 @@ inline_mysql_file_pread(
>     size_t result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file, PSI_FILE_READ);
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
> PSI_FILE_READ);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, count, src_file, src_line);
>     }
> @@ -1164,9 +1187,10 @@ inline_mysql_file_pwrite(
>     size_t result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file,
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
>                                                             PSI_FILE_WRITE);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, count, src_file, src_line);
> @@ -1197,9 +1221,10 @@ inline_mysql_file_seek(
>     my_off_t result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file, PSI_FILE_SEEK);
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
> PSI_FILE_SEEK);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
>     }
> @@ -1222,9 +1247,10 @@ inline_mysql_file_tell(
>     my_off_t result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(file, PSI_FILE_TELL);
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, file,
> PSI_FILE_TELL);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
>     }
> @@ -1247,9 +1273,10 @@ inline_mysql_file_delete(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_DELETE,
> +    locker= PSI_server->get_thread_file_name_locker(&state, key,
> PSI_FILE_DELETE,
>                                                       name,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -1273,9 +1300,10 @@ inline_mysql_file_rename(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_RENAME,
> +    locker= PSI_server->get_thread_file_name_locker(&state, key,
> PSI_FILE_RENAME,
>                                                       to,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -1300,9 +1328,10 @@ inline_mysql_file_create_with_symlink(
>     File file;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_CREATE,
> +    locker= PSI_server->get_thread_file_name_locker(&state, key,
> PSI_FILE_CREATE,
>                                                       filename,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_open_wait(locker, src_file, src_line);
> @@ -1327,9 +1356,10 @@ inline_mysql_file_delete_with_symlink(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_DELETE,
> +    locker= PSI_server->get_thread_file_name_locker(&state, key,
> PSI_FILE_DELETE,
>                                                       name,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -1353,9 +1383,10 @@ inline_mysql_file_rename_with_symlink(
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_name_locker(key, PSI_FILE_RENAME,
> +    locker= PSI_server->get_thread_file_name_locker(&state, key,
> PSI_FILE_RENAME,
>                                                       to,&locker);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
> @@ -1379,9 +1410,10 @@ inline_mysql_file_sync(
>     int result= 0;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_file_locker *locker= NULL;
> +  PSI_file_locker_state state;
>     if (likely(PSI_server != NULL))
>     {
> -    locker= PSI_server->get_thread_file_descriptor_locker(fd, PSI_FILE_SYNC);
> +    locker= PSI_server->get_thread_file_descriptor_locker(&state, fd,
> PSI_FILE_SYNC);
>       if (likely(locker != NULL))
>         PSI_server->start_file_wait(locker, (size_t) 0, src_file, src_line);
>     }
>
> === modified file 'include/mysql/psi/mysql_thread.h'
> --- a/include/mysql/psi/mysql_thread.h	2010-07-08 17:04:07 +0000
> +++ b/include/mysql/psi/mysql_thread.h	2010-07-09 23:00:24 +0000
> @@ -625,9 +625,10 @@ static inline int inline_mysql_mutex_loc
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_mutex_locker *locker= NULL;
> +  PSI_mutex_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_mutex_locker(that->m_psi, PSI_MUTEX_LOCK);
> +    locker= PSI_server->get_thread_mutex_locker(&state, that->m_psi,
> PSI_MUTEX_LOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_mutex_wait(locker, src_file, src_line);
>     }
> @@ -654,9 +655,10 @@ static inline int inline_mysql_mutex_try
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_mutex_locker *locker= NULL;
> +  PSI_mutex_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_mutex_locker(that->m_psi,
> PSI_MUTEX_TRYLOCK);
> +    locker= PSI_server->get_thread_mutex_locker(&state, that->m_psi,
> PSI_MUTEX_TRYLOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_mutex_wait(locker, src_file, src_line);
>     }
> @@ -682,13 +684,8 @@ static inline int inline_mysql_mutex_unl
>   {
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
> -  struct PSI_thread *thread;
>     if (likely(PSI_server&&  that->m_psi))
> -  {
> -    thread= PSI_server->get_thread();
> -    if (likely(thread != NULL))
> -      PSI_server->unlock_mutex(thread, that->m_psi);
> -  }
> +    PSI_server->unlock_mutex(that->m_psi);
>   #endif
>   #ifdef SAFE_MUTEX
>     result= safe_mutex_unlock(&that->m_mutex, src_file, src_line);
> @@ -771,9 +768,10 @@ static inline int inline_mysql_rwlock_rd
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_READLOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_rdwait(locker, src_file, src_line);
> @@ -798,9 +796,10 @@ static inline int inline_mysql_prlock_rd
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_READLOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_rdwait(locker, src_file, src_line);
> @@ -825,9 +824,10 @@ static inline int inline_mysql_rwlock_wr
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_WRITELOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_wrwait(locker, src_file, src_line);
> @@ -852,9 +852,10 @@ static inline int inline_mysql_prlock_wr
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_WRITELOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_wrwait(locker, src_file, src_line);
> @@ -879,9 +880,10 @@ static inline int inline_mysql_rwlock_tr
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_TRYREADLOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_rdwait(locker, src_file, src_line);
> @@ -906,9 +908,10 @@ static inline int inline_mysql_prlock_tr
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_TRYREADLOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_rdwait(locker, src_file, src_line);
> @@ -933,9 +936,10 @@ static inline int inline_mysql_rwlock_tr
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_TRYWRITELOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_wrwait(locker, src_file, src_line);
> @@ -960,9 +964,10 @@ static inline int inline_mysql_prlock_tr
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_rwlock_locker *locker= NULL;
> +  PSI_rwlock_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_rwlock_locker(that->m_psi,
> +    locker= PSI_server->get_thread_rwlock_locker(&state, that->m_psi,
>                                                    PSI_RWLOCK_TRYWRITELOCK);
>       if (likely(locker != NULL))
>         PSI_server->start_rwlock_wrwait(locker, src_file, src_line);
> @@ -982,13 +987,8 @@ static inline int inline_mysql_rwlock_un
>   {
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
> -  struct PSI_thread *thread;
>     if (likely(PSI_server&&  that->m_psi))
> -  {
> -    thread= PSI_server->get_thread();
> -    if (likely(thread != NULL))
> -      PSI_server->unlock_rwlock(thread, that->m_psi);
> -  }
> +    PSI_server->unlock_rwlock(that->m_psi);
>   #endif
>     result= rw_unlock(&that->m_rwlock);
>     return result;
> @@ -1000,13 +1000,8 @@ static inline int inline_mysql_prlock_un
>   {
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
> -  struct PSI_thread *thread;
>     if (likely(PSI_server&&  that->m_psi))
> -  {
> -    thread= PSI_server->get_thread();
> -    if (likely(thread != NULL))
> -      PSI_server->unlock_rwlock(thread, that->m_psi);
> -  }
> +    PSI_server->unlock_rwlock(that->m_psi);
>   #endif
>     result= rw_pr_unlock(&that->m_prlock);
>     return result;
> @@ -1053,9 +1048,10 @@ static inline int inline_mysql_cond_wait
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_cond_locker *locker= NULL;
> +  PSI_cond_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_cond_locker(that->m_psi, mutex->m_psi,
> +    locker= PSI_server->get_thread_cond_locker(&state, that->m_psi,
> mutex->m_psi,
>                                                  PSI_COND_WAIT);
>       if (likely(locker != NULL))
>         PSI_server->start_cond_wait(locker, src_file, src_line);
> @@ -1081,9 +1077,10 @@ static inline int inline_mysql_cond_time
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
>     struct PSI_cond_locker *locker= NULL;
> +  PSI_cond_locker_state state;
>     if (likely(PSI_server&&  that->m_psi))
>     {
> -    locker= PSI_server->get_thread_cond_locker(that->m_psi, mutex->m_psi,
> +    locker= PSI_server->get_thread_cond_locker(&state, that->m_psi,
> mutex->m_psi,
>                                                  PSI_COND_TIMEDWAIT);
>       if (likely(locker != NULL))
>         PSI_server->start_cond_wait(locker, src_file, src_line);
> @@ -1102,13 +1099,8 @@ static inline int inline_mysql_cond_sign
>   {
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
> -  struct PSI_thread *thread;
>     if (likely(PSI_server&&  that->m_psi))
> -  {
> -    thread= PSI_server->get_thread();
> -    if (likely(thread != NULL))
> -      PSI_server->signal_cond(thread, that->m_psi);
> -  }
> +    PSI_server->signal_cond(that->m_psi);
>   #endif
>     result= pthread_cond_signal(&that->m_cond);
>     return result;
> @@ -1119,13 +1111,8 @@ static inline int inline_mysql_cond_broa
>   {
>     int result;
>   #ifdef HAVE_PSI_INTERFACE
> -  struct PSI_thread *thread;
>     if (likely(PSI_server&&  that->m_psi))
> -  {
> -    thread= PSI_server->get_thread();
> -    if (likely(thread != NULL))
> -      PSI_server->broadcast_cond(thread, that->m_psi);
> -  }
> +    PSI_server->broadcast_cond(that->m_psi);
>   #endif
>     result= pthread_cond_broadcast(&that->m_cond);
>     return result;
>
> === modified file 'include/mysql/psi/psi.h'
> --- a/include/mysql/psi/psi.h	2010-07-08 17:04:07 +0000
> +++ b/include/mysql/psi/psi.h	2010-07-09 23:00:24 +0000
> @@ -422,6 +422,175 @@ struct PSI_file_info_v1
>     int m_flags;
>   };
>
> +/**
> +  State data storage for @c get_thread_mutex_locker_v1_t.
> +  This structure provide temporary storage to a mutex locker.
> +  The content of this structure is considered opaque,
> +  the fields are only hints of what an implementation
> +  of the psi interface can use.
> +  This memory is provided by the instrumented code for performance reasons.
> +  @sa get_thread_mutex_locker_v1_t
> +*/
> +struct PSI_mutex_locker_state_v1
> +{
> +  /** Internal state. */
> +  uint m_flags;
> +  /** Current mutex. */
> +  struct PSI_mutex *m_mutex;
> +  /** Current thread. */
> +  struct PSI_thread *m_thread;
> +  /** Timer start. */
> +  ulonglong m_timer_start;
> +  /** Timer function. */
> +  ulonglong (*m_timer)(void);
> +  /** Current operation. */
> +  enum PSI_mutex_operation m_operation;
> +  /** Source file. */
> +  const char* m_src_file;
> +  /** Source line number. */
> +  int m_src_line;
> +  /** Internal data. */
> +  void *m_wait;
> +};
> +
> +/**
> +  State data storage for @c get_thread_rwlock_locker_v1_t.
> +  This structure provide temporary storage to a rwlock locker.
> +  The content of this structure is considered opaque,
> +  the fields are only hints of what an implementation
> +  of the psi interface can use.
> +  This memory is provided by the instrumented code for performance reasons.
> +  @sa get_thread_rwlock_locker_v1_t
> +*/
> +struct PSI_rwlock_locker_state_v1
> +{
> +  /** Internal state. */
> +  uint m_flags;
> +  /** Current rwlock. */
> +  struct PSI_rwlock *m_rwlock;
> +  /** Current thread. */
> +  struct PSI_thread *m_thread;
> +  /** Timer start. */
> +  ulonglong m_timer_start;
> +  /** Timer function. */
> +  ulonglong (*m_timer)(void);
> +  /** Current operation. */
> +  enum PSI_rwlock_operation m_operation;
> +  /** Source file. */
> +  const char* m_src_file;
> +  /** Source line number. */
> +  int m_src_line;
> +  /** Internal data. */
> +  void *m_wait;
> +};
> +
> +/**
> +  State data storage for @c get_thread_cond_locker_v1_t.
> +  This structure provide temporary storage to a condition locker.
> +  The content of this structure is considered opaque,
> +  the fields are only hints of what an implementation
> +  of the psi interface can use.
> +  This memory is provided by the instrumented code for performance reasons.
> +  @sa get_thread_cond_locker_v1_t
> +*/
> +struct PSI_cond_locker_state_v1
> +{
> +  /** Internal state. */
> +  uint m_flags;
> +  /** Current condition. */
> +  struct PSI_cond *m_cond;
> +  /** Current mutex. */
> +  struct PSI_mutex *m_mutex;
> +  /** Current thread. */
> +  struct PSI_thread *m_thread;
> +  /** Timer start. */
> +  ulonglong m_timer_start;
> +  /** Timer function. */
> +  ulonglong (*m_timer)(void);
> +  /** Current operation. */
> +  enum PSI_cond_operation m_operation;
> +  /** Source file. */
> +  const char* m_src_file;
> +  /** Source line number. */
> +  int m_src_line;
> +  /** Internal data. */
> +  void *m_wait;
> +};
> +
> +/**
> +  State data storage for @c get_thread_file_name_locker_v1_t.
> +  This structure provide temporary storage to a file locker.
> +  The content of this structure is considered opaque,
> +  the fields are only hints of what an implementation
> +  of the psi interface can use.
> +  This memory is provided by the instrumented code for performance reasons.
> +  @sa get_thread_file_name_locker_v1_t
> +  @sa get_thread_file_stream_locker_v1_t
> +  @sa get_thread_file_descriptor_locker_v1_t
> +*/
> +struct PSI_file_locker_state_v1
> +{
> +  /** Internal state. */
> +  uint m_flags;
> +  /** Current file. */
> +  struct PSI_file *m_file;
> +  /** Current thread. */
> +  struct PSI_thread *m_thread;
> +  /** Operation number of bytes. */
> +  size_t m_number_of_bytes;
> +  /** Timer start. */
> +  ulonglong m_timer_start;
> +  /** Timer function. */
> +  ulonglong (*m_timer)(void);
> +  /** Current operation. */
> +  enum PSI_file_operation m_operation;
> +  /** Source file. */
> +  const char* m_src_file;
> +  /** Source line number. */
> +  int m_src_line;
> +  /** Internal data. */
> +  void *m_wait;
> +};
> +
> +/**
> +  State data storage for @c get_thread_table_locker_v1_t.
> +  This structure provide temporary storage to a table locker.
> +  The content of this structure is considered opaque,
> +  the fields are only hints of what an implementation
> +  of the psi interface can use.
> +  This memory is provided by the instrumented code for performance reasons.
> +  @sa get_thread_table_locker_v1_t
> +*/
> +struct PSI_table_locker_state_v1
> +{
> +  /** Internal state. */
> +  uint m_flags;
> +  /** Current table handle. */
> +  struct PSI_table *m_table;
> +  /** Current table share. */
> +  struct PSI_table_share *m_table_share;
> +  /** Instrumentation class. */
> +  void *m_class;
> +  /** Current thread. */
> +  struct PSI_thread *m_thread;
> +  /** Timer start. */
> +  ulonglong m_timer_start;
> +  /** Timer function. */
> +  ulonglong (*m_timer)(void);
> +  /* Current operation (waiting for WL#4895). */
> +  /* enum PSI_table_operation m_operation; */
> +  /** Current table io index. */
> +  uint m_index;
> +  /** Current table lock index. */
> +  uint m_lock_index;
> +  /** Source file. */
> +  const char* m_src_file;
> +  /** Source line number. */
> +  int m_src_line;
> +  /** Internal data. */
> +  void *m_wait;
> +};
> +
>   /* Using typedef to make reuse between PSI_v1 and PSI_v2 easier later. */
>
>   /**
> @@ -619,40 +788,51 @@ typedef void (*delete_thread_v1_t)(struc
>
>   /**
>     Get a mutex instrumentation locker.
> +  @param state data storage for the locker
>     @param mutex the instrumented mutex to lock
>     @return a mutex locker, or NULL
>   */
>   typedef struct PSI_mutex_locker* (*get_thread_mutex_locker_v1_t)
> -  (struct PSI_mutex *mutex, enum PSI_mutex_operation op);
> +  (struct PSI_mutex_locker_state_v1 *state,
> +   struct PSI_mutex *mutex,
> +   enum PSI_mutex_operation op);
>
>   /**
>     Get a rwlock instrumentation locker.
> +  @param state data storage for the locker
>     @param rwlock the instrumented rwlock to lock
>     @return a rwlock locker, or NULL
>   */
>   typedef struct PSI_rwlock_locker* (*get_thread_rwlock_locker_v1_t)
> -  (struct PSI_rwlock *rwlock, enum PSI_rwlock_operation op);
> +  (struct PSI_rwlock_locker_state_v1 *state,
> +   struct PSI_rwlock *rwlock,
> +   enum PSI_rwlock_operation op);
>
>   /**
>     Get a cond instrumentation locker.
> +  @param state data storage for the locker
>     @param cond the instrumented condition to wait on
>     @param mutex the instrumented mutex associated with the condition
>     @return a condition locker, or NULL
>   */
>   typedef struct PSI_cond_locker* (*get_thread_cond_locker_v1_t)
> -  (struct PSI_cond *cond, struct PSI_mutex *mutex,
> +  (struct PSI_cond_locker_state_v1 *state,
> +   struct PSI_cond *cond, struct PSI_mutex *mutex,
>      enum PSI_cond_operation op);
>
>   /**
>     Get a table instrumentation locker.
> +  @param state data storage for the locker
>     @param table the instrumented table to lock
>     @return a table locker, or NULL
>   */
>   typedef struct PSI_table_locker* (*get_thread_table_locker_v1_t)
> -  (struct PSI_table *table);
> +  (struct PSI_table_locker_state_v1 *state,
> +   struct PSI_table *table);
>
>   /**
>     Get a file instrumentation locker, for opening or creating a file.
> +  @param state data storage for the locker
>     @param key the file instrumentation key
>     @param op the operation to perform
>     @param name the file name
> @@ -660,58 +840,59 @@ typedef struct PSI_table_locker* (*get_t
>     @return a file locker, or NULL
>   */
>   typedef struct PSI_file_locker* (*get_thread_file_name_locker_v1_t)
> -  (PSI_file_key key, enum PSI_file_operation op, const char *name,
> +  (struct PSI_file_locker_state_v1 *state,
> +   PSI_file_key key, enum PSI_file_operation op, const char *name,
>      const void *identity);
>
>   /**
>     Get a file stream instrumentation locker.
> +  @param state data storage for the locker
>     @param file the file stream to access
>     @param op the operation to perform
>     @return a file locker, or NULL
>   */
>   typedef struct PSI_file_locker* (*get_thread_file_stream_locker_v1_t)
> -  (struct PSI_file *file, enum PSI_file_operation op);
> +  (struct PSI_file_locker_state_v1 *state,
> +   struct PSI_file *file, enum PSI_file_operation op);
>
>   /**
>     Get a file instrumentation locker.
> +  @param state data storage for the locker
>     @param file the file descriptor to access
>     @param op the operation to perform
>     @return a file locker, or NULL
>   */
>   typedef struct PSI_file_locker* (*get_thread_file_descriptor_locker_v1_t)
> -  (File file, enum PSI_file_operation op);
> +  (struct PSI_file_locker_state_v1 *state,
> +   File file, enum PSI_file_operation op);
>
>   /**
>     Record a mutex instrumentation unlock event.
> -  @param thread the running thread instrumentation
>     @param mutex the mutex instrumentation
>   */
>   typedef void (*unlock_mutex_v1_t)
> -  (struct PSI_thread *thread, struct PSI_mutex *mutex);
> +  (struct PSI_mutex *mutex);
>
>   /**
>     Record a rwlock instrumentation unlock event.
> -  @param thread the running thread instrumentation
>     @param rwlock the rwlock instrumentation
>   */
>   typedef void (*unlock_rwlock_v1_t)
> -  (struct PSI_thread *thread, struct PSI_rwlock *rwlock);
> +  (struct PSI_rwlock *rwlock);
>
>   /**
>     Record a condition instrumentation signal event.
> -  @param thread the running thread instrumentation
>     @param cond the cond instrumentation
>   */
>   typedef void (*signal_cond_v1_t)
> -  (struct PSI_thread *thread, struct PSI_cond *cond);
> +  (struct PSI_cond *cond);
>
>   /**
>     Record a condition instrumentation broadcast event.
> -  @param thread the running thread instrumentation
>     @param cond the cond instrumentation
>   */
>   typedef void (*broadcast_cond_v1_t)
> -  (struct PSI_thread *thread, struct PSI_cond *cond);
> +  (struct PSI_cond *cond);
>
>   /**
>     Record a mutex instrumentation wait start event.
> @@ -1013,6 +1194,36 @@ struct PSI_file_info_v2
>     int placeholder;
>   };
>
> +struct PSI_mutex_locker_state_v2
> +{
> +  /** Placeholder */
> +  int placeholder;
> +};
> +
> +struct PSI_rwlock_locker_state_v2
> +{
> +  /** Placeholder */
> +  int placeholder;
> +};
> +
> +struct PSI_cond_locker_state_v2
> +{
> +  /** Placeholder */
> +  int placeholder;
> +};
> +
> +struct PSI_file_locker_state_v2
> +{
> +  /** Placeholder */
> +  int placeholder;
> +};
> +
> +struct PSI_table_locker_state_v2
> +{
> +  /** Placeholder */
> +  int placeholder;
> +};
> +
>   /** @} (end of group Group_PSI_v2) */
>
>   #endif /* HAVE_PSI_2 */
> @@ -1056,6 +1267,11 @@ typedef struct PSI_rwlock_info_v1 PSI_rw
>   typedef struct PSI_cond_info_v1 PSI_cond_info;
>   typedef struct PSI_thread_info_v1 PSI_thread_info;
>   typedef struct PSI_file_info_v1 PSI_file_info;
> +typedef struct PSI_mutex_locker_state_v1 PSI_mutex_locker_state;
> +typedef struct PSI_rwlock_locker_state_v1 PSI_rwlock_locker_state;
> +typedef struct PSI_cond_locker_state_v1 PSI_cond_locker_state;
> +typedef struct PSI_file_locker_state_v1 PSI_file_locker_state;
> +typedef struct PSI_table_locker_state_v1 PSI_table_locker_state;
>   #endif
>
>   #ifdef USE_PSI_2
> @@ -1065,6 +1281,11 @@ typedef struct PSI_rwlock_info_v2 PSI_rw
>   typedef struct PSI_cond_info_v2 PSI_cond_info;
>   typedef struct PSI_thread_info_v2 PSI_thread_info;
>   typedef struct PSI_file_info_v2 PSI_file_info;
> +typedef struct PSI_mutex_locker_state_v2 PSI_mutex_locker_state;
> +typedef struct PSI_rwlock_locker_state_v2 PSI_rwlock_locker_state;
> +typedef struct PSI_cond_locker_state_v2 PSI_cond_locker_state;
> +typedef struct PSI_file_locker_state_v2 PSI_file_locker_state;
> +typedef struct PSI_table_locker_state_v2 PSI_table_locker_state;
>   #endif
>
>   #else /* HAVE_PSI_INTERFACE */
>
> === modified file 'include/mysql/psi/psi_abi_v1.h.pp'
> --- a/include/mysql/psi/psi_abi_v1.h.pp	2010-01-26 23:42:54 +0000
> +++ b/include/mysql/psi/psi_abi_v1.h.pp	2010-07-09 23:00:24 +0000
> @@ -88,6 +88,71 @@ struct PSI_file_info_v1
>     const char *m_name;
>     int m_flags;
>   };
> +struct PSI_mutex_locker_state_v1
> +{
> +  uint m_flags;
> +  struct PSI_mutex *m_mutex;
> +  struct PSI_thread *m_thread;
> +  ulonglong m_timer_start;
> +  ulonglong (*m_timer)(void);
> +  enum PSI_mutex_operation m_operation;
> +  const char* m_src_file;
> +  int m_src_line;
> +  void *m_wait;
> +};
> +struct PSI_rwlock_locker_state_v1
> +{
> +  uint m_flags;
> +  struct PSI_rwlock *m_rwlock;
> +  struct PSI_thread *m_thread;
> +  ulonglong m_timer_start;
> +  ulonglong (*m_timer)(void);
> +  enum PSI_rwlock_operation m_operation;
> +  const char* m_src_file;
> +  int m_src_line;
> +  void *m_wait;
> +};
> +struct PSI_cond_locker_state_v1
> +{
> +  uint m_flags;
> +  struct PSI_cond *m_cond;
> +  struct PSI_mutex *m_mutex;
> +  struct PSI_thread *m_thread;
> +  ulonglong m_timer_start;
> +  ulonglong (*m_timer)(void);
> +  enum PSI_cond_operation m_operation;
> +  const char* m_src_file;
> +  int m_src_line;
> +  void *m_wait;
> +};
> +struct PSI_file_locker_state_v1
> +{
> +  uint m_flags;
> +  struct PSI_file *m_file;
> +  struct PSI_thread *m_thread;
> +  size_t m_number_of_bytes;
> +  ulonglong m_timer_start;
> +  ulonglong (*m_timer)(void);
> +  enum PSI_file_operation m_operation;
> +  const char* m_src_file;
> +  int m_src_line;
> +  void *m_wait;
> +};
> +struct PSI_table_locker_state_v1
> +{
> +  uint m_flags;
> +  struct PSI_table *m_table;
> +  struct PSI_table_share *m_table_share;
> +  void *m_class;
> +  struct PSI_thread *m_thread;
> +  ulonglong m_timer_start;
> +  ulonglong (*m_timer)(void);
> +  uint m_index;
> +  uint m_lock_index;
> +  const char* m_src_file;
> +  int m_src_line;
> +  void *m_wait;
> +};
>   typedef void (*register_mutex_v1_t)
>     (const char *category, struct PSI_mutex_info_v1 *info, int count);
>   typedef void (*register_rwlock_v1_t)
> @@ -129,29 +194,38 @@ typedef void (*set_thread_v1_t)(struct P
>   typedef void (*delete_current_thread_v1_t)(void);
>   typedef void (*delete_thread_v1_t)(struct PSI_thread *thread);
>   typedef struct PSI_mutex_locker* (*get_thread_mutex_locker_v1_t)
> -  (struct PSI_mutex *mutex, enum PSI_mutex_operation op);
> +  (struct PSI_mutex_locker_state_v1 *state,
> +   struct PSI_mutex *mutex,
> +   enum PSI_mutex_operation op);
>   typedef struct PSI_rwlock_locker* (*get_thread_rwlock_locker_v1_t)
> -  (struct PSI_rwlock *rwlock, enum PSI_rwlock_operation op);
> +  (struct PSI_rwlock_locker_state_v1 *state,
> +   struct PSI_rwlock *rwlock,
> +   enum PSI_rwlock_operation op);
>   typedef struct PSI_cond_locker* (*get_thread_cond_locker_v1_t)
> -  (struct PSI_cond *cond, struct PSI_mutex *mutex,
> +  (struct PSI_cond_locker_state_v1 *state,
> +   struct PSI_cond *cond, struct PSI_mutex *mutex,
>      enum PSI_cond_operation op);
>   typedef struct PSI_table_locker* (*get_thread_table_locker_v1_t)
> -  (struct PSI_table *table);
> +  (struct PSI_table_locker_state_v1 *state,
> +   struct PSI_table *table);
>   typedef struct PSI_file_locker* (*get_thread_file_name_locker_v1_t)
> -  (PSI_file_key key, enum PSI_file_operation op, const char *name,
> +  (struct PSI_file_locker_state_v1 *state,
> +   PSI_file_key key, enum PSI_file_operation op, const char *name,
>      const void *identity);
>   typedef struct PSI_file_locker* (*get_thread_file_stream_locker_v1_t)
> -  (struct PSI_file *file, enum PSI_file_operation op);
> +  (struct PSI_file_locker_state_v1 *state,
> +   struct PSI_file *file, enum PSI_file_operation op);
>   typedef struct PSI_file_locker* (*get_thread_file_descriptor_locker_v1_t)
> -  (File file, enum PSI_file_operation op);
> +  (struct PSI_file_locker_state_v1 *state,
> +   File file, enum PSI_file_operation op);
>   typedef void (*unlock_mutex_v1_t)
> -  (struct PSI_thread *thread, struct PSI_mutex *mutex);
> +  (struct PSI_mutex *mutex);
>   typedef void (*unlock_rwlock_v1_t)
> -  (struct PSI_thread *thread, struct PSI_rwlock *rwlock);
> +  (struct PSI_rwlock *rwlock);
>   typedef void (*signal_cond_v1_t)
> -  (struct PSI_thread *thread, struct PSI_cond *cond);
> +  (struct PSI_cond *cond);
>   typedef void (*broadcast_cond_v1_t)
> -  (struct PSI_thread *thread, struct PSI_cond *cond);
> +  (struct PSI_cond *cond);
>   typedef void (*start_mutex_wait_v1_t)
>     (struct PSI_mutex_locker *locker, const char *src_file, uint src_line);
>   typedef void (*end_mutex_wait_v1_t)
> @@ -240,5 +314,10 @@ typedef struct PSI_rwlock_info_v1 PSI_rw
>   typedef struct PSI_cond_info_v1 PSI_cond_info;
>   typedef struct PSI_thread_info_v1 PSI_thread_info;
>   typedef struct PSI_file_info_v1 PSI_file_info;
> +typedef struct PSI_mutex_locker_state_v1 PSI_mutex_locker_state;
> +typedef struct PSI_rwlock_locker_state_v1 PSI_rwlock_locker_state;
> +typedef struct PSI_cond_locker_state_v1 PSI_cond_locker_state;
> +typedef struct PSI_file_locker_state_v1 PSI_file_locker_state;
> +typedef struct PSI_table_locker_state_v1 PSI_table_locker_state;
>   extern MYSQL_PLUGIN_IMPORT PSI *PSI_server;
>   C_MODE_END
>
> === modified file 'include/mysql/psi/psi_abi_v2.h.pp'
> --- a/include/mysql/psi/psi_abi_v2.h.pp	2009-12-01 00:49:15 +0000
> +++ b/include/mysql/psi/psi_abi_v2.h.pp	2010-07-09 23:00:24 +0000
> @@ -82,11 +82,36 @@ struct PSI_file_info_v2
>   {
>     int placeholder;
>   };
> +struct PSI_mutex_locker_state_v2
> +{
> +  int placeholder;
> +};
> +struct PSI_rwlock_locker_state_v2
> +{
> +  int placeholder;
> +};
> +struct PSI_cond_locker_state_v2
> +{
> +  int placeholder;
> +};
> +struct PSI_file_locker_state_v2
> +{
> +  int placeholder;
> +};
> +struct PSI_table_locker_state_v2
> +{
> +  int placeholder;
> +};
>   typedef struct PSI_v2 PSI;
>   typedef struct PSI_mutex_info_v2 PSI_mutex_info;
>   typedef struct PSI_rwlock_info_v2 PSI_rwlock_info;
>   typedef struct PSI_cond_info_v2 PSI_cond_info;
>   typedef struct PSI_thread_info_v2 PSI_thread_info;
>   typedef struct PSI_file_info_v2 PSI_file_info;
> +typedef struct PSI_mutex_locker_state_v2 PSI_mutex_locker_state;
> +typedef struct PSI_rwlock_locker_state_v2 PSI_rwlock_locker_state;
> +typedef struct PSI_cond_locker_state_v2 PSI_cond_locker_state;
> +typedef struct PSI_file_locker_state_v2 PSI_file_locker_state;
> +typedef struct PSI_table_locker_state_v2 PSI_table_locker_state;
>   extern MYSQL_PLUGIN_IMPORT PSI *PSI_server;
>   C_MODE_END
>
> === modified file 'storage/innobase/include/os0file.h'
> --- a/storage/innobase/include/os0file.h	2010-06-17 11:11:34 +0000
> +++ b/storage/innobase/include/os0file.h	2010-07-09 23:00:24 +0000
> @@ -194,12 +194,12 @@ various file I/O operations with perform
>   used to register file creation, opening, closing and renaming.
>   2) register_pfs_file_io_begin() and register_pfs_file_io_end() are
>   used to register actual file read, write and flush */
> -# define register_pfs_file_open_begin(locker, key, op, name,		\
> +# define register_pfs_file_open_begin(state, locker, key, op, name,	\
>   				      src_file, src_line)		\
>   do {									\
>   	if (PSI_server) {						\
>   		locker = PSI_server->get_thread_file_name_locker(	\
> -			key, op, name,&locker);			\
> +			state, key, op, name,&locker);			\
>   		if (locker) {						\
>   			PSI_server->start_file_open_wait(		\
>   				locker, src_file, src_line);		\
> @@ -215,12 +215,12 @@ do {									\
>   	}								\
>   } while (0)
>
> -# define register_pfs_file_io_begin(locker, file, count, op,		\
> +# define register_pfs_file_io_begin(state, locker, file, count, op,	\
>   				    src_file, src_line)			\
>   do {									\
>   	if (PSI_server) {						\
>   		locker = PSI_server->get_thread_file_descriptor_locker(	\
> -			file, op);					\
> +			state, file, op);				\
>   		if (locker) {						\
>   			PSI_server->start_file_wait(			\
>   				locker, count, src_file, src_line);	\
>
> === modified file 'storage/innobase/include/os0file.ic'
> --- a/storage/innobase/include/os0file.ic	2010-03-29 07:34:42 +0000
> +++ b/storage/innobase/include/os0file.ic	2010-07-09 23:00:24 +0000
> @@ -55,9 +55,10 @@ pfs_os_file_create_simple_func(
>   {
>   	os_file_t	file;
>   	struct PSI_file_locker* locker = NULL;
> +	PSI_file_locker_state state;
>
>   	/* register a file open or creation depending on "create_mode" */
> -	register_pfs_file_open_begin(locker, key,
> +	register_pfs_file_open_begin(&state, locker, key,
>   				     ((create_mode == OS_FILE_CREATE)
>   					? PSI_FILE_CREATE
>   					: PSI_FILE_OPEN),
> @@ -101,9 +102,10 @@ pfs_os_file_create_simple_no_error_handl
>   {
>   	os_file_t	file;
>   	struct PSI_file_locker* locker = NULL;
> +	PSI_file_locker_state state;
>
>   	/* register a file open or creation depending on "create_mode" */
> -	register_pfs_file_open_begin(locker, key,
> +	register_pfs_file_open_begin(&state, locker, key,
>   				     ((create_mode == OS_FILE_CREATE)
>   					? PSI_FILE_CREATE
>   					: PSI_FILE_OPEN),
> @@ -153,9 +155,10 @@ pfs_os_file_create_func(
>   {
>   	os_file_t	file;
>   	struct PSI_file_locker* locker = NULL;
> +	PSI_file_locker_state state;
>
>   	/* register a file open or creation depending on "create_mode" */
> -	register_pfs_file_open_begin(locker, key,
> +	register_pfs_file_open_begin(&state, locker, key,
>   				     ((create_mode == OS_FILE_CREATE)
>   					? PSI_FILE_CREATE
>   					: PSI_FILE_OPEN),
> @@ -183,9 +186,10 @@ pfs_os_file_close_func(
>   {
>   	ibool	result;
>   	struct PSI_file_locker*	locker = NULL;
> +	PSI_file_locker_state state;
>
>   	/* register the file close */
> -	register_pfs_file_io_begin(locker, file, 0, PSI_FILE_CLOSE,
> +	register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_CLOSE,
>   				   src_file, src_line);
>
>   	result = os_file_close_func(file);
> @@ -230,9 +234,10 @@ pfs_os_aio_func(
>   {
>   	ibool	result;
>   	struct PSI_file_locker*	locker = NULL;
> +	PSI_file_locker_state state;
>
>   	/* Register the read or write I/O depending on "type" */
> -	register_pfs_file_io_begin(locker, file, n,
> +	register_pfs_file_io_begin(&state, locker, file, n,
>   				   (type == OS_FILE_WRITE)
>   					? PSI_FILE_WRITE
>   					: PSI_FILE_READ,
> @@ -268,8 +273,9 @@ pfs_os_file_read_func(
>   {
>   	ibool	result;
>   	struct PSI_file_locker*	locker = NULL;
> +	PSI_file_locker_state state;
>
> -	register_pfs_file_io_begin(locker, file, n, PSI_FILE_READ,
> +	register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_READ,
>   				   src_file, src_line);
>
>   	result = os_file_read_func(file, buf, offset, offset_high, n);
> @@ -303,8 +309,9 @@ pfs_os_file_read_no_error_handling_func(
>   {
>   	ibool	result;
>   	struct PSI_file_locker*	locker = NULL;
> +	PSI_file_locker_state state;
>
> -	register_pfs_file_io_begin(locker, file, n, PSI_FILE_READ,
> +	register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_READ,
>   				   src_file, src_line);
>
>   	result = os_file_read_no_error_handling_func(file, buf, offset,
> @@ -339,8 +346,9 @@ pfs_os_file_write_func(
>   {
>   	ibool	result;
>   	struct PSI_file_locker*	locker = NULL;
> +	PSI_file_locker_state state;
>
> -	register_pfs_file_io_begin(locker, file, n, PSI_FILE_WRITE,
> +	register_pfs_file_io_begin(&state, locker, file, n, PSI_FILE_WRITE,
>   				   src_file, src_line);
>
>   	result = os_file_write_func(name, file, buf, offset, offset_high, n);
> @@ -366,8 +374,9 @@ pfs_os_file_flush_func(
>   {
>   	ibool	result;
>   	struct PSI_file_locker*	locker = NULL;
> +	PSI_file_locker_state state;
>
> -	register_pfs_file_io_begin(locker, file, 0, PSI_FILE_SYNC,
> +	register_pfs_file_io_begin(&state, locker, file, 0, PSI_FILE_SYNC,
>   				   src_file, src_line);
>   	result = os_file_flush_func(file);
>
> @@ -395,8 +404,9 @@ pfs_os_file_rename_func(
>   {
>   	ibool	result;
>   	struct PSI_file_locker*	locker = NULL;
> +	PSI_file_locker_state state;
>
> -	register_pfs_file_open_begin(locker, key, PSI_FILE_RENAME, newpath,
> +	register_pfs_file_open_begin(&state, locker, key, PSI_FILE_RENAME, newpath,
>   				     src_file, src_line);
>
>   	result = os_file_rename_func(oldpath, newpath);
>
> === modified file 'storage/innobase/include/sync0rw.ic'
> --- a/storage/innobase/include/sync0rw.ic	2010-06-17 11:11:34 +0000
> +++ b/storage/innobase/include/sync0rw.ic	2010-07-09 23:00:24 +0000
> @@ -676,11 +676,12 @@ pfs_rw_lock_x_lock_func(
>   	ulint		line)	/*!<  in: line where requested */
>   {
>   	struct PSI_rwlock_locker* locker = NULL;
> +	PSI_rwlock_locker_state state;
>
>   	/* Record the entry of rw x lock request in performance schema */
>   	if (UNIV_LIKELY(PSI_server&&  lock->pfs_psi)) {
>   		locker = PSI_server->get_thread_rwlock_locker(
> -			lock->pfs_psi, PSI_RWLOCK_WRITELOCK);
> +			&state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK);
>
>   		if (locker) {
>   			PSI_server->start_rwlock_wrwait(locker,
> @@ -710,12 +711,13 @@ pfs_rw_lock_x_lock_func_nowait(
>   	ulint		line)	/*!<  in: line where requested */
>   {
>   	struct PSI_rwlock_locker* locker = NULL;
> +	PSI_rwlock_locker_state state;
>   	ibool	ret;
>
>   	/* Record the entry of rw x lock request in performance schema */
>   	if (UNIV_LIKELY(PSI_server&&  lock->pfs_psi)) {
>   		locker = PSI_server->get_thread_rwlock_locker(
> -			lock->pfs_psi, PSI_RWLOCK_WRITELOCK);
> +			&state, lock->pfs_psi, PSI_RWLOCK_WRITELOCK);
>
>   		if (locker) {
>   			PSI_server->start_rwlock_wrwait(locker,
> @@ -765,11 +767,12 @@ pfs_rw_lock_s_lock_func(
>   	ulint		line)	/*!<  in: line where requested */
>   {
>   	struct PSI_rwlock_locker* locker = NULL;
> +	PSI_rwlock_locker_state state;
>
>   	/* Instrumented to inform we are aquiring a shared rwlock */
>   	if (UNIV_LIKELY(PSI_server&&  lock->pfs_psi)) {
>   		locker = PSI_server->get_thread_rwlock_locker(
> -			lock->pfs_psi, PSI_RWLOCK_READLOCK);
> +			&state, lock->pfs_psi, PSI_RWLOCK_READLOCK);
>   		if (locker) {
>   			PSI_server->start_rwlock_rdwait(locker,
>   							file_name, line);
> @@ -800,12 +803,13 @@ pfs_rw_lock_s_lock_low(
>   {
>
>   	struct PSI_rwlock_locker* locker = NULL;
> +	PSI_rwlock_locker_state state;
>   	ibool	ret;
>
>   	/* Instrumented to inform we are aquiring a shared rwlock */
>   	if (UNIV_LIKELY(PSI_server&&  lock->pfs_psi)) {
>   		locker = PSI_server->get_thread_rwlock_locker(
> -			lock->pfs_psi, PSI_RWLOCK_READLOCK);
> +			&state, lock->pfs_psi, PSI_RWLOCK_READLOCK);
>   		if (locker) {
>   			PSI_server->start_rwlock_rdwait(locker,
>   							file_name, line);
> @@ -838,11 +842,7 @@ pfs_rw_lock_x_unlock_func(
>   {
>   	/* Inform performance schema we are unlocking the lock */
>   	if (UNIV_LIKELY(PSI_server&&  lock->pfs_psi)) {
> -		struct PSI_thread*	thread;
> -		thread = PSI_server->get_thread();
> -		if (thread) {
> -			PSI_server->unlock_rwlock(thread, lock->pfs_psi);
> -		}
> +		PSI_server->unlock_rwlock(lock->pfs_psi);
>   	}
>
>   	rw_lock_x_unlock_func(
> @@ -869,11 +869,7 @@ pfs_rw_lock_s_unlock_func(
>   {
>   	/* Inform performance schema we are unlocking the lock */
>   	if (UNIV_LIKELY(PSI_server&&  lock->pfs_psi)) {
> -		struct PSI_thread*	thread;
> -		thread = PSI_server->get_thread();
> -		if (thread) {
> -			PSI_server->unlock_rwlock(thread, lock->pfs_psi);
> -		}
> +		PSI_server->unlock_rwlock(lock->pfs_psi);
>   	}
>
>   	rw_lock_s_unlock_func(
>
> === modified file 'storage/innobase/include/sync0sync.ic'
> --- a/storage/innobase/include/sync0sync.ic	2010-06-17 11:11:34 +0000
> +++ b/storage/innobase/include/sync0sync.ic	2010-07-09 23:00:24 +0000
> @@ -237,11 +237,12 @@ pfs_mutex_enter_func(
>   	ulint		line)		/*!<  in: line where locked */
>   {
>   	struct PSI_mutex_locker*	locker = NULL;
> +	PSI_mutex_locker_state		state;
>   	int	result = 0;
>
>   	if (UNIV_LIKELY(PSI_server&&  mutex->pfs_psi)) {
>   		locker = PSI_server->get_thread_mutex_locker(
> -				mutex->pfs_psi, PSI_MUTEX_LOCK);
> +				&state, mutex->pfs_psi, PSI_MUTEX_LOCK);
>   		if (locker) {
>   			PSI_server->start_mutex_wait(locker, file_name, line);
>   		}
> @@ -270,11 +271,12 @@ pfs_mutex_enter_nowait_func(
>   {
>   	ulint	ret;
>   	struct PSI_mutex_locker*	locker = NULL;
> +	PSI_mutex_locker_state		state;
>   	int	result = 0;
>
>   	if (UNIV_LIKELY(PSI_server&&  mutex->pfs_psi)) {
>   		locker = PSI_server->get_thread_mutex_locker(
> -				mutex->pfs_psi, PSI_MUTEX_LOCK);
> +				&state, mutex->pfs_psi, PSI_MUTEX_LOCK);
>   		if (locker) {
>   			PSI_server->start_mutex_wait(locker, file_name, line);
>   		}
> @@ -300,12 +302,7 @@ pfs_mutex_exit_func(
>   	mutex_t*	mutex)	/*!<  in: pointer to mutex */
>   {
>   	if (UNIV_LIKELY(PSI_server&&  mutex->pfs_psi)) {
> -		struct PSI_thread*	thread;
> -		thread = PSI_server->get_thread();
> -
> -		if (thread) {
> -			PSI_server->unlock_mutex(thread, mutex->pfs_psi);
> -		}
> +		PSI_server->unlock_mutex(mutex->pfs_psi);
>   	}
>
>   	mutex_exit_func(mutex);
>
> === modified file 'storage/innobase/row/row0merge.c'
> --- a/storage/innobase/row/row0merge.c	2010-06-17 11:11:34 +0000
> +++ b/storage/innobase/row/row0merge.c	2010-07-09 23:00:24 +0000
> @@ -2165,7 +2165,8 @@ row_merge_file_create(
>   	file APIs, add instrumentation to register with
>   	performance schema */
>   	struct PSI_file_locker* locker = NULL;
> -	register_pfs_file_open_begin(locker, innodb_file_temp_key,
> +	PSI_file_locker_state state;
> +	register_pfs_file_open_begin(&state, locker, innodb_file_temp_key,
>   				     PSI_FILE_OPEN,
>   				     "Innodb Merge Temp File",
>   				     __FILE__, __LINE__);
> @@ -2188,7 +2189,8 @@ row_merge_file_destroy(
>   {
>   #ifdef UNIV_PFS_IO
>   	struct PSI_file_locker* locker = NULL;
> -	register_pfs_file_io_begin(locker, merge_file->fd, 0, PSI_FILE_CLOSE,
> +	PSI_file_locker_state state;
> +	register_pfs_file_io_begin(&state, locker, merge_file->fd, 0,
> PSI_FILE_CLOSE,
>   				   __FILE__, __LINE__);
>   #endif
>   	if (merge_file->fd != -1) {
>
> === modified file 'storage/perfschema/pfs.cc'
> --- a/storage/perfschema/pfs.cc	2010-07-08 21:20:08 +0000
> +++ b/storage/perfschema/pfs.cc	2010-07-09 23:00:24 +0000
> @@ -1093,7 +1093,8 @@ static void delete_thread_v1(PSI_thread
>   }
>
>   static PSI_mutex_locker*
> -get_thread_mutex_locker_v1(PSI_mutex *mutex, PSI_mutex_operation op)
> +get_thread_mutex_locker_v1(PSI_mutex_locker_state *state,
> +                           PSI_mutex *mutex, PSI_mutex_operation op)
>   {
>     PFS_mutex *pfs_mutex= reinterpret_cast<PFS_mutex*>  (mutex);
>     DBUG_ASSERT((int) op>= 0);
> @@ -1138,7 +1139,8 @@ get_thread_mutex_locker_v1(PSI_mutex *mu
>   }
>
>   static PSI_rwlock_locker*
> -get_thread_rwlock_locker_v1(PSI_rwlock *rwlock, PSI_rwlock_operation op)
> +get_thread_rwlock_locker_v1(PSI_rwlock_locker_state *state,
> +                            PSI_rwlock *rwlock, PSI_rwlock_operation op)
>   {
>     PFS_rwlock *pfs_rwlock= reinterpret_cast<PFS_rwlock*>  (rwlock);
>     DBUG_ASSERT(static_cast<int>  (op)>= 0);
> @@ -1184,7 +1186,8 @@ get_thread_rwlock_locker_v1(PSI_rwlock *
>   }
>
>   static PSI_cond_locker*
> -get_thread_cond_locker_v1(PSI_cond *cond, PSI_mutex * /* unused: mutex */,
> +get_thread_cond_locker_v1(PSI_cond_locker_state *state,
> +                          PSI_cond *cond, PSI_mutex * /* unused: mutex */,
>                             PSI_cond_operation op)
>   {
>     /*
> @@ -1242,7 +1245,8 @@ get_thread_cond_locker_v1(PSI_cond *cond
>   }
>
>   static PSI_table_locker*
> -get_thread_table_locker_v1(PSI_table *table)
> +get_thread_table_locker_v1(PSI_table_locker_state *state,
> +                           PSI_table *table)
>   {
>     PFS_table *pfs_table= reinterpret_cast<PFS_table*>  (table);
>     DBUG_ASSERT(pfs_table != NULL);
> @@ -1284,7 +1288,8 @@ get_thread_table_locker_v1(PSI_table *ta
>   }
>
>   static PSI_file_locker*
> -get_thread_file_name_locker_v1(PSI_file_key key,
> +get_thread_file_name_locker_v1(PSI_file_locker_state *state,
> +                               PSI_file_key key,
>                                  PSI_file_operation op,
>                                  const char *name, const void *identity)
>   {
> @@ -1341,7 +1346,8 @@ get_thread_file_name_locker_v1(PSI_file_
>   }
>
>   static PSI_file_locker*
> -get_thread_file_stream_locker_v1(PSI_file *file, PSI_file_operation op)
> +get_thread_file_stream_locker_v1(PSI_file_locker_state *state,
> +                                 PSI_file *file, PSI_file_operation op)
>   {
>     PFS_file *pfs_file= reinterpret_cast<PFS_file*>  (file);
>
> @@ -1392,7 +1398,8 @@ get_thread_file_stream_locker_v1(PSI_fil
>   }
>
>   static PSI_file_locker*
> -get_thread_file_descriptor_locker_v1(File file, PSI_file_operation op)
> +get_thread_file_descriptor_locker_v1(PSI_file_locker_state *state,
> +                                     File file, PSI_file_operation op)
>   {
>     int index= static_cast<int>  (file);
>
> @@ -1462,7 +1469,7 @@ get_thread_file_descriptor_locker_v1(Fil
>     return NULL;
>   }
>
> -static void unlock_mutex_v1(PSI_thread * thread, PSI_mutex *mutex)
> +static void unlock_mutex_v1(PSI_mutex *mutex)
>   {
>     PFS_mutex *pfs_mutex= reinterpret_cast<PFS_mutex*>  (mutex);
>     DBUG_ASSERT(pfs_mutex != NULL);
> @@ -1501,7 +1508,7 @@ static void unlock_mutex_v1(PSI_thread *
>   #endif
>   }
>
> -static void unlock_rwlock_v1(PSI_thread *thread, PSI_rwlock *rwlock)
> +static void unlock_rwlock_v1(PSI_rwlock *rwlock)
>   {
>     PFS_rwlock *pfs_rwlock= reinterpret_cast<PFS_rwlock*>  (rwlock);
>     DBUG_ASSERT(pfs_rwlock != NULL);
> @@ -1577,7 +1584,7 @@ static void unlock_rwlock_v1(PSI_thread
>   #endif
>   }
>
> -static void signal_cond_v1(PSI_thread *thread, PSI_cond* cond)
> +static void signal_cond_v1(PSI_cond* cond)
>   {
>     PFS_cond *pfs_cond= reinterpret_cast<PFS_cond*>  (cond);
>     DBUG_ASSERT(pfs_cond != NULL);
> @@ -1585,7 +1592,7 @@ static void signal_cond_v1(PSI_thread *t
>     pfs_cond->m_cond_stat.m_signal_count++;
>   }
>
> -static void broadcast_cond_v1(PSI_thread *thread, PSI_cond* cond)
> +static void broadcast_cond_v1(PSI_cond* cond)
>   {
>     PFS_cond *pfs_cond= reinterpret_cast<PFS_cond*>  (cond);
>     DBUG_ASSERT(pfs_cond != NULL);
>
> === modified file 'storage/perfschema/unittest/pfs-t.cc'
> --- a/storage/perfschema/unittest/pfs-t.cc	2010-04-13 11:48:46 +0000
> +++ b/storage/perfschema/unittest/pfs-t.cc	2010-07-09 23:00:24 +0000
> @@ -941,9 +941,13 @@ void test_locker_disabled()
>     ok(file_A1 != NULL, "instrumented");
>
>     PSI_mutex_locker *mutex_locker;
> +  PSI_mutex_locker_state mutex_state;
>     PSI_rwlock_locker *rwlock_locker;
> +  PSI_rwlock_locker_state rwlock_state;
>     PSI_cond_locker *cond_locker;
> +  PSI_cond_locker_state cond_state;
>     PSI_file_locker *file_locker;
> +  PSI_file_locker_state file_state;
>
>     /* Pretend thread T-1 is disabled */
>     /* ------------------------------ */
> @@ -955,17 +959,17 @@ void test_locker_disabled()
>     cond_class_A->m_enabled= true;
>     file_class_A->m_enabled= true;
>
> -  mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK);
> +  mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1,
> PSI_MUTEX_LOCK);
>     ok(mutex_locker == NULL, "no locker");
> -  rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK);
> +  rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1,
> PSI_RWLOCK_READLOCK);
>     ok(rwlock_locker == NULL, "no locker");
> -  cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT);
> +  cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1,
> PSI_COND_WAIT);
>     ok(cond_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx",
> NULL);
> +  file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A,
> PSI_FILE_OPEN, "xxx", NULL);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
>
>     /* Pretend the consumer is disabled */
> @@ -978,17 +982,17 @@ void test_locker_disabled()
>     cond_class_A->m_enabled= true;
>     file_class_A->m_enabled= true;
>
> -  mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK);
> +  mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1,
> PSI_MUTEX_LOCK);
>     ok(mutex_locker == NULL, "no locker");
> -  rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK);
> +  rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1,
> PSI_RWLOCK_READLOCK);
>     ok(rwlock_locker == NULL, "no locker");
> -  cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT);
> +  cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1,
> PSI_COND_WAIT);
>     ok(cond_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx",
> NULL);
> +  file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A,
> PSI_FILE_OPEN, "xxx", NULL);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
>
>     /* Pretend the instrument is disabled */
> @@ -1001,17 +1005,17 @@ void test_locker_disabled()
>     cond_class_A->m_enabled= false;
>     file_class_A->m_enabled= false;
>
> -  mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK);
> +  mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1,
> PSI_MUTEX_LOCK);
>     ok(mutex_locker == NULL, "no locker");
> -  rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK);
> +  rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1,
> PSI_RWLOCK_READLOCK);
>     ok(rwlock_locker == NULL, "no locker");
> -  cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT);
> +  cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1,
> PSI_COND_WAIT);
>     ok(cond_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx",
> NULL);
> +  file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A,
> PSI_FILE_OPEN, "xxx", NULL);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
>
>     /* Pretend everything is enabled */
> @@ -1024,27 +1028,27 @@ void test_locker_disabled()
>     cond_class_A->m_enabled= true;
>     file_class_A->m_enabled= true;
>
> -  mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK);
> +  mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1,
> PSI_MUTEX_LOCK);
>     ok(mutex_locker != NULL, "locker");
>     psi->start_mutex_wait(mutex_locker, __FILE__, __LINE__);
>     psi->end_mutex_wait(mutex_locker, 0);
> -  rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK);
> +  rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1,
> PSI_RWLOCK_READLOCK);
>     ok(rwlock_locker != NULL, "locker");
>     psi->start_rwlock_rdwait(rwlock_locker, __FILE__, __LINE__);
>     psi->end_rwlock_rdwait(rwlock_locker, 0);
> -  cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT);
> +  cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1,
> PSI_COND_WAIT);
>     ok(cond_locker != NULL, "locker");
>     psi->start_cond_wait(cond_locker, __FILE__, __LINE__);
>     psi->end_cond_wait(cond_locker, 0);
> -  file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx",
> NULL);
> +  file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A,
> PSI_FILE_OPEN, "xxx", NULL);
>     ok(file_locker != NULL, "locker");
>     psi->start_file_open_wait(file_locker, __FILE__, __LINE__);
>     psi->end_file_open_wait(file_locker);
> -  file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1,
> PSI_FILE_READ);
>     ok(file_locker != NULL, "locker");
>     psi->start_file_wait(file_locker, 10, __FILE__, __LINE__);
>     psi->end_file_wait(file_locker, 10);
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_READ);
>     ok(file_locker != NULL, "locker");
>     psi->start_file_wait(file_locker, 10, __FILE__, __LINE__);
>     psi->end_file_wait(file_locker, 10);
> @@ -1059,17 +1063,17 @@ void test_locker_disabled()
>     cond_class_A->m_enabled= true;
>     file_class_A->m_enabled= true;
>
> -  mutex_locker= psi->get_thread_mutex_locker(mutex_A1, PSI_MUTEX_LOCK);
> +  mutex_locker= psi->get_thread_mutex_locker(&mutex_state, mutex_A1,
> PSI_MUTEX_LOCK);
>     ok(mutex_locker == NULL, "no locker");
> -  rwlock_locker= psi->get_thread_rwlock_locker(rwlock_A1, PSI_RWLOCK_READLOCK);
> +  rwlock_locker= psi->get_thread_rwlock_locker(&rwlock_state, rwlock_A1,
> PSI_RWLOCK_READLOCK);
>     ok(rwlock_locker == NULL, "no locker");
> -  cond_locker= psi->get_thread_cond_locker(cond_A1, mutex_A1, PSI_COND_WAIT);
> +  cond_locker= psi->get_thread_cond_locker(&cond_state, cond_A1, mutex_A1,
> PSI_COND_WAIT);
>     ok(cond_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "xxx",
> NULL);
> +  file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A,
> PSI_FILE_OPEN, "xxx", NULL);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_stream_locker(file_A1, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_READ);
>     ok(file_locker == NULL, "no locker");
>
>     shutdown_performance_schema();
> @@ -1102,6 +1106,7 @@ void test_file_instrumentation_leak()
>
>     PFS_file_class *file_class_A;
>     PFS_file_class *file_class_B;
> +  PSI_file_locker_state file_state;
>     PSI_thread *thread_1;
>
>     /* Preparation */
> @@ -1130,24 +1135,24 @@ void test_file_instrumentation_leak()
>
>     /* Simulate OPEN + READ of 100 bytes + CLOSE on descriptor 12 */
>
> -  file_locker= psi->get_thread_file_name_locker(file_key_A, PSI_FILE_OPEN, "AAA",
> NULL);
> +  file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A,
> PSI_FILE_OPEN, "AAA", NULL);
>     ok(file_locker != NULL, "locker");
>     psi->start_file_open_wait(file_locker, __FILE__, __LINE__);
>     psi->end_file_open_wait_and_bind_to_descriptor(file_locker, 12);
>
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12, PSI_FILE_READ);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_READ);
>     ok(file_locker != NULL, "locker");
>     psi->start_file_wait(file_locker, 100, __FILE__, __LINE__);
>     psi->end_file_wait(file_locker, 100);
>
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12,
> PSI_FILE_CLOSE);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_CLOSE);
>     ok(file_locker != NULL, "locker");
>     psi->start_file_wait(file_locker, 0, __FILE__, __LINE__);
>     psi->end_file_wait(file_locker, 0);
>
>     /* Simulate uninstrumented-OPEN + WRITE on descriptor 24 */
>
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 24,
> PSI_FILE_WRITE);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 24,
> PSI_FILE_WRITE);
>     ok(file_locker == NULL, "no locker, since the open was not instrumented");
>
>     /*
> @@ -1155,7 +1160,7 @@ void test_file_instrumentation_leak()
>       the instrumentation should not leak (don't charge the file io on unknown B to
> "AAA")
>     */
>
> -  file_locker= psi->get_thread_file_descriptor_locker((File) 12,
> PSI_FILE_WRITE);
> +  file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12,
> PSI_FILE_WRITE);
>     ok(file_locker == NULL, "no locker, no leak");
>
>     shutdown_performance_schema();
>
>
>
>
>
Thread
bzr commit into mysql-trunk-bugfixing branch (marc.alff:3103) Bug#55087Marc Alff10 Jul
  • Re: bzr commit into mysql-trunk-bugfixing branch (marc.alff:3103)Bug#55087Christopher Powers12 Jul