From: Marc Alff Date: June 25 2010 7:56am Subject: bzr commit into mysql-next-mr-bugfixing branch (marc.alff:3271) Bug#54782 List-Archive: http://lists.mysql.com/commits/112172 X-Bug: 54782 Message-Id: <201006250757.o5P6H6ja012153@rcsinet13.oracle.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============8419687105351728068==" --===============8419687105351728068== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///Users/malff/BZR_TREE/mysql-next-mr-bugfixing-54782/ based on revid:martin.hansson@stripped 3271 Marc Alff 2010-06-25 Bug#54782 Performance schema per thread accounting and thread cache Before this fix, when using the performance schema with the thread cache, a thread executing connection A, then cached, then executing connection B would account B actions with the statistics for A. With this fix: - the instrumentation for connection A is cleaned up when A completes, - a new instrumentation for connection B is created when B is executed from a cached thread. added: mysql-test/suite/perfschema/r/thread_cache.result mysql-test/suite/perfschema/t/thread_cache.test modified: sql/mysqld.cc === added file 'mysql-test/suite/perfschema/r/thread_cache.result' --- a/mysql-test/suite/perfschema/r/thread_cache.result 1970-01-01 00:00:00 +0000 +++ b/mysql-test/suite/perfschema/r/thread_cache.result 2010-06-25 07:56:10 +0000 @@ -0,0 +1,34 @@ +SET @saved_thread_cache_size = @@global.thread_cache_size; +set global thread_cache_size = 0; +show variables like "thread_cache_size"; +Variable_name Value +thread_cache_size 0 +select @id_increment; +@id_increment +1 +select @thread_id_increment; +@thread_id_increment +1 +select @id_increment; +@id_increment +1 +select @thread_id_increment; +@thread_id_increment +1 +set global thread_cache_size = 100; +show variables like "thread_cache_size"; +Variable_name Value +thread_cache_size 100 +select @id_increment; +@id_increment +1 +select @thread_id_increment; +@thread_id_increment +1 +select @id_increment; +@id_increment +1 +select @thread_id_increment; +@thread_id_increment +1 +set global thread_cache_size = @saved_thread_cache_size; === added file 'mysql-test/suite/perfschema/t/thread_cache.test' --- a/mysql-test/suite/perfschema/t/thread_cache.test 1970-01-01 00:00:00 +0000 +++ b/mysql-test/suite/perfschema/t/thread_cache.test 2010-06-25 07:56:10 +0000 @@ -0,0 +1,134 @@ +# Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; version 2 of the License. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA + +# Tests for PERFORMANCE_SCHEMA + +--source include/not_embedded.inc +--source include/have_perfschema.inc + +# Setup + +SET @saved_thread_cache_size = @@global.thread_cache_size; + +set global thread_cache_size = 0; + +show variables like "thread_cache_size"; + +connect (con1, localhost, root, , ); + +let $con1_ID=`select connection_id()`; + +let $con1_THREAD_ID=`select thread_id from performance_schema.PROCESSLIST + where ID = connection_id()`; + +connect (con2, localhost, root, , ); + +let $con2_ID=`select connection_id()`; + +let $con2_THREAD_ID=`select thread_id from performance_schema.PROCESSLIST + where ID = connection_id()`; + +connection default; + +--disable_query_log +eval select ($con2_ID - $con1_ID) into @id_increment; +eval select ($con2_THREAD_ID - $con1_THREAD_ID) into @thread_id_increment; +--enable_query_log + +# Expect 1, connection_id() is incremented for each new connection +select @id_increment; +# Expect 1, THREAD_ID is incremented for each new connection +select @thread_id_increment; + +disconnect con2; + +connect (con3, localhost, root, , ); + +let $con3_ID=`select connection_id()`; + +let $con3_THREAD_ID=`select thread_id from performance_schema.PROCESSLIST + where ID = connection_id()`; + +disconnect con3; +disconnect con1; + +connection default; + +--disable_query_log +eval select ($con3_ID - $con2_ID) into @id_increment; +eval select ($con3_THREAD_ID - $con2_THREAD_ID) into @thread_id_increment; +--enable_query_log + +select @id_increment; +select @thread_id_increment; + +set global thread_cache_size = 100; + +show variables like "thread_cache_size"; + +connect (con1, localhost, root, , ); + +let $con1_ID=`select connection_id()`; + +let $con1_THREAD_ID=`select thread_id from performance_schema.PROCESSLIST + where ID = connection_id()`; + +connect (con2, localhost, root, , ); + +let $con2_ID=`select connection_id()`; + +let $con2_THREAD_ID=`select thread_id from performance_schema.PROCESSLIST + where ID = connection_id()`; + +connection default; + +--disable_query_log +eval select ($con2_ID - $con1_ID) into @id_increment; +eval select ($con2_THREAD_ID - $con1_THREAD_ID) into @thread_id_increment; +--enable_query_log + +select @id_increment; +select @thread_id_increment; + +disconnect con2; + +connect (con3, localhost, root, , ); + +let $con3_ID=`select connection_id()`; + +let $con3_THREAD_ID=`select thread_id from performance_schema.PROCESSLIST + where ID = connection_id()`; + +disconnect con3; +disconnect con1; + +connection default; + +--disable_query_log +eval select ($con3_ID - $con2_ID) into @id_increment; +eval select ($con3_THREAD_ID - $con2_THREAD_ID) into @thread_id_increment; +--enable_query_log + +# When caching threads, the pthread that executed con2 was parked in the +# cache on disconnect, and then picked up con3. + +# Still expect a new connection_id() +select @id_increment; + +# And expect a new instrumentation: the THREAD_ID of old connections should not be reused. +select @thread_id_increment; + +set global thread_cache_size = @saved_thread_cache_size; + === modified file 'sql/mysqld.cc' --- a/sql/mysqld.cc 2010-06-21 07:58:54 +0000 +++ b/sql/mysqld.cc 2010-06-25 07:56:10 +0000 @@ -2143,6 +2143,16 @@ static bool cache_thread() /* Don't kill the thread, just put it in cache for reuse */ DBUG_PRINT("info", ("Adding thread to cache")); cached_thread_count++; + +#ifdef HAVE_PSI_INTERFACE + /* + Delete the instrumentation for the job that just completed, + before parking this pthread in the cache (blocked on COND_thread_cache). + */ + if (likely(PSI_server != NULL)) + PSI_server->delete_current_thread(); +#endif + while (!abort_loop && ! wake_thread && ! kill_cached_threads) mysql_cond_wait(&COND_thread_cache, &LOCK_thread_count); cached_thread_count--; @@ -2155,6 +2165,21 @@ static bool cache_thread() thd= thread_cache.get(); thd->thread_stack= (char*) &thd; // For store_globals (void) thd->store_globals(); + +#ifdef HAVE_PSI_INTERFACE + /* + Create new instrumentation for the new THD job, + and attach it to this running pthread. + */ + if (likely(PSI_server != NULL)) + { + PSI_thread *psi= PSI_server->new_thread(key_thread_one_connection, + thd, thd->thread_id); + if (likely(psi != NULL)) + PSI_server->set_thread(psi); + } +#endif + /* THD::mysys_var::abort is associated with physical thread rather than with THD object. So we need to reset this flag before using --===============8419687105351728068== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/marc.alff@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: marc.alff@stripped # target_branch: file:///Users/malff/BZR_TREE/mysql-next-mr-bugfixing-\ # 54782/ # testament_sha1: c332e68ae2298d392c7871d0e9f5818a35f85246 # timestamp: 2010-06-25 01:56:26 -0600 # base_revision_id: martin.hansson@stripped\ # 4hkdi8ubgge6mud2 # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWaUJnBoABR7fgFUwfHf//3/n 36D////6YAwuPfPdh71qHlCi951O7uN7zusU9PXc1ttvWuRpToMJSKnso9T1MSDaE9ANRmhNAADI AaAACSSZMQGgVP0IRomhpoGTEyMmRkD0nqD1NBxoyZGEYgGE0GATQaBkyaMmQwgMJTJI1U/JTwTQ 001HqaeiNGgAGjQAAaBkCJSJiIyT1MamamRo9Rp6mg0yNGmg0GjR6jIaAkhCAmRqbQJpqZHpGQZK eKeptJobUeoGg8o9Q0AzBbziurPVwaVe00IFRu0UZcDBSNENHe8uUGBNfmkI62UcGHucDevXv2O2 nPZNH8OQi6J2sVXn0uOASm1cxb/rSztsKB1H+wNwKATkWcRioO5REDEGPbJEI3d40aSspq9uCJwc tTCWF1FgoFJTSQzVOHMANaBCyi9JosDfNYhCEIQWkXBlWsXFhXfEDwW/JmZGXd8DENFNDkSNjlWy ok3ap1x7mnl2cJS5Z0AyFgYi7gY8xA4QDB+eS4Uz46ZxY4tUo/leasD/aqFQrU04Yp3GyrHbrXPK Y2Nn+s96z/TNJ+t6eqmb/8tv7GCqq8dslG+XGf2/obaLUeNGwZ8Inw2imKq+28MGewo7Uli9FMJE EOfbxntoKsTVepnBiY2DMd4GWe1mjnT7br8pTi4MxTPUqVmY7Y9fRc1vKU6uq65VStbSLbII4O8O 9A36RSkQBxiFMV7/ap6/RnpXtkuumoxs2Qzl84J3UnPJ9QtoqpuSFvlCzBWuritiOkhpuapqY8u1 x4oqc6srdtwVKVCdCqDFouEN8UxwKAcpAhAhCEEvq98ohSIteFOtj5wF6EhcJG5iCcp0dLWT3S9c e0SwJI1S5VKXScCBXWeD/eVqDeC/8XbRztp4AwMI20EcekNZdRLTkjViAvSQmQpY30BzzmFSX4JV WFGZeqYhK6IMWpVJDKUQLE/cdnZ1KdeThWXLr9hl85WIJkwhwUd8lHxgcsGBH5dqEVkDDMObiyVx T4AxA0E7DlaStEEXCVchV3HZRUYor62blWe6olTGZuG5WB5wGVcObBtXwuusEZwCKDGj4uZcTd54 keEfDvhO4sjlj0z5YQ0skbIhwVB55KReXtY41ORkWCPTHHwdvIzkcjRMBuXRuM6zg41JhbSVUpml 0WHcETOG6y2gUa1SEHLZ0FVLLbBG85E/wqNl2q+0VBLuG60nyYM7KSOKgOs1LCNwVrCUVSuszvID UWBpz8oHN2orMRajUyT9QqrdLEvqk8wRkvoEVlXRonKxw44yvKjAtJmG8B6kG/wouRXItnNzW54Z iUHlV9OaGOQMTO9cX+jLVZWY9JcIyhB1z87hijw452UlsgtMs7iwa4RwLMZMgHmNYMdLXMV6rkTJ UNwu7dUr2tk6hodD8cyzIt1LdCV6SrJxcPHaFhpojAqN7yBMR5hExDrgrmZvuKx16feVvs2MCuRt 3VQebE9DS9aFmLjNRJEzGLPgVs88QbAx5JSwdONVa+GbUoyzgKUhDVNMKCqo2Xghtxzloi4sGd0Q hCEWyXlBpBFTZGRZYeDHyV7wbCHM5aDfxWMLnbqgSSeoHFxObFHAc5n1AqB21IGm1BQHl6CifHQc YBX+flZ7+r+XitchpszJl67HP8jzsF2XUr7G63JK5kIkAR9n+EpgGEuvrGO/cNx1FMRgISKUhbSC H9AqGCnohkF2t3WAMutwtHKQcGubfbfB0hvgq06IqXmm1ah7BZnUcYdnM5FL552gDJ9wtKzV18Oc rAgKKWgrkoFBXwUp2A4wi+CUky6GVkXXn8zQSTU2EfqOE7wg4iRgxkkkYTLFChY0kIZxQEaztUHv CyUKpCoAYP1AhSIffnoOkljQQZOb+mviEvKC6wVEfXqwFC8D3Ez1GZ9x+3p7R5zcNwcH30NuB7gA 6uoFB6ABpVCrZf8BmB9SRMXjun5jARNMiyPAB/0xDCrgm/XzxSO6tEF5sAyaQr3dCvMbxBpSVvGF TaDj+Junrz5o1RYBKWdMhKnFBcJfRHiIoOSSK/npwDRd02US6xHzPWQIhGBsw4n0NGJgv1swCZbR Nb2qw6jQZAW7sg+jlSnJ0kuSBh72cFfMuEtsGYx9wGcYcE46cBuKxKoTgycAbjTEBbekkF3vjUER nr6ussUuZKkUZRNOg4HQSCEJ5ktFJStTVlt0OrVdJyuedM0TRxHQSmAJgAa0Jjy8guPMX8RzWH3r tj6KDuDj2BqFTQ1en6lXeeB6Dgb21mkH9NAOZAMJsBuNbyhRB1DFTDNNj1cZlcjN6qpPS0ILLUhx cHTVm88e+RrpJr+VU133hNlqoWssXc7rFMTGjAaCoIORcl0shmQCqaDHYN0EAXC2DgDDicEyQv8B ovsdX7naGpxkSpu3OF+/APzmebr6OLNSZiwV+F+nVgW7ubcuo5wWAhxYcTrobuMQKDhm6HQfRxhm AtgDAi2p0MW+R0+njmrxfwqA1TriBecDsCZ136ITfthTBVC2NjAde8KeQDm4sgHE16W/Rgd7L0Yj wHmN68TNjlw0DCcG7RIQRwZCIpDGBWxKRBgZbf8mulhVsezeZnv6ZoNRxAc6GAfgpSxgRQDsb1mr QmE/VRLRdRTw2ro4LQG4g3xAeVPVnvcEGGZCZkgjq2UU4SvRCi1UM5HZb/aG4rgQVchTaAqploZ2 raW3JQo6Apt7l3mRNmIXBCQJAYGBhPXK0+vy/LV7yaNBWByEbbfKxWTZOuI5qABDyDkvOrr18G9a jyeHcwYC/BYQjBZCwJDJkZpGHjFCogHg10O8w/xdzdWF6EXVGYiRJeYkd2lMGiRfC17RT24m9YJh LL5Dkg1BNxT74WOHTYpG0jvCVWghQNgGhmObTQLbGurUMl0QfWRnf8gExR0AlKtLLAeYJhGTDC4s hO0INYHeeIMvJ1spKdSGAC5DErzf03evIsqFCt/CvDGzbksKlVhQJNjgSBXTDJDFEwxAEBxEZmhT KkDAgbcwOKtVFfUkgm9Sil6LZAQZ0YvSQSibcc4FoRViHASYEDOA6ZkQ68TPtEOI+p8N/zCDkko0 aUfE52lALzei7iBhWqBIN6FQiRLGK7HHdeVCsuXdlXPj0onYI8CmEdSpHPU4B9vZyjCa/T4rDoNJ sIR1LCFq5smQxAXewIA3xziayseFX7D7cSQeBaa+eelG0RhpA+QdpYI7WHO9lky/SSAdXr1cPLYC 2jFBVKkcBJLy8dhadfRIQFQXsinvTc/jcGCCAmkbcIdNZkkcpeqfJUSmK2qe0hyskiqQoTAR5xZO 6gN9UA0n0E/h3POYcvQF5iLTNKq0MSgGsA+wLZSxEhePjMJK2soGat4TFRCKLNiWStO787O5gpmr 3cRMp31ZCcVogGyfkSAkC3geRhb2EErnLLdMApUrExAqLfSoVJwKNMyCzvaAZJFlHUhNX0NVCGtu rnFTyKDWTXI51RJGDUXhMchzOCInQwzDhN5dxCWkoEhiAcuIFx3AEo9+OzZ1ePSOt244CKwZkwA0 AWnIsShe4RbBDIzbqukiyfT2KWJAYfyXzXDymWrmusPaB7vTnpxTZroDWh1I2w5zglBhrke+6bTG Y9dAKBabrnDInuUkUgWZrdK8GxUzEYSwPK/cYekPa9gOPyEfoSEQeo23asNXStpIRZgGPijqGx7Q 6AtEcckIoNd2zv6HrP/F3JFOFCQpQmcGgA== --===============8419687105351728068==--