\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Thu, 22 Oct 2020 at 20:34, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n>\\n> On Thu, Oct 22, 2020 at 4:09 PM Masahiko Sawada\\n> <masahiko.sawada@2ndquadrant.com> wrote:\\n> >\\n> > On Wed, 21 Oct 2020 at 12:56, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> > >\\n> > > On Tue, Oct 13, 2020 at 10:33 AM Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> > > >\\n> > > > On Tue, Oct 13, 2020 at 10:21 AM Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> > > > >\\n> > > > >\\n> > > > > I know I can go read the source code, but most users will not want to.\\n> > > > > Is the documentation in monitoring.sgml really sufficient? If we can't\\n> > > > > explain this with more precision, is it really a number we want to expose\\n> > > > > at all?\\n> > > > >\\n> > > >\\n> > > > This counter is important to give users an idea about the amount of\\n> > > > I/O we incur during decoding and to tune logical_decoding_work_mem\\n> > > > GUC. So, I would prefer to improve the documentation for this\\n> > > > variable.\\n> > > >\\n> > >\\n> > > I have modified the description of spill_count and spill_txns to make\\n> > > things clear. Any suggestions?\\n> >\\n> > Thank you for the patch.\\n> >\\n> > - logical decoding exceeds\\n> > <literal>logical_decoding_work_mem</literal>. The\\n> > - counter gets incremented both for toplevel transactions and\\n> > - subtransactions.\\n> > + logical decoding of changes from WAL for this exceeds\\n> > + <literal>logical_decoding_work_mem</literal>. The counter gets\\n> > + incremented both for toplevel transactions and subtransactions.\\n> >\\n> > What is the word \\\"this\\\" in the above change referring to?\\n> >\\n>\\n> 'slot'. The word *slot* is missing in the sentence.\\n>\\n> > How about\\n> > something like:\\n> >\\n>\\n> > Number of transactions spilled to disk after the memory used by\\n> > logical decoding of changes from WAL exceeding\\n> > logical_decoding_work_mem. The counter gets incremented both for\\n> > toplevel transactions and subtransactions.\\n> >\\n>\\n> /exceeding/exceeds. I am fine with your proposed text as well but if\\n> you like the above after correction that would be better because it\\n> would be more close to spill_count description.\\n\\nyeah, I agree with the correction.\\n\\nRegards,\\n\\n-- \\nMasahiko Sawada http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\",\n \"msg_date\": \"Fri, 23 Oct 2020 11:12:17 +0900\",\n \"msg_from\": \"Masahiko Sawada <masahiko.sawada@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Fri, Oct 23, 2020 at 7:42 AM Masahiko Sawada\\n<masahiko.sawada@2ndquadrant.com> wrote:\\n>\\n> On Thu, 22 Oct 2020 at 20:34, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> >\\n> > > > I have modified the description of spill_count and spill_txns to make\\n> > > > things clear. Any suggestions?\\n> > >\\n> > > Thank you for the patch.\\n> > >\\n> > > - logical decoding exceeds\\n> > > <literal>logical_decoding_work_mem</literal>. The\\n> > > - counter gets incremented both for toplevel transactions and\\n> > > - subtransactions.\\n> > > + logical decoding of changes from WAL for this exceeds\\n> > > + <literal>logical_decoding_work_mem</literal>. The counter gets\\n> > > + incremented both for toplevel transactions and subtransactions.\\n> > >\\n> > > What is the word \\\"this\\\" in the above change referring to?\\n> > >\\n> >\\n> > 'slot'. The word *slot* is missing in the sentence.\\n> >\\n> > > How about\\n> > > something like:\\n> > >\\n> >\\n> > > Number of transactions spilled to disk after the memory used by\\n> > > logical decoding of changes from WAL exceeding\\n> > > logical_decoding_work_mem. The counter gets incremented both for\\n> > > toplevel transactions and subtransactions.\\n> > >\\n> >\\n> > /exceeding/exceeds. I am fine with your proposed text as well but if\\n> > you like the above after correction that would be better because it\\n> > would be more close to spill_count description.\\n>\\n> yeah, I agree with the correction.\\n>\\n\\nOkay, thanks, attached is an updated patch. I'll push this early next\\nweek unless you or someone else has any comments/suggestions.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\",\n \"msg_date\": \"Fri, 23 Oct 2020 08:59:19 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Fri, Oct 23, 2020 at 8:59 AM Amit Kapila <amit.kapila16@gmail.com> wrote:\\n>\\n> On Fri, Oct 23, 2020 at 7:42 AM Masahiko Sawada\\n> <masahiko.sawada@2ndquadrant.com> wrote:\\n> >\\n> > On Thu, 22 Oct 2020 at 20:34, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> > >\\n> > > > > I have modified the description of spill_count and spill_txns to make\\n> > > > > things clear. Any suggestions?\\n> > > >\\n> > > > Thank you for the patch.\\n> > > >\\n> > > > - logical decoding exceeds\\n> > > > <literal>logical_decoding_work_mem</literal>. The\\n> > > > - counter gets incremented both for toplevel transactions and\\n> > > > - subtransactions.\\n> > > > + logical decoding of changes from WAL for this exceeds\\n> > > > + <literal>logical_decoding_work_mem</literal>. The counter gets\\n> > > > + incremented both for toplevel transactions and subtransactions.\\n> > > >\\n> > > > What is the word \\\"this\\\" in the above change referring to?\\n> > > >\\n> > >\\n> > > 'slot'. The word *slot* is missing in the sentence.\\n> > >\\n> > > > How about\\n> > > > something like:\\n> > > >\\n> > >\\n> > > > Number of transactions spilled to disk after the memory used by\\n> > > > logical decoding of changes from WAL exceeding\\n> > > > logical_decoding_work_mem. The counter gets incremented both for\\n> > > > toplevel transactions and subtransactions.\\n> > > >\\n> > >\\n> > > /exceeding/exceeds. I am fine with your proposed text as well but if\\n> > > you like the above after correction that would be better because it\\n> > > would be more close to spill_count description.\\n> >\\n> > yeah, I agree with the correction.\\n> >\\n>\\n> Okay, thanks, attached is an updated patch.\\n>\\n\\nWhile updating the streaming stats patch, it occurred to me that we\\ncan write a better description spill_bytes as well. Attached contains\\nthe update to spill_bytes description.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\",\n \"msg_date\": \"Fri, 23 Oct 2020 10:45:34 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Fri, Oct 23, 2020 at 10:45:34AM +0530, Amit Kapila wrote:\\n> On Fri, Oct 23, 2020 at 8:59 AM Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> >\\n> > On Fri, Oct 23, 2020 at 7:42 AM Masahiko Sawada\\n> > <masahiko.sawada@2ndquadrant.com> wrote:\\n> > >\\n> > > On Thu, 22 Oct 2020 at 20:34, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> > > >\\n> > > > > > I have modified the description of spill_count and spill_txns to make\\n> > > > > > things clear. Any suggestions?\\n> > > > >\\n> > > > > Thank you for the patch.\\n> > > > >\\n> > > > > - logical decoding exceeds\\n> > > > > <literal>logical_decoding_work_mem</literal>. The\\n> > > > > - counter gets incremented both for toplevel transactions and\\n> > > > > - subtransactions.\\n> > > > > + logical decoding of changes from WAL for this exceeds\\n> > > > > + <literal>logical_decoding_work_mem</literal>. The counter gets\\n> > > > > + incremented both for toplevel transactions and subtransactions.\\n> > > > >\\n> > > > > What is the word \\\"this\\\" in the above change referring to?\\n> > > > >\\n> > > >\\n> > > > 'slot'. The word *slot* is missing in the sentence.\\n> > > >\\n> > > > > How about\\n> > > > > something like:\\n> > > > >\\n> > > >\\n> > > > > Number of transactions spilled to disk after the memory used by\\n> > > > > logical decoding of changes from WAL exceeding\\n> > > > > logical_decoding_work_mem. The counter gets incremented both for\\n> > > > > toplevel transactions and subtransactions.\\n> > > > >\\n> > > >\\n> > > > /exceeding/exceeds. I am fine with your proposed text as well but if\\n> > > > you like the above after correction that would be better because it\\n> > > > would be more close to spill_count description.\\n> > >\\n> > > yeah, I agree with the correction.\\n> > >\\n> >\\n> > Okay, thanks, attached is an updated patch.\\n> >\\n> \\n> While updating the streaming stats patch, it occurred to me that we\\n> can write a better description spill_bytes as well. Attached contains\\n> the update to spill_bytes description.\\n\\n+ This and other spill\\n+ counters can be used to gauge the I/O occurred during logical decoding\\n+ and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n\\n\\\"gauge the IO occurred\\\" is wrong.\\nEither: I/O *which* occured, or I/O occurring, or occurs.\\n\\n\\\"can tune\\\" should say \\\"allow tuning\\\".\\n\\nLike:\\n+ This and other spill\\n+ counters can be used to gauge the I/O which occurs during logical decoding\\n+ and accordingly allow tuning of <literal>logical_decoding_work_mem</literal>.\\n\\n- Number of times transactions were spilled to disk. Transactions\\n+ Number of times transactions were spilled to disk while performing\\n+ decoding of changes from WAL for this slot. Transactions\\n\\nWhat about: \\\"..while decoding changes..\\\" (remove \\\"performing\\\" and \\\"of\\\").\\n\\n-- \\nJustin\\n\\n\\n\",\n \"msg_date\": \"Mon, 26 Oct 2020 22:21:01 -0500\",\n \"msg_from\": \"Justin Pryzby <pryzby@telsasoft.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Tue, Oct 27, 2020 at 8:51 AM Justin Pryzby <pryzby@telsasoft.com> wrote:\\n>\\n> On Fri, Oct 23, 2020 at 10:45:34AM +0530, Amit Kapila wrote:\\n> > On Fri, Oct 23, 2020 at 8:59 AM Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> >\\n> > While updating the streaming stats patch, it occurred to me that we\\n> > can write a better description spill_bytes as well. Attached contains\\n> > the update to spill_bytes description.\\n>\\n> + This and other spill\\n> + counters can be used to gauge the I/O occurred during logical decoding\\n> + and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n>\\n> \\\"gauge the IO occurred\\\" is wrong.\\n> Either: I/O *which* occured, or I/O occurring, or occurs.\\n>\\n> \\\"can tune\\\" should say \\\"allow tuning\\\".\\n>\\n> Like:\\n> + This and other spill\\n> + counters can be used to gauge the I/O which occurs during logical decoding\\n> + and accordingly allow tuning of <literal>logical_decoding_work_mem</literal>.\\n>\\n> - Number of times transactions were spilled to disk. Transactions\\n> + Number of times transactions were spilled to disk while performing\\n> + decoding of changes from WAL for this slot. Transactions\\n>\\n> What about: \\\"..while decoding changes..\\\" (remove \\\"performing\\\" and \\\"of\\\").\\n>\\n\\nAll of your suggestions sound good to me. Find the patch attached to\\nupdate the docs accordingly.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\",\n \"msg_date\": \"Tue, 27 Oct 2020 09:17:43 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Tue, Oct 27, 2020 at 09:17:43AM +0530, Amit Kapila wrote:\\n> On Tue, Oct 27, 2020 at 8:51 AM Justin Pryzby <pryzby@telsasoft.com> wrote:\\n> >\\n> > On Fri, Oct 23, 2020 at 10:45:34AM +0530, Amit Kapila wrote:\\n> > > On Fri, Oct 23, 2020 at 8:59 AM Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> > >\\n> > > While updating the streaming stats patch, it occurred to me that we\\n> > > can write a better description spill_bytes as well. Attached contains\\n> > > the update to spill_bytes description.\\n> >\\n> > + This and other spill\\n> > + counters can be used to gauge the I/O occurred during logical decoding\\n> > + and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n> >\\n> > \\\"gauge the IO occurred\\\" is wrong.\\n> > Either: I/O *which* occured, or I/O occurring, or occurs.\\n> >\\n> > \\\"can tune\\\" should say \\\"allow tuning\\\".\\n> >\\n> > Like:\\n> > + This and other spill\\n> > + counters can be used to gauge the I/O which occurs during logical decoding\\n> > + and accordingly allow tuning of <literal>logical_decoding_work_mem</literal>.\\n> >\\n> > - Number of times transactions were spilled to disk. Transactions\\n> > + Number of times transactions were spilled to disk while performing\\n> > + decoding of changes from WAL for this slot. Transactions\\n> >\\n> > What about: \\\"..while decoding changes..\\\" (remove \\\"performing\\\" and \\\"of\\\").\\n> >\\n> \\n> All of your suggestions sound good to me. Find the patch attached to\\n> update the docs accordingly.\\n\\n@@ -2628,8 +2627,8 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i\\n <para>\\n Amount of decoded transaction data spilled to disk while performing\\n decoding of changes from WAL for this slot. This and other spill\\n- counters can be used to gauge the I/O occurred during logical decoding\\n- and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n+ counters can be used to gauge the I/O which occurred during logical\\n+ decoding and accordingly allow tuning <literal>logical_decoding_work_mem</literal>.\\n\\nNow that I look again, maybe remove \\\"accordingly\\\" ?\\n\\n-- \\nJustin\\n\\n\\n\",\n \"msg_date\": \"Tue, 27 Oct 2020 18:19:42 -0500\",\n \"msg_from\": \"Justin Pryzby <pryzby@telsasoft.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Tue, Oct 27, 2020 at 06:19:42PM -0500, Justin Pryzby wrote:\\n>On Tue, Oct 27, 2020 at 09:17:43AM +0530, Amit Kapila wrote:\\n>> On Tue, Oct 27, 2020 at 8:51 AM Justin Pryzby <pryzby@telsasoft.com> wrote:\\n>> >\\n>> > On Fri, Oct 23, 2020 at 10:45:34AM +0530, Amit Kapila wrote:\\n>> > > On Fri, Oct 23, 2020 at 8:59 AM Amit Kapila <amit.kapila16@gmail.com> wrote:\\n>> > >\\n>> > > While updating the streaming stats patch, it occurred to me that we\\n>> > > can write a better description spill_bytes as well. Attached contains\\n>> > > the update to spill_bytes description.\\n>> >\\n>> > + This and other spill\\n>> > + counters can be used to gauge the I/O occurred during logical decoding\\n>> > + and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n>> >\\n>> > \\\"gauge the IO occurred\\\" is wrong.\\n>> > Either: I/O *which* occured, or I/O occurring, or occurs.\\n>> >\\n>> > \\\"can tune\\\" should say \\\"allow tuning\\\".\\n>> >\\n>> > Like:\\n>> > + This and other spill\\n>> > + counters can be used to gauge the I/O which occurs during logical decoding\\n>> > + and accordingly allow tuning of <literal>logical_decoding_work_mem</literal>.\\n>> >\\n>> > - Number of times transactions were spilled to disk. Transactions\\n>> > + Number of times transactions were spilled to disk while performing\\n>> > + decoding of changes from WAL for this slot. Transactions\\n>> >\\n>> > What about: \\\"..while decoding changes..\\\" (remove \\\"performing\\\" and \\\"of\\\").\\n>> >\\n>>\\n>> All of your suggestions sound good to me. Find the patch attached to\\n>> update the docs accordingly.\\n>\\n>@@ -2628,8 +2627,8 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i\\n> <para>\\n> Amount of decoded transaction data spilled to disk while performing\\n> decoding of changes from WAL for this slot. This and other spill\\n>- counters can be used to gauge the I/O occurred during logical decoding\\n>- and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n>+ counters can be used to gauge the I/O which occurred during logical\\n>+ decoding and accordingly allow tuning <literal>logical_decoding_work_mem</literal>.\\n>\\n>Now that I look again, maybe remove \\\"accordingly\\\" ?\\n>\\n\\nYeah, the 'accordingly' seems rather unnecessary here. Let's remove it.\\n\\n\\nFWIW thanks to everyone working on this and getting the reworked version\\nof the 9290ad198b patch in. As an author of that patch I should have\\npaid more attention to this thread, and I appreciate the amount of work\\nspent on fixing it.\\n\\n\\nregards\\n\\n-- \\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services \\n\\n\\n\",\n \"msg_date\": \"Wed, 28 Oct 2020 00:56:23 +0100\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n },\n {\n \"msg_contents\": \"On Wed, Oct 28, 2020 at 5:26 AM Tomas Vondra\\n<tomas.vondra@2ndquadrant.com> wrote:\\n>\\n> On Tue, Oct 27, 2020 at 06:19:42PM -0500, Justin Pryzby wrote:\\n> >On Tue, Oct 27, 2020 at 09:17:43AM +0530, Amit Kapila wrote:\\n> >> On Tue, Oct 27, 2020 at 8:51 AM Justin Pryzby <pryzby@telsasoft.com> wrote:\\n> >> >\\n> >> > On Fri, Oct 23, 2020 at 10:45:34AM +0530, Amit Kapila wrote:\\n> >> > > On Fri, Oct 23, 2020 at 8:59 AM Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> >> > >\\n> >> > > While updating the streaming stats patch, it occurred to me that we\\n> >> > > can write a better description spill_bytes as well. Attached contains\\n> >> > > the update to spill_bytes description.\\n> >> >\\n> >> > + This and other spill\\n> >> > + counters can be used to gauge the I/O occurred during logical decoding\\n> >> > + and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n> >> >\\n> >> > \\\"gauge the IO occurred\\\" is wrong.\\n> >> > Either: I/O *which* occured, or I/O occurring, or occurs.\\n> >> >\\n> >> > \\\"can tune\\\" should say \\\"allow tuning\\\".\\n> >> >\\n> >> > Like:\\n> >> > + This and other spill\\n> >> > + counters can be used to gauge the I/O which occurs during logical decoding\\n> >> > + and accordingly allow tuning of <literal>logical_decoding_work_mem</literal>.\\n> >> >\\n> >> > - Number of times transactions were spilled to disk. Transactions\\n> >> > + Number of times transactions were spilled to disk while performing\\n> >> > + decoding of changes from WAL for this slot. Transactions\\n> >> >\\n> >> > What about: \\\"..while decoding changes..\\\" (remove \\\"performing\\\" and \\\"of\\\").\\n> >> >\\n> >>\\n> >> All of your suggestions sound good to me. Find the patch attached to\\n> >> update the docs accordingly.\\n> >\\n> >@@ -2628,8 +2627,8 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i\\n> > <para>\\n> > Amount of decoded transaction data spilled to disk while performing\\n> > decoding of changes from WAL for this slot. This and other spill\\n> >- counters can be used to gauge the I/O occurred during logical decoding\\n> >- and accordingly can tune <literal>logical_decoding_work_mem</literal>.\\n> >+ counters can be used to gauge the I/O which occurred during logical\\n> >+ decoding and accordingly allow tuning <literal>logical_decoding_work_mem</literal>.\\n> >\\n> >Now that I look again, maybe remove \\\"accordingly\\\" ?\\n> >\\n>\\n> Yeah, the 'accordingly' seems rather unnecessary here. Let's remove it.\\n>\\n\\nRemoved and pushed.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\n\\n\\n\",\n \"msg_date\": \"Wed, 28 Oct 2020 08:04:31 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Resetting spilled txn statistics in pg_stat_replication\"\n }\n]","isConversational":false}}},{"rowIdx":50396,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hello.\n\nI noticed that UpdateSpillStats calls \"elog(DEBUG2\" within\nSpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\nin the first place the rb cannot be modified during the function is\nrunning.\n\nIt should be out of the lock section.\n\nregards.\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center","msg_date":"Tue, 02 Jun 2020 16:15:18 +0900 (JST)","msg_from":"Kyotaro Horiguchi <horikyota.ntt@gmail.com>","msg_from_op":true,"msg_subject":"elog(DEBUG2 in SpinLocked section."},{"msg_contents":"\n\nOn 2020/06/02 16:15, Kyotaro Horiguchi wrote:\n> Hello.\n> \n> I noticed that UpdateSpillStats calls \"elog(DEBUG2\" within\n> SpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\n> in the first place the rb cannot be modified during the function is\n> running.\n> \n> It should be out of the lock section.\n\nThanks for the patch! It looks good to me.\n\nRegards,\n\n-- \nFujii Masao\nAdvanced Computing Technology Center\nResearch and Development Headquarters\nNTT DATA CORPORATION\n\n\n","msg_date":"Tue, 2 Jun 2020 17:35:48 +0900","msg_from":"Fujii Masao <masao.fujii@oss.nttdata.com>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Tue, Jun 2, 2020 at 2:05 PM Fujii Masao <masao.fujii@oss.nttdata.com> wrote:\n>\n> On 2020/06/02 16:15, Kyotaro Horiguchi wrote:\n> > Hello.\n> >\n> > I noticed that UpdateSpillStats calls \"elog(DEBUG2\" within\n> > SpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\n> > in the first place the rb cannot be modified during the function is\n> > running.\n> >\n> > It should be out of the lock section.\n\nRight.\n\n>\n> Thanks for the patch! It looks good to me.\n>\n\nThe patch looks good to me as well. I will push this unless Fujii-San\nwants to do it.\n\n-- \nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\n\n","msg_date":"Tue, 2 Jun 2020 14:12:37 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"\n\nOn 2020/06/02 17:42, Amit Kapila wrote:\n> On Tue, Jun 2, 2020 at 2:05 PM Fujii Masao <masao.fujii@oss.nttdata.com> wrote:\n>>\n>> On 2020/06/02 16:15, Kyotaro Horiguchi wrote:\n>>> Hello.\n>>>\n>>> I noticed that UpdateSpillStats calls \"elog(DEBUG2\" within\n>>> SpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\n>>> in the first place the rb cannot be modified during the function is\n>>> running.\n>>>\n>>> It should be out of the lock section.\n> \n> Right.\n> \n>>\n>> Thanks for the patch! It looks good to me.\n>>\n> \n> The patch looks good to me as well. I will push this unless Fujii-San\n> wants to do it.\n\nThanks! I pushed the patch.\n\nRegards,\n\n-- \nFujii Masao\nAdvanced Computing Technology Center\nResearch and Development Headquarters\nNTT DATA CORPORATION\n\n\n","msg_date":"Tue, 2 Jun 2020 19:24:16 +0900","msg_from":"Fujii Masao <masao.fujii@oss.nttdata.com>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"At Tue, 2 Jun 2020 19:24:16 +0900, Fujii Masao <masao.fujii@oss.nttdata.com> wrote in \n> Thanks! I pushed the patch.\n\nThanks to all!\n\nregards.\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n","msg_date":"Wed, 03 Jun 2020 09:18:19 +0900 (JST)","msg_from":"Kyotaro Horiguchi <horikyota.ntt@gmail.com>","msg_from_op":true,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Wed, Jun 03, 2020 at 09:18:19AM +0900, Kyotaro Horiguchi wrote:\n> Thanks to all!\n\nIndeed, this was incorrect. And you may not have noticed, but we have\na second instance of that in LogicalIncreaseRestartDecodingForSlot()\nthat goes down to 9.4 and b89e151. I used a dirty-still-efficient\nhack to detect that, and that's the only instance I have spotted.\n\nI am not sure if that's worth worrying a back-patch, but we should\nreally address that at least on HEAD. Attached is an extra patch to\nclose the loop.\n--\nMichael","msg_date":"Wed, 3 Jun 2020 12:05:10 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Wed, Jun 3, 2020 at 8:35 AM Michael Paquier <michael@paquier.xyz> wrote:\n>\n> On Wed, Jun 03, 2020 at 09:18:19AM +0900, Kyotaro Horiguchi wrote:\n> > Thanks to all!\n>\n> Indeed, this was incorrect.\n>\n\nDo you mean to say correct?\n\n-- \nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\n\n","msg_date":"Wed, 3 Jun 2020 08:52:08 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Michael Paquier <michael@paquier.xyz> writes:\n> Indeed, this was incorrect. And you may not have noticed, but we have\n> a second instance of that in LogicalIncreaseRestartDecodingForSlot()\n> that goes down to 9.4 and b89e151. I used a dirty-still-efficient\n> hack to detect that, and that's the only instance I have spotted.\n\nUgh, that is just horrid. I experimented with the attached patch\nbut it did not find any other problems. Still, that only proves\nsomething about code paths that are taken during check-world, and\nwe know that our test coverage is not very good :-(.\n\nShould we think about adding automated detection of this type of\nmistake? I don't like the attached as-is because of the #include\nfootprint expansion, but maybe we can find a better way.\n\n> I am not sure if that's worth worrying a back-patch, but we should\n> really address that at least on HEAD.\n\nIt's actually worse in the back branches, because elog() did not have\na good short-circuit path like ereport() does. +1 for back-patch.\n\n\t\t\tregards, tom lane","msg_date":"Wed, 03 Jun 2020 00:36:34 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Wed, Jun 03, 2020 at 08:52:08AM +0530, Amit Kapila wrote:\n> Do you mean to say correct?\n\nNope, I really meant that the code before caa3c42 is incorrect, and I\nam glad that it got fixed. Sorry if that sounded confusing.\n--\nMichael","msg_date":"Wed, 3 Jun 2020 13:41:21 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Wed, Jun 03, 2020 at 12:36:34AM -0400, Tom Lane wrote:\n> Ugh, that is just horrid. I experimented with the attached patch\n> but it did not find any other problems.\n\nOh. I can see the same \"ifndef FRONTEND\" logic all around the place\nas I did on my local branch :)\n\n> Still, that only proves something about code paths that are taken\n> during check-world, and we know that our test coverage is not very\n> good :-(.\n\nYeah. Not perfect, still we are getting better at it with the years.\nI am fine to take care of a backpatch, but I'll wait first a bit to\nsee if others have any comments.\n--\nMichael","msg_date":"Wed, 3 Jun 2020 13:48:59 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"I wrote:\n> Ugh, that is just horrid. I experimented with the attached patch\n> but it did not find any other problems.\n\nIt occurred to me to add NotHoldingSpinLock() into palloc and\nfriends, and look what I found in copy_replication_slot:\n\n SpinLockAcquire(&s->mutex);\n src_islogical = SlotIsLogical(s);\n src_restart_lsn = s->data.restart_lsn;\n temporary = s->data.persistency == RS_TEMPORARY;\n plugin = logical_slot ? pstrdup(NameStr(s->data.plugin)) : NULL;\n SpinLockRelease(&s->mutex);\n\nThat is not gonna do, of course. And there is another pstrdup\ninside another spinlock section a bit further down in the same\nfunction. Also, pg_get_replication_slots has a couple of\nnamecpy() calls inside a spinlock, which is maybe less dangerous\nthan palloc() but it's still willful disregard of the project coding\nrule about \"only straight-line code inside a spinlock\".\n\nI'm inclined to think that memcpy'ing the ReplicationSlot struct\ninto a local variable might be the best way, replacing all the\npiecemeal copying these stanzas are doing right now. memcpy() of\na fixed amount of data isn't quite straight-line code perhaps,\nbut it has a well-defined runtime and zero chance of throwing an\nerror, which are the two properties we should be most urgently\nconcerned about.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Wed, 03 Jun 2020 01:27:51 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Wed, Jun 03, 2020 at 01:27:51AM -0400, Tom Lane wrote:\n> I'm inclined to think that memcpy'ing the ReplicationSlot struct\n> into a local variable might be the best way, replacing all the\n> piecemeal copying these stanzas are doing right now. memcpy() of\n> a fixed amount of data isn't quite straight-line code perhaps,\n> but it has a well-defined runtime and zero chance of throwing an\n> error, which are the two properties we should be most urgently\n> concerned about.\n\n+1. And I guess that you are already on that? ;)\n--\nMichael","msg_date":"Wed, 3 Jun 2020 14:47:48 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Michael Paquier <michael@paquier.xyz> writes:\n> On Wed, Jun 03, 2020 at 01:27:51AM -0400, Tom Lane wrote:\n>> I'm inclined to think that memcpy'ing the ReplicationSlot struct\n>> into a local variable might be the best way, replacing all the\n>> piecemeal copying these stanzas are doing right now.\n\n> +1. And I guess that you are already on that? ;)\n\nI'll work on it tomorrow ... it's getting late here.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Wed, 03 Jun 2020 01:54:23 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"... and InvalidateObsoleteReplicationSlots(), too.\n\nI am detecting a pattern here.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Wed, 03 Jun 2020 02:00:53 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"At Wed, 03 Jun 2020 02:00:53 -0400, Tom Lane <tgl@sss.pgh.pa.us> wrote in \n> ... and InvalidateObsoleteReplicationSlots(), too.\n> \n> I am detecting a pattern here.\n\nI looked through 224 locations where SpinLockAcquire and found some.\n\nLogicalIncreaseRestartDecodingForSlot is spotted by Michael.\npg_get_replication_slots has some namecpy as Tom pointed out.\ncopy_replication_slot has pstrdup as Tom pointed out.\nInvalidateObsoleteReplicationSlots has pstrdup as Tom poineed out.\n\nI found another instance of pstrdup, but found some string copy functions.\n\nCreateInitDecodingContext has StrNCpy (up to NAMEDATALEN = 64 bytes).\nRequestXLogStreaming has strlcpy (up to MAXCONNINFO = 1024 bytes).\nSaveSlotToPath has memcpy on ReplicationSlotOnDisk (176 bytes).\nWalReceiverMain has strlcpy(MAXCONINFO + NAMEDATALEN) and memset of MAXCONNINFO.\npg_stat_get_wal_receiver has strlcpy (NAMEDATALEN + NI_MAXHOST(1025) + MAXCONNINFO).\n\nregards.\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n","msg_date":"Wed, 03 Jun 2020 15:18:19 +0900 (JST)","msg_from":"Kyotaro Horiguchi <horikyota.ntt@gmail.com>","msg_from_op":true,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Kyotaro Horiguchi <horikyota.ntt@gmail.com> writes:\n> I looked through 224 locations where SpinLockAcquire and found some.\n\nYeah, I made a similar scan and arrived at about the same conclusions.\nI think that the memcpy and strlcpy calls are fine; at least, we've got\nto transport data somehow and it's not apparent why those aren't OK ways\nto do it. The one use of StrNCpy is annoying from a cosmetic standpoint\n(mainly because it's Not Like Anywhere Else) but I'm not sure it's worth\nchanging.\n\nThe condition-variable code has a boatload of spinlocked calls of the\nproclist functions in proclist.h. All of those are straight-line code\nso they're okay performance wise, but I wonder if we shouldn't add a\ncomment to that header pointing out that its functions must not throw\nerrors.\n\nThe only other thing I remain concerned about is some instances of atomic\noperations inside spinlocks, which I started a separate thread about [1].\n\n\t\t\tregards, tom lane\n\n[1] https://www.postgresql.org/message-id/1141819.1591208385%40sss.pgh.pa.us\n\n\n","msg_date":"Wed, 03 Jun 2020 14:35:29 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Wed, Jun 03, 2020 at 12:36:34AM -0400, Tom Lane wrote:\n> Should we think about adding automated detection of this type of\n> mistake? I don't like the attached as-is because of the #include\n> footprint expansion, but maybe we can find a better way.\n\nI think that this one first boils down to the FRONTEND dependency in\nthose headers. Or in short, spin.h may get loaded by the frontend but\nwe have a backend-only API, no?\n\n> It's actually worse in the back branches, because elog() did not have\n> a good short-circuit path like ereport() does. +1 for back-patch.\n\nThanks, got that fixed down to 9.5.\n--\nMichael","msg_date":"Thu, 4 Jun 2020 10:43:56 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Michael Paquier <michael@paquier.xyz> writes:\n> On Wed, Jun 03, 2020 at 12:36:34AM -0400, Tom Lane wrote:\n>> Should we think about adding automated detection of this type of\n>> mistake? I don't like the attached as-is because of the #include\n>> footprint expansion, but maybe we can find a better way.\n\n> I think that this one first boils down to the FRONTEND dependency in\n> those headers. Or in short, spin.h may get loaded by the frontend but\n> we have a backend-only API, no?\n\nI think the #include bloat comes from wanting to declare the global\nstate variable as \"slock_t *\". We could give up on that and write\nsomething like this in a central place like c.h:\n\n#if defined(USE_ASSERT_CHECKING) && !defined(FRONTEND)\nextern void *held_spinlock;\n#define NotHoldingSpinLock() Assert(held_spinlock == NULL)\n#else\n#define NotHoldingSpinLock() ((void) 0)\n#endif\n\nThen throwing NotHoldingSpinLock() into relevant places costs\nnothing new include-wise.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Wed, 03 Jun 2020 21:57:33 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Wed, Jun 3, 2020 at 12:36 AM Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> Should we think about adding automated detection of this type of\n> mistake? I don't like the attached as-is because of the #include\n> footprint expansion, but maybe we can find a better way.\n\nI think it would be an excellent idea.\n\nRemoving some of these spinlocks and replacing them with LWLocks might\nalso be worth considering.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n","msg_date":"Tue, 9 Jun 2020 13:46:28 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Robert Haas <robertmhaas@gmail.com> writes:\n> Removing some of these spinlocks and replacing them with LWLocks might\n> also be worth considering.\n\nWhen I went through the existing spinlock stanzas, the only thing that\nreally made me acutely uncomfortable was the chunk in pg_stat_statement's\npgss_store(), lines 1386..1438 in HEAD. In the first place, that's\npushing the notion of \"short straight-line code\" well beyond reasonable\nbounds. Other processes could waste a fair amount of time spinning while\nthe lock holder does all this arithmetic; not to mention the risk of\nexhausting one's CPU time-slice partway through. In the second place,\na chunk of code this large could well allow people to make modifications\nwithout noticing that they're inside a spinlock, allowing future coding\nviolations to sneak in.\n\nNot sure what we want to do about it though. An LWLock per pgss entry\nprobably isn't gonna do. Perhaps we could take a cue from your old\nhack with multiplexed spinlocks, and map the pgss entries onto some\nfixed-size pool of LWLocks, figuring that the odds of false conflicts\nare small as long as the pool is bigger than MaxBackends.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Tue, 09 Jun 2020 13:59:44 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Tue, Jun 9, 2020 at 1:59 PM Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> Robert Haas <robertmhaas@gmail.com> writes:\n> > Removing some of these spinlocks and replacing them with LWLocks might\n> > also be worth considering.\n>\n> When I went through the existing spinlock stanzas, the only thing that\n> really made me acutely uncomfortable was the chunk in pg_stat_statement's\n> pgss_store(), lines 1386..1438 in HEAD. In the first place, that's\n> pushing the notion of \"short straight-line code\" well beyond reasonable\n> bounds. Other processes could waste a fair amount of time spinning while\n> the lock holder does all this arithmetic; not to mention the risk of\n> exhausting one's CPU time-slice partway through. In the second place,\n> a chunk of code this large could well allow people to make modifications\n> without noticing that they're inside a spinlock, allowing future coding\n> violations to sneak in.\n>\n> Not sure what we want to do about it though. An LWLock per pgss entry\n> probably isn't gonna do. Perhaps we could take a cue from your old\n> hack with multiplexed spinlocks, and map the pgss entries onto some\n> fixed-size pool of LWLocks, figuring that the odds of false conflicts\n> are small as long as the pool is bigger than MaxBackends.\n\nI mean, what would be wrong with having an LWLock per pgss entry? If\nyou're worried about efficiency, it's no longer the case that an\nLWLock uses a spinlock internally, so there's not the old problem of\ndoubling (plus contention) the number of atomic operations by using an\nLWLock. If you're worried about space, an LWLock is only 16 bytes, and\nthe slock_t that we'd be replacing is currently at the end of the\nstruct so presumably followed by some padding.\n\nI suspect that these days many of the places we're using spinlocks are\nbuying little of any value on the efficiency side, but making any\nhigh-contention scenarios way worse. Plus, unlike LWLocks, they're not\ninstrumented with wait events, so you can't even find out that you've\ngot contention there without breaking out 'perf', not exactly a great\nthing to have to do in a production environments.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n","msg_date":"Tue, 9 Jun 2020 15:20:08 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Robert Haas <robertmhaas@gmail.com> writes:\n> On Tue, Jun 9, 2020 at 1:59 PM Tom Lane <tgl@sss.pgh.pa.us> wrote:\n>> When I went through the existing spinlock stanzas, the only thing that\n>> really made me acutely uncomfortable was the chunk in pg_stat_statement's\n>> pgss_store(), lines 1386..1438 in HEAD.\n\n> I mean, what would be wrong with having an LWLock per pgss entry?\n\nHmm, maybe nothing. I'm accustomed to thinking of them as being\nsignificantly more expensive than spinlocks, but maybe we've narrowed\nthe gap enough that that's not such a problem.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Tue, 09 Jun 2020 19:24:15 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Hi,\n\nOn 2020-06-09 19:24:15 -0400, Tom Lane wrote:\n> Robert Haas <robertmhaas@gmail.com> writes:\n> > On Tue, Jun 9, 2020 at 1:59 PM Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> >> When I went through the existing spinlock stanzas, the only thing that\n> >> really made me acutely uncomfortable was the chunk in pg_stat_statement's\n> >> pgss_store(), lines 1386..1438 in HEAD.\n> \n> > I mean, what would be wrong with having an LWLock per pgss entry?\n\n+1\n\n> Hmm, maybe nothing. I'm accustomed to thinking of them as being\n> significantly more expensive than spinlocks, but maybe we've narrowed\n> the gap enough that that's not such a problem.\n\nThey do add a few cycles (IIRC ~30 or so, last time I measured a\nspecific scenario) of latency to acquisition, but it's not a large\namount. The only case where acquisition is noticably slower, in my\nexperiments, is when there's \"just the right amount\" of\ncontention. There spinning instead of entering the kernel can be good.\n\nI've mused about adding a small amount of spinning to lwlock acquisition\nbefore. But so far working on reducing contention seemed the better\nroute.\n\n\nFunnily enough lwlock *release*, even when there are no waiters, has a\nsomewhat noticable performance difference on x86 (and other TSO\nplatforms) compared to spinlock release. For spinlock release we can\njust use a plain write and a compiler barrier, whereas lwlock release\nneeds to use an atomic operation.\n\nI think that's hard, but not impossible, to avoid for an userspace\nreader-writer lock.\n\n\nIt would be a nice experiment to make spinlocks a legacy wrapper around\nrwlocks. I think if we added 2-3 optimizations (optimize for\nexclusive-only locks, short amount of spinning, possibly inline\nfunctions for \"fast path\" acquisitions/release) that'd be better for\nnearly all situations. And in the situations where it's not, the loss\nwould be pretty darn small.\n\nGreetings,\n\nAndres Freund\n\n\n","msg_date":"Tue, 9 Jun 2020 16:54:15 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Hi,\n\nOn 2020-06-09 15:20:08 -0400, Robert Haas wrote:\n> If you're worried about space, an LWLock is only 16 bytes, and the\n> slock_t that we'd be replacing is currently at the end of the struct\n> so presumably followed by some padding.\n\nI don't think the size is worth of concern in this case, and I'm not\nsure there's any current case where it's really worth spending effort\nreducing size. But if there is: It seems possible to reduce the size.\n\nstruct LWLock {\n uint16 tranche; /* 0 2 */\n\n /* XXX 2 bytes hole, try to pack */\n\n pg_atomic_uint32 state; /* 4 4 */\n proclist_head waiters; /* 8 8 */\n\n /* size: 16, cachelines: 1, members: 3 */\n /* sum members: 14, holes: 1, sum holes: 2 */\n /* last cacheline: 16 bytes */\n};\n\nFirst, we could remove the tranche from the lwlock, and instead perform\nmore work when we need to know it. Which is only when we're going to\nsleep, so it'd be ok if it's not that much work. Perhaps we could even\ndefer determining the tranche to the the *read* side of the wait event\n(presumably that'd require making the pgstat side a bit more\ncomplicated).\n\nSecond, it seems like it should be doable to reduce the size of the\nwaiters list. We e.g. could have a separate 'array of wait lists' array\nin shared memory, which gets assigned to an lwlock whenever a backend\nwants to wait for an lwlock. The number of processes waiting for lwlocks\nis clearly limited by MAX_BACKENDS / 2^18-1 backends waiting, so one 4\nbyte integer pointing to a wait list obviously would suffice.\n\nBut again, I'm not sure the current size a real problem anywhere.\n\nGreetings,\n\nAndres Freund\n\n\n","msg_date":"Tue, 9 Jun 2020 17:12:54 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"On Tue, Jun 9, 2020 at 8:12 PM Andres Freund <andres@anarazel.de> wrote:\n> I don't think the size is worth of concern in this case, and I'm not\n> sure there's any current case where it's really worth spending effort\n> reducing size. But if there is: It seems possible to reduce the size.\n\nYeah, I don't think it's very important.\n\n> First, we could remove the tranche from the lwlock, and instead perform\n> more work when we need to know it. Which is only when we're going to\n> sleep, so it'd be ok if it's not that much work. Perhaps we could even\n> defer determining the tranche to the the *read* side of the wait event\n> (presumably that'd require making the pgstat side a bit more\n> complicated).\n>\n> Second, it seems like it should be doable to reduce the size of the\n> waiters list. We e.g. could have a separate 'array of wait lists' array\n> in shared memory, which gets assigned to an lwlock whenever a backend\n> wants to wait for an lwlock. The number of processes waiting for lwlocks\n> is clearly limited by MAX_BACKENDS / 2^18-1 backends waiting, so one 4\n> byte integer pointing to a wait list obviously would suffice.\n>\n> But again, I'm not sure the current size a real problem anywhere.\n\nHonestly, both of these sound more painful than it's worth. We're not\nlikely to have enough LWLocks that using 16 bytes for each one rather\nthan 8 is a major problem. With regard to the first of these ideas,\nbear in mind that the LWLock might be in a DSM segment that the reader\ndoesn't have mapped.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n","msg_date":"Wed, 10 Jun 2020 10:45:37 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Hi,\n\nOn 2020-06-03 00:36:34 -0400, Tom Lane wrote:\n> Should we think about adding automated detection of this type of\n> mistake? I don't like the attached as-is because of the #include\n> footprint expansion, but maybe we can find a better way.\n\nI experimented with making the compiler warn about about some of these\nkinds of mistakes without needing full test coverage:\n\nI was able to get clang to warn about things like using palloc in signal\nhandlers, or using palloc while holding a spinlock. Which would be\ngreat, except that it doesn't warn when there's an un-annotated\nintermediary function. Even when that function is in the same TU.\n\nHere's my attempt: https://godbolt.org/z/xfa6Es\n\nIt does detect things like\n spinlock_lock();\n example_alloc(17);\n spinlock_unlock();\n\n<source>:49:2: warning: cannot call function 'example_alloc' while mutex 'holding_spinlock' is held [-Wthread-safety-analysis]\n\n example_alloc(17);\n\n ^\n\nwhich isn't too bad.\n\nDoes anybody think this would be useful even if it doesn't detect the\nmore complicated cases?\n\nGreetings,\n\nAndres Freund\n\n\n","msg_date":"Tue, 16 Jun 2020 16:31:05 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Andres Freund <andres@anarazel.de> writes:\n> I experimented with making the compiler warn about about some of these\n> kinds of mistakes without needing full test coverage:\n\n> I was able to get clang to warn about things like using palloc in signal\n> handlers, or using palloc while holding a spinlock. Which would be\n> great, except that it doesn't warn when there's an un-annotated\n> intermediary function. Even when that function is in the same TU.\n\nHm. Couldn't we make \"calling an un-annotated function\" be a violation\nin itself? Certainly in the case of spinlocks, what we want is pretty\nnearly a total ban on calling anything at all. I wouldn't cry too hard\nabout having a similar policy for signal handlers. (The postmaster's\nhandlers would have to be an exception for now.)\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Tue, 16 Jun 2020 19:46:29 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."},{"msg_contents":"Hi,\n\nOn 2020-06-16 19:46:29 -0400, Tom Lane wrote:\n> Andres Freund <andres@anarazel.de> writes:\n> > I experimented with making the compiler warn about about some of these\n> > kinds of mistakes without needing full test coverage:\n>\n> > I was able to get clang to warn about things like using palloc in signal\n> > handlers, or using palloc while holding a spinlock. Which would be\n> > great, except that it doesn't warn when there's an un-annotated\n> > intermediary function. Even when that function is in the same TU.\n>\n> Hm. Couldn't we make \"calling an un-annotated function\" be a violation\n> in itself?\n\nI don't see a way to do that with these annotations, unfortunately.\n\nhttps://clang.llvm.org/docs/ThreadSafetyAnalysis.html\nhttps://clang.llvm.org/docs/AttributeReference.html#acquire-capability-acquire-shared-capability\n\n\n> Certainly in the case of spinlocks, what we want is pretty\n> nearly a total ban on calling anything at all. I wouldn't cry too hard\n> about having a similar policy for signal handlers.\n\nIt'd be interesting to try and see how invasive that'd be, if it were\npossible to enforce. But...\n\nGreetings,\n\nAndres Freund\n\n\n","msg_date":"Tue, 16 Jun 2020 17:27:36 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: elog(DEBUG2 in SpinLocked section."}],"string":"[\n {\n \"msg_contents\": \"Hello.\\n\\nI noticed that UpdateSpillStats calls \\\"elog(DEBUG2\\\" within\\nSpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\\nin the first place the rb cannot be modified during the function is\\nrunning.\\n\\nIt should be out of the lock section.\\n\\nregards.\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\",\n \"msg_date\": \"Tue, 02 Jun 2020 16:15:18 +0900 (JST)\",\n \"msg_from\": \"Kyotaro Horiguchi <horikyota.ntt@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 2020/06/02 16:15, Kyotaro Horiguchi wrote:\\n> Hello.\\n> \\n> I noticed that UpdateSpillStats calls \\\"elog(DEBUG2\\\" within\\n> SpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\\n> in the first place the rb cannot be modified during the function is\\n> running.\\n> \\n> It should be out of the lock section.\\n\\nThanks for the patch! It looks good to me.\\n\\nRegards,\\n\\n-- \\nFujii Masao\\nAdvanced Computing Technology Center\\nResearch and Development Headquarters\\nNTT DATA CORPORATION\\n\\n\\n\",\n \"msg_date\": \"Tue, 2 Jun 2020 17:35:48 +0900\",\n \"msg_from\": \"Fujii Masao <masao.fujii@oss.nttdata.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Tue, Jun 2, 2020 at 2:05 PM Fujii Masao <masao.fujii@oss.nttdata.com> wrote:\\n>\\n> On 2020/06/02 16:15, Kyotaro Horiguchi wrote:\\n> > Hello.\\n> >\\n> > I noticed that UpdateSpillStats calls \\\"elog(DEBUG2\\\" within\\n> > SpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\\n> > in the first place the rb cannot be modified during the function is\\n> > running.\\n> >\\n> > It should be out of the lock section.\\n\\nRight.\\n\\n>\\n> Thanks for the patch! It looks good to me.\\n>\\n\\nThe patch looks good to me as well. I will push this unless Fujii-San\\nwants to do it.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\n\\n\",\n \"msg_date\": \"Tue, 2 Jun 2020 14:12:37 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 2020/06/02 17:42, Amit Kapila wrote:\\n> On Tue, Jun 2, 2020 at 2:05 PM Fujii Masao <masao.fujii@oss.nttdata.com> wrote:\\n>>\\n>> On 2020/06/02 16:15, Kyotaro Horiguchi wrote:\\n>>> Hello.\\n>>>\\n>>> I noticed that UpdateSpillStats calls \\\"elog(DEBUG2\\\" within\\n>>> SpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\\n>>> in the first place the rb cannot be modified during the function is\\n>>> running.\\n>>>\\n>>> It should be out of the lock section.\\n> \\n> Right.\\n> \\n>>\\n>> Thanks for the patch! It looks good to me.\\n>>\\n> \\n> The patch looks good to me as well. I will push this unless Fujii-San\\n> wants to do it.\\n\\nThanks! I pushed the patch.\\n\\nRegards,\\n\\n-- \\nFujii Masao\\nAdvanced Computing Technology Center\\nResearch and Development Headquarters\\nNTT DATA CORPORATION\\n\\n\\n\",\n \"msg_date\": \"Tue, 2 Jun 2020 19:24:16 +0900\",\n \"msg_from\": \"Fujii Masao <masao.fujii@oss.nttdata.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"At Tue, 2 Jun 2020 19:24:16 +0900, Fujii Masao <masao.fujii@oss.nttdata.com> wrote in \\n> Thanks! I pushed the patch.\\n\\nThanks to all!\\n\\nregards.\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\",\n \"msg_date\": \"Wed, 03 Jun 2020 09:18:19 +0900 (JST)\",\n \"msg_from\": \"Kyotaro Horiguchi <horikyota.ntt@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 03, 2020 at 09:18:19AM +0900, Kyotaro Horiguchi wrote:\\n> Thanks to all!\\n\\nIndeed, this was incorrect. And you may not have noticed, but we have\\na second instance of that in LogicalIncreaseRestartDecodingForSlot()\\nthat goes down to 9.4 and b89e151. I used a dirty-still-efficient\\nhack to detect that, and that's the only instance I have spotted.\\n\\nI am not sure if that's worth worrying a back-patch, but we should\\nreally address that at least on HEAD. Attached is an extra patch to\\nclose the loop.\\n--\\nMichael\",\n \"msg_date\": \"Wed, 3 Jun 2020 12:05:10 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 3, 2020 at 8:35 AM Michael Paquier <michael@paquier.xyz> wrote:\\n>\\n> On Wed, Jun 03, 2020 at 09:18:19AM +0900, Kyotaro Horiguchi wrote:\\n> > Thanks to all!\\n>\\n> Indeed, this was incorrect.\\n>\\n\\nDo you mean to say correct?\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\n\\n\",\n \"msg_date\": \"Wed, 3 Jun 2020 08:52:08 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael@paquier.xyz> writes:\\n> Indeed, this was incorrect. And you may not have noticed, but we have\\n> a second instance of that in LogicalIncreaseRestartDecodingForSlot()\\n> that goes down to 9.4 and b89e151. I used a dirty-still-efficient\\n> hack to detect that, and that's the only instance I have spotted.\\n\\nUgh, that is just horrid. I experimented with the attached patch\\nbut it did not find any other problems. Still, that only proves\\nsomething about code paths that are taken during check-world, and\\nwe know that our test coverage is not very good :-(.\\n\\nShould we think about adding automated detection of this type of\\nmistake? I don't like the attached as-is because of the #include\\nfootprint expansion, but maybe we can find a better way.\\n\\n> I am not sure if that's worth worrying a back-patch, but we should\\n> really address that at least on HEAD.\\n\\nIt's actually worse in the back branches, because elog() did not have\\na good short-circuit path like ereport() does. +1 for back-patch.\\n\\n\\t\\t\\tregards, tom lane\",\n \"msg_date\": \"Wed, 03 Jun 2020 00:36:34 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 03, 2020 at 08:52:08AM +0530, Amit Kapila wrote:\\n> Do you mean to say correct?\\n\\nNope, I really meant that the code before caa3c42 is incorrect, and I\\nam glad that it got fixed. Sorry if that sounded confusing.\\n--\\nMichael\",\n \"msg_date\": \"Wed, 3 Jun 2020 13:41:21 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 03, 2020 at 12:36:34AM -0400, Tom Lane wrote:\\n> Ugh, that is just horrid. I experimented with the attached patch\\n> but it did not find any other problems.\\n\\nOh. I can see the same \\\"ifndef FRONTEND\\\" logic all around the place\\nas I did on my local branch :)\\n\\n> Still, that only proves something about code paths that are taken\\n> during check-world, and we know that our test coverage is not very\\n> good :-(.\\n\\nYeah. Not perfect, still we are getting better at it with the years.\\nI am fine to take care of a backpatch, but I'll wait first a bit to\\nsee if others have any comments.\\n--\\nMichael\",\n \"msg_date\": \"Wed, 3 Jun 2020 13:48:59 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"I wrote:\\n> Ugh, that is just horrid. I experimented with the attached patch\\n> but it did not find any other problems.\\n\\nIt occurred to me to add NotHoldingSpinLock() into palloc and\\nfriends, and look what I found in copy_replication_slot:\\n\\n SpinLockAcquire(&s->mutex);\\n src_islogical = SlotIsLogical(s);\\n src_restart_lsn = s->data.restart_lsn;\\n temporary = s->data.persistency == RS_TEMPORARY;\\n plugin = logical_slot ? pstrdup(NameStr(s->data.plugin)) : NULL;\\n SpinLockRelease(&s->mutex);\\n\\nThat is not gonna do, of course. And there is another pstrdup\\ninside another spinlock section a bit further down in the same\\nfunction. Also, pg_get_replication_slots has a couple of\\nnamecpy() calls inside a spinlock, which is maybe less dangerous\\nthan palloc() but it's still willful disregard of the project coding\\nrule about \\\"only straight-line code inside a spinlock\\\".\\n\\nI'm inclined to think that memcpy'ing the ReplicationSlot struct\\ninto a local variable might be the best way, replacing all the\\npiecemeal copying these stanzas are doing right now. memcpy() of\\na fixed amount of data isn't quite straight-line code perhaps,\\nbut it has a well-defined runtime and zero chance of throwing an\\nerror, which are the two properties we should be most urgently\\nconcerned about.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Wed, 03 Jun 2020 01:27:51 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 03, 2020 at 01:27:51AM -0400, Tom Lane wrote:\\n> I'm inclined to think that memcpy'ing the ReplicationSlot struct\\n> into a local variable might be the best way, replacing all the\\n> piecemeal copying these stanzas are doing right now. memcpy() of\\n> a fixed amount of data isn't quite straight-line code perhaps,\\n> but it has a well-defined runtime and zero chance of throwing an\\n> error, which are the two properties we should be most urgently\\n> concerned about.\\n\\n+1. And I guess that you are already on that? ;)\\n--\\nMichael\",\n \"msg_date\": \"Wed, 3 Jun 2020 14:47:48 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael@paquier.xyz> writes:\\n> On Wed, Jun 03, 2020 at 01:27:51AM -0400, Tom Lane wrote:\\n>> I'm inclined to think that memcpy'ing the ReplicationSlot struct\\n>> into a local variable might be the best way, replacing all the\\n>> piecemeal copying these stanzas are doing right now.\\n\\n> +1. And I guess that you are already on that? ;)\\n\\nI'll work on it tomorrow ... it's getting late here.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Wed, 03 Jun 2020 01:54:23 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"... and InvalidateObsoleteReplicationSlots(), too.\\n\\nI am detecting a pattern here.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Wed, 03 Jun 2020 02:00:53 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"At Wed, 03 Jun 2020 02:00:53 -0400, Tom Lane <tgl@sss.pgh.pa.us> wrote in \\n> ... and InvalidateObsoleteReplicationSlots(), too.\\n> \\n> I am detecting a pattern here.\\n\\nI looked through 224 locations where SpinLockAcquire and found some.\\n\\nLogicalIncreaseRestartDecodingForSlot is spotted by Michael.\\npg_get_replication_slots has some namecpy as Tom pointed out.\\ncopy_replication_slot has pstrdup as Tom pointed out.\\nInvalidateObsoleteReplicationSlots has pstrdup as Tom poineed out.\\n\\nI found another instance of pstrdup, but found some string copy functions.\\n\\nCreateInitDecodingContext has StrNCpy (up to NAMEDATALEN = 64 bytes).\\nRequestXLogStreaming has strlcpy (up to MAXCONNINFO = 1024 bytes).\\nSaveSlotToPath has memcpy on ReplicationSlotOnDisk (176 bytes).\\nWalReceiverMain has strlcpy(MAXCONINFO + NAMEDATALEN) and memset of MAXCONNINFO.\\npg_stat_get_wal_receiver has strlcpy (NAMEDATALEN + NI_MAXHOST(1025) + MAXCONNINFO).\\n\\nregards.\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\",\n \"msg_date\": \"Wed, 03 Jun 2020 15:18:19 +0900 (JST)\",\n \"msg_from\": \"Kyotaro Horiguchi <horikyota.ntt@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Kyotaro Horiguchi <horikyota.ntt@gmail.com> writes:\\n> I looked through 224 locations where SpinLockAcquire and found some.\\n\\nYeah, I made a similar scan and arrived at about the same conclusions.\\nI think that the memcpy and strlcpy calls are fine; at least, we've got\\nto transport data somehow and it's not apparent why those aren't OK ways\\nto do it. The one use of StrNCpy is annoying from a cosmetic standpoint\\n(mainly because it's Not Like Anywhere Else) but I'm not sure it's worth\\nchanging.\\n\\nThe condition-variable code has a boatload of spinlocked calls of the\\nproclist functions in proclist.h. All of those are straight-line code\\nso they're okay performance wise, but I wonder if we shouldn't add a\\ncomment to that header pointing out that its functions must not throw\\nerrors.\\n\\nThe only other thing I remain concerned about is some instances of atomic\\noperations inside spinlocks, which I started a separate thread about [1].\\n\\n\\t\\t\\tregards, tom lane\\n\\n[1] https://www.postgresql.org/message-id/1141819.1591208385%40sss.pgh.pa.us\\n\\n\\n\",\n \"msg_date\": \"Wed, 03 Jun 2020 14:35:29 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 03, 2020 at 12:36:34AM -0400, Tom Lane wrote:\\n> Should we think about adding automated detection of this type of\\n> mistake? I don't like the attached as-is because of the #include\\n> footprint expansion, but maybe we can find a better way.\\n\\nI think that this one first boils down to the FRONTEND dependency in\\nthose headers. Or in short, spin.h may get loaded by the frontend but\\nwe have a backend-only API, no?\\n\\n> It's actually worse in the back branches, because elog() did not have\\n> a good short-circuit path like ereport() does. +1 for back-patch.\\n\\nThanks, got that fixed down to 9.5.\\n--\\nMichael\",\n \"msg_date\": \"Thu, 4 Jun 2020 10:43:56 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael@paquier.xyz> writes:\\n> On Wed, Jun 03, 2020 at 12:36:34AM -0400, Tom Lane wrote:\\n>> Should we think about adding automated detection of this type of\\n>> mistake? I don't like the attached as-is because of the #include\\n>> footprint expansion, but maybe we can find a better way.\\n\\n> I think that this one first boils down to the FRONTEND dependency in\\n> those headers. Or in short, spin.h may get loaded by the frontend but\\n> we have a backend-only API, no?\\n\\nI think the #include bloat comes from wanting to declare the global\\nstate variable as \\\"slock_t *\\\". We could give up on that and write\\nsomething like this in a central place like c.h:\\n\\n#if defined(USE_ASSERT_CHECKING) && !defined(FRONTEND)\\nextern void *held_spinlock;\\n#define NotHoldingSpinLock() Assert(held_spinlock == NULL)\\n#else\\n#define NotHoldingSpinLock() ((void) 0)\\n#endif\\n\\nThen throwing NotHoldingSpinLock() into relevant places costs\\nnothing new include-wise.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Wed, 03 Jun 2020 21:57:33 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 3, 2020 at 12:36 AM Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Should we think about adding automated detection of this type of\\n> mistake? I don't like the attached as-is because of the #include\\n> footprint expansion, but maybe we can find a better way.\\n\\nI think it would be an excellent idea.\\n\\nRemoving some of these spinlocks and replacing them with LWLocks might\\nalso be worth considering.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n\",\n \"msg_date\": \"Tue, 9 Jun 2020 13:46:28 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Robert Haas <robertmhaas@gmail.com> writes:\\n> Removing some of these spinlocks and replacing them with LWLocks might\\n> also be worth considering.\\n\\nWhen I went through the existing spinlock stanzas, the only thing that\\nreally made me acutely uncomfortable was the chunk in pg_stat_statement's\\npgss_store(), lines 1386..1438 in HEAD. In the first place, that's\\npushing the notion of \\\"short straight-line code\\\" well beyond reasonable\\nbounds. Other processes could waste a fair amount of time spinning while\\nthe lock holder does all this arithmetic; not to mention the risk of\\nexhausting one's CPU time-slice partway through. In the second place,\\na chunk of code this large could well allow people to make modifications\\nwithout noticing that they're inside a spinlock, allowing future coding\\nviolations to sneak in.\\n\\nNot sure what we want to do about it though. An LWLock per pgss entry\\nprobably isn't gonna do. Perhaps we could take a cue from your old\\nhack with multiplexed spinlocks, and map the pgss entries onto some\\nfixed-size pool of LWLocks, figuring that the odds of false conflicts\\nare small as long as the pool is bigger than MaxBackends.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Tue, 09 Jun 2020 13:59:44 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Tue, Jun 9, 2020 at 1:59 PM Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Robert Haas <robertmhaas@gmail.com> writes:\\n> > Removing some of these spinlocks and replacing them with LWLocks might\\n> > also be worth considering.\\n>\\n> When I went through the existing spinlock stanzas, the only thing that\\n> really made me acutely uncomfortable was the chunk in pg_stat_statement's\\n> pgss_store(), lines 1386..1438 in HEAD. In the first place, that's\\n> pushing the notion of \\\"short straight-line code\\\" well beyond reasonable\\n> bounds. Other processes could waste a fair amount of time spinning while\\n> the lock holder does all this arithmetic; not to mention the risk of\\n> exhausting one's CPU time-slice partway through. In the second place,\\n> a chunk of code this large could well allow people to make modifications\\n> without noticing that they're inside a spinlock, allowing future coding\\n> violations to sneak in.\\n>\\n> Not sure what we want to do about it though. An LWLock per pgss entry\\n> probably isn't gonna do. Perhaps we could take a cue from your old\\n> hack with multiplexed spinlocks, and map the pgss entries onto some\\n> fixed-size pool of LWLocks, figuring that the odds of false conflicts\\n> are small as long as the pool is bigger than MaxBackends.\\n\\nI mean, what would be wrong with having an LWLock per pgss entry? If\\nyou're worried about efficiency, it's no longer the case that an\\nLWLock uses a spinlock internally, so there's not the old problem of\\ndoubling (plus contention) the number of atomic operations by using an\\nLWLock. If you're worried about space, an LWLock is only 16 bytes, and\\nthe slock_t that we'd be replacing is currently at the end of the\\nstruct so presumably followed by some padding.\\n\\nI suspect that these days many of the places we're using spinlocks are\\nbuying little of any value on the efficiency side, but making any\\nhigh-contention scenarios way worse. Plus, unlike LWLocks, they're not\\ninstrumented with wait events, so you can't even find out that you've\\ngot contention there without breaking out 'perf', not exactly a great\\nthing to have to do in a production environments.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n\",\n \"msg_date\": \"Tue, 9 Jun 2020 15:20:08 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Robert Haas <robertmhaas@gmail.com> writes:\\n> On Tue, Jun 9, 2020 at 1:59 PM Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>> When I went through the existing spinlock stanzas, the only thing that\\n>> really made me acutely uncomfortable was the chunk in pg_stat_statement's\\n>> pgss_store(), lines 1386..1438 in HEAD.\\n\\n> I mean, what would be wrong with having an LWLock per pgss entry?\\n\\nHmm, maybe nothing. I'm accustomed to thinking of them as being\\nsignificantly more expensive than spinlocks, but maybe we've narrowed\\nthe gap enough that that's not such a problem.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Tue, 09 Jun 2020 19:24:15 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020-06-09 19:24:15 -0400, Tom Lane wrote:\\n> Robert Haas <robertmhaas@gmail.com> writes:\\n> > On Tue, Jun 9, 2020 at 1:59 PM Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> >> When I went through the existing spinlock stanzas, the only thing that\\n> >> really made me acutely uncomfortable was the chunk in pg_stat_statement's\\n> >> pgss_store(), lines 1386..1438 in HEAD.\\n> \\n> > I mean, what would be wrong with having an LWLock per pgss entry?\\n\\n+1\\n\\n> Hmm, maybe nothing. I'm accustomed to thinking of them as being\\n> significantly more expensive than spinlocks, but maybe we've narrowed\\n> the gap enough that that's not such a problem.\\n\\nThey do add a few cycles (IIRC ~30 or so, last time I measured a\\nspecific scenario) of latency to acquisition, but it's not a large\\namount. The only case where acquisition is noticably slower, in my\\nexperiments, is when there's \\\"just the right amount\\\" of\\ncontention. There spinning instead of entering the kernel can be good.\\n\\nI've mused about adding a small amount of spinning to lwlock acquisition\\nbefore. But so far working on reducing contention seemed the better\\nroute.\\n\\n\\nFunnily enough lwlock *release*, even when there are no waiters, has a\\nsomewhat noticable performance difference on x86 (and other TSO\\nplatforms) compared to spinlock release. For spinlock release we can\\njust use a plain write and a compiler barrier, whereas lwlock release\\nneeds to use an atomic operation.\\n\\nI think that's hard, but not impossible, to avoid for an userspace\\nreader-writer lock.\\n\\n\\nIt would be a nice experiment to make spinlocks a legacy wrapper around\\nrwlocks. I think if we added 2-3 optimizations (optimize for\\nexclusive-only locks, short amount of spinning, possibly inline\\nfunctions for \\\"fast path\\\" acquisitions/release) that'd be better for\\nnearly all situations. And in the situations where it's not, the loss\\nwould be pretty darn small.\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n\",\n \"msg_date\": \"Tue, 9 Jun 2020 16:54:15 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020-06-09 15:20:08 -0400, Robert Haas wrote:\\n> If you're worried about space, an LWLock is only 16 bytes, and the\\n> slock_t that we'd be replacing is currently at the end of the struct\\n> so presumably followed by some padding.\\n\\nI don't think the size is worth of concern in this case, and I'm not\\nsure there's any current case where it's really worth spending effort\\nreducing size. But if there is: It seems possible to reduce the size.\\n\\nstruct LWLock {\\n uint16 tranche; /* 0 2 */\\n\\n /* XXX 2 bytes hole, try to pack */\\n\\n pg_atomic_uint32 state; /* 4 4 */\\n proclist_head waiters; /* 8 8 */\\n\\n /* size: 16, cachelines: 1, members: 3 */\\n /* sum members: 14, holes: 1, sum holes: 2 */\\n /* last cacheline: 16 bytes */\\n};\\n\\nFirst, we could remove the tranche from the lwlock, and instead perform\\nmore work when we need to know it. Which is only when we're going to\\nsleep, so it'd be ok if it's not that much work. Perhaps we could even\\ndefer determining the tranche to the the *read* side of the wait event\\n(presumably that'd require making the pgstat side a bit more\\ncomplicated).\\n\\nSecond, it seems like it should be doable to reduce the size of the\\nwaiters list. We e.g. could have a separate 'array of wait lists' array\\nin shared memory, which gets assigned to an lwlock whenever a backend\\nwants to wait for an lwlock. The number of processes waiting for lwlocks\\nis clearly limited by MAX_BACKENDS / 2^18-1 backends waiting, so one 4\\nbyte integer pointing to a wait list obviously would suffice.\\n\\nBut again, I'm not sure the current size a real problem anywhere.\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n\",\n \"msg_date\": \"Tue, 9 Jun 2020 17:12:54 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"On Tue, Jun 9, 2020 at 8:12 PM Andres Freund <andres@anarazel.de> wrote:\\n> I don't think the size is worth of concern in this case, and I'm not\\n> sure there's any current case where it's really worth spending effort\\n> reducing size. But if there is: It seems possible to reduce the size.\\n\\nYeah, I don't think it's very important.\\n\\n> First, we could remove the tranche from the lwlock, and instead perform\\n> more work when we need to know it. Which is only when we're going to\\n> sleep, so it'd be ok if it's not that much work. Perhaps we could even\\n> defer determining the tranche to the the *read* side of the wait event\\n> (presumably that'd require making the pgstat side a bit more\\n> complicated).\\n>\\n> Second, it seems like it should be doable to reduce the size of the\\n> waiters list. We e.g. could have a separate 'array of wait lists' array\\n> in shared memory, which gets assigned to an lwlock whenever a backend\\n> wants to wait for an lwlock. The number of processes waiting for lwlocks\\n> is clearly limited by MAX_BACKENDS / 2^18-1 backends waiting, so one 4\\n> byte integer pointing to a wait list obviously would suffice.\\n>\\n> But again, I'm not sure the current size a real problem anywhere.\\n\\nHonestly, both of these sound more painful than it's worth. We're not\\nlikely to have enough LWLocks that using 16 bytes for each one rather\\nthan 8 is a major problem. With regard to the first of these ideas,\\nbear in mind that the LWLock might be in a DSM segment that the reader\\ndoesn't have mapped.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n\",\n \"msg_date\": \"Wed, 10 Jun 2020 10:45:37 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020-06-03 00:36:34 -0400, Tom Lane wrote:\\n> Should we think about adding automated detection of this type of\\n> mistake? I don't like the attached as-is because of the #include\\n> footprint expansion, but maybe we can find a better way.\\n\\nI experimented with making the compiler warn about about some of these\\nkinds of mistakes without needing full test coverage:\\n\\nI was able to get clang to warn about things like using palloc in signal\\nhandlers, or using palloc while holding a spinlock. Which would be\\ngreat, except that it doesn't warn when there's an un-annotated\\nintermediary function. Even when that function is in the same TU.\\n\\nHere's my attempt: https://godbolt.org/z/xfa6Es\\n\\nIt does detect things like\\n spinlock_lock();\\n example_alloc(17);\\n spinlock_unlock();\\n\\n<source>:49:2: warning: cannot call function 'example_alloc' while mutex 'holding_spinlock' is held [-Wthread-safety-analysis]\\n\\n example_alloc(17);\\n\\n ^\\n\\nwhich isn't too bad.\\n\\nDoes anybody think this would be useful even if it doesn't detect the\\nmore complicated cases?\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n\",\n \"msg_date\": \"Tue, 16 Jun 2020 16:31:05 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Andres Freund <andres@anarazel.de> writes:\\n> I experimented with making the compiler warn about about some of these\\n> kinds of mistakes without needing full test coverage:\\n\\n> I was able to get clang to warn about things like using palloc in signal\\n> handlers, or using palloc while holding a spinlock. Which would be\\n> great, except that it doesn't warn when there's an un-annotated\\n> intermediary function. Even when that function is in the same TU.\\n\\nHm. Couldn't we make \\\"calling an un-annotated function\\\" be a violation\\nin itself? Certainly in the case of spinlocks, what we want is pretty\\nnearly a total ban on calling anything at all. I wouldn't cry too hard\\nabout having a similar policy for signal handlers. (The postmaster's\\nhandlers would have to be an exception for now.)\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Tue, 16 Jun 2020 19:46:29 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020-06-16 19:46:29 -0400, Tom Lane wrote:\\n> Andres Freund <andres@anarazel.de> writes:\\n> > I experimented with making the compiler warn about about some of these\\n> > kinds of mistakes without needing full test coverage:\\n>\\n> > I was able to get clang to warn about things like using palloc in signal\\n> > handlers, or using palloc while holding a spinlock. Which would be\\n> > great, except that it doesn't warn when there's an un-annotated\\n> > intermediary function. Even when that function is in the same TU.\\n>\\n> Hm. Couldn't we make \\\"calling an un-annotated function\\\" be a violation\\n> in itself?\\n\\nI don't see a way to do that with these annotations, unfortunately.\\n\\nhttps://clang.llvm.org/docs/ThreadSafetyAnalysis.html\\nhttps://clang.llvm.org/docs/AttributeReference.html#acquire-capability-acquire-shared-capability\\n\\n\\n> Certainly in the case of spinlocks, what we want is pretty\\n> nearly a total ban on calling anything at all. I wouldn't cry too hard\\n> about having a similar policy for signal handlers.\\n\\nIt'd be interesting to try and see how invasive that'd be, if it were\\npossible to enforce. But...\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n\",\n \"msg_date\": \"Tue, 16 Jun 2020 17:27:36 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: elog(DEBUG2 in SpinLocked section.\"\n }\n]","isConversational":false}}},{"rowIdx":50397,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi hackers,\n\n\nI've attached a patch to add blocker(s) information for LW Locks.\nThe motive behind is to be able to get some blocker(s) information (if \nany) in the context of LW Locks.\n\n_Motivation:_\n\nWe have seen some cases with heavy contention on some LW Locks (large \nnumber of backends waiting on the same LW Lock).\n\nAdding some blocker information would make the investigations easier, it \ncould help answering questions like:\n\n * how many PIDs are holding the LWLock (could be more than one in case\n of LW_SHARED)?\n * Is the blocking PID changing?\n * Is the number of blocking PIDs changing?\n * What is the blocking PID doing?\n * Is the blocking PID waiting?\n * In which mode request is the blocked PID?\n * in which mode is the blocker PID holding the lock?\n\n_Technical context and proposal:_\n\nThere is 2 points in this patch:\n\n * Add the instrumentation:\n\n * the patch adds into the LWLock struct:\n\n last_holding_pid: last pid owner of the lock\n last_mode: last holding mode of the last pid owner \nof the lock\n nholders: number of holders (could be >1 in case of \nLW_SHARED)\n\n * the patch adds into the PGPROC struct:\n\n//lwLastHoldingPid: last holder of the LW lock the PID is waiting for\n lwHolderMode; LW lock mode of last holder of the \nLW lock the PID is waiting for\n lwNbHolders: number of holders of the LW lock the \nPID is waiting for\n\n and what is necessary to update this new information.\n\n * Provide a way to display the information: the patch also adds a\n function /pg_lwlock_blocking_pid/ to display this new information.\n\n_Outcome Example:_\n\n# select * from pg_lwlock_blocking_pid(10259);\n\n requested_mode | last_holder_pid | last_holder_mode | nb_holders\n\n----------------+-----------------+------------------+------------\n\n LW_EXCLUSIVE | 10232 | LW_EXCLUSIVE | 1\n\n(1 row)\n\n \n\n # select query,pid,state,wait_event,wait_event_type,pg_lwlock_blocking_pid(pid),pg_blocking_pids(pid) from pg_stat_activity where state='active' and pid != pg_backend_pid();\n\n query | pid | state | wait_event | wait_event_type | pg_lwlock_blocking_pid | pg_blocking_pids\n\n--------------------------------+-------+--------+---------------+-----------------+-------------------------------------------+------------------\n\n insert into bdtlwa values (1); | 10232 | active | | | (,,,) | {}\n\n insert into bdtlwb values (1); | 10254 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\n\n create table bdtwt (a int); | 10256 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\n\n insert into bdtlwa values (2); | 10259 | active | BufferContent | LWLock | (LW_EXCLUSIVE,10232,LW_EXCLUSIVE,1) | {}\n\n drop table bdtlwd; | 10261 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\n\n(5 rows)\n\n\nSo, should a PID being blocked on a LWLock we could see:\n\n * in which mode request it is waiting\n * the last pid holding the lock\n * the mode of the last PID holding the lock\n * the number of PID(s) holding the lock\n\n_Remarks:_\n\nI did a few benchmarks so far and did not observe notable performance \ndegradation (can share more details if needed).\n\nI did some quick attempts to get an exhaustive list of blockers (in case \nof LW_SHARED holders), but I think that would be challenging as:\n\n * There is about 40 000 calls to LWLockInitialize and all my attempts\n to init a list here produced “ FATAL: out of shared memory” or similar.\n * One way to get rid of using a list in LWLock could be to use\n proc_list (with proclist_head in LWLock and proclist_node in\n PGPROC). This is the current implementation for the “waiters” list.\n But this would not work for the blockers as one PGPROC can hold\n multiples LW locks so it could mean having a list of about 40K\n proclist_node per PGPROC.\n * I also have concerns about possible performance impact by using such\n a huge list in this context.\n\nThose are the reasons why this patch does not provide an exhaustive list \nof blockers.\n\nWhile this patch does not provide an exhaustive list of blockers (in \ncase of LW_SHARED holders), the information it delivers could already be \nuseful to get insights during LWLock contention scenario.\n\nI will add this patch to the next commitfest. I look forward to your \nfeedback about the idea and/or implementation.\n\nRegards,\n\nBertrand","msg_date":"Tue, 2 Jun 2020 14:24:53 +0200","msg_from":"\"Drouvot, Bertrand\" <bdrouvot@amazon.com>","msg_from_op":true,"msg_subject":"Add LWLock blocker(s) information"},{"msg_contents":"Hi hackers,\n\nOn 6/2/20 2:24 PM, Drouvot, Bertrand wrote:\n>\n> Hi hackers,\n>\n>\n> I've attached a patch to add blocker(s) information for LW Locks.\n> The motive behind is to be able to get some blocker(s) information (if \n> any) in the context of LW Locks.\n>\n> _Motivation:_\n>\n> We have seen some cases with heavy contention on some LW Locks (large \n> number of backends waiting on the same LW Lock).\n>\n> Adding some blocker information would make the investigations easier, \n> it could help answering questions like:\n>\n> * how many PIDs are holding the LWLock (could be more than one in\n> case of LW_SHARED)?\n> * Is the blocking PID changing?\n> * Is the number of blocking PIDs changing?\n> * What is the blocking PID doing?\n> * Is the blocking PID waiting?\n> * In which mode request is the blocked PID?\n> * in which mode is the blocker PID holding the lock?\n>\n> _Technical context and proposal:_\n>\n> There is 2 points in this patch:\n>\n> * Add the instrumentation:\n>\n> * the patch adds into the LWLock struct:\n>\n> last_holding_pid: last pid owner of the lock\n> last_mode: last holding mode of the last pid owner \n> of the lock\n> nholders: number of holders (could be >1 in case \n> of LW_SHARED)\n>\n> * the patch adds into the PGPROC struct:\n>\n> //lwLastHoldingPid: last holder of the LW lock the PID is waiting for\n> lwHolderMode; LW lock mode of last holder of the \n> LW lock the PID is waiting for\n> lwNbHolders: number of holders of the LW lock the \n> PID is waiting for\n>\n> and what is necessary to update this new information.\n>\n> * Provide a way to display the information: the patch also adds a\n> function /pg_lwlock_blocking_pid/ to display this new information.\n>\n> _Outcome Example:_\n>\n> # select * from pg_lwlock_blocking_pid(10259);\n> requested_mode | last_holder_pid | last_holder_mode | nb_holders\n> ----------------+-----------------+------------------+------------\n> LW_EXCLUSIVE | 10232 | LW_EXCLUSIVE | 1\n> (1 row)\n> \n> # select query,pid,state,wait_event,wait_event_type,pg_lwlock_blocking_pid(pid),pg_blocking_pids(pid) from pg_stat_activity where state='active' and pid != pg_backend_pid();\n> query | pid | state | wait_event | wait_event_type | pg_lwlock_blocking_pid | pg_blocking_pids\n> --------------------------------+-------+--------+---------------+-----------------+-------------------------------------------+------------------\n> insert into bdtlwa values (1); | 10232 | active | | | (,,,) | {}\n> insert into bdtlwb values (1); | 10254 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\n> create table bdtwt (a int); | 10256 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\n> insert into bdtlwa values (2); | 10259 | active | BufferContent | LWLock | (LW_EXCLUSIVE,10232,LW_EXCLUSIVE,1) | {}\n> drop table bdtlwd; | 10261 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\n> (5 rows)\n>\n>\n> So, should a PID being blocked on a LWLock we could see:\n>\n> * in which mode request it is waiting\n> * the last pid holding the lock\n> * the mode of the last PID holding the lock\n> * the number of PID(s) holding the lock\n>\n> _Remarks:_\n>\n> I did a few benchmarks so far and did not observe notable performance \n> degradation (can share more details if needed).\n>\n> I did some quick attempts to get an exhaustive list of blockers (in \n> case of LW_SHARED holders), but I think that would be challenging as:\n>\n> * There is about 40 000 calls to LWLockInitialize and all my\n> attempts to init a list here produced “ FATAL: out of shared\n> memory” or similar.\n> * One way to get rid of using a list in LWLock could be to use\n> proc_list (with proclist_head in LWLock and proclist_node in\n> PGPROC). This is the current implementation for the “waiters”\n> list. But this would not work for the blockers as one PGPROC can\n> hold multiples LW locks so it could mean having a list of about\n> 40K proclist_node per PGPROC.\n> * I also have concerns about possible performance impact by using\n> such a huge list in this context.\n>\n> Those are the reasons why this patch does not provide an exhaustive \n> list of blockers.\n>\n> While this patch does not provide an exhaustive list of blockers (in \n> case of LW_SHARED holders), the information it delivers could already \n> be useful to get insights during LWLock contention scenario.\n>\n> I will add this patch to the next commitfest. I look forward to your \n> feedback about the idea and/or implementation.\n>\n> Regards,\n>\n> Bertrand \n\nAttaching a new version of the patch with a tiny change to make it pass \nthe regression tests (opr_sanity was failing due to the new function \nthat is part of the patch).\n\nRegards,\n\nBertrand","msg_date":"Sun, 7 Jun 2020 08:12:59 +0200","msg_from":"\"Drouvot, Bertrand\" <bdrouvot@amazon.com>","msg_from_op":true,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"Hi, \r\nThis is a very interesting topic. I did apply the 2nd patch to master branch and performed a quick test. I can observe below information,\r\npostgres=# select * from pg_lwlock_blocking_pid(26925);\r\n requested_mode | last_holder_pid | last_holder_mode | nb_holders \r\n----------------+-----------------+------------------+------------\r\n LW_EXCLUSIVE | 26844 | LW_EXCLUSIVE | 1\r\n(1 row)\r\n\r\npostgres=# select query,pid,state,wait_event,wait_event_type,pg_lwlock_blocking_pid(pid),pg_blocking_pids(pid) from pg_stat_activity where state='active' and pid != pg_backend_pid();\r\n query | pid | state | wait_event | wait_event_type | pg_lwlock_blocking_pid | pg_blocking_pids \r\n--------------------------------------------------------------+-------+--------+------------+-----------------+-------------------------------------+------------------\r\n INSERT INTO orders SELECT FROM generate_series(1, 10000000); | 26925 | active | WALWrite | LWLock | (LW_EXCLUSIVE,26844,LW_EXCLUSIVE,1) | {}\r\n(1 row)\r\n\r\nAt some points, I have to keep repeating the query in order to capture the \"lock info\". I think this is probably part of the design, but I was wondering,\r\nif a query is in deadlock expecting a developer to take a look using the methods above, will the process be killed before a developer get the chance to execute the one of the query?\r\nif some statistics information can be added, it may help the developers to get an overall idea about the lock status, and if the developers can specify some filters, such as, the number of times a query entered into a deadlock, the queries hold the lock more than number of ms, etc, it might help to troubleshooting the \"lock\" issue even better. And moreover, if this feature can be an independent extension, similar to \"pg_buffercache\" it will be great.\r\nBest regards,\r\n\r\nDavid","msg_date":"Fri, 07 Aug 2020 19:53:38 +0000","msg_from":"David Zhang <david.zhang@highgo.ca>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com> wrote:\n> the patch adds into the LWLock struct:\n>\n> last_holding_pid: last pid owner of the lock\n> last_mode: last holding mode of the last pid owner of the lock\n> nholders: number of holders (could be >1 in case of LW_SHARED)\n\nThere's been significant work done over the years to get the size of\nan LWLock down; I'm not very enthusiastic about making it bigger\nagain. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\nwhich embeds one of the LWLocks associated with a BufferDesc into the\nstructure to reduce the number of cache lines associated with common\nbuffer operations. I'm not sure whether this patch would increase the\nspace usage of a BufferDesc to more than one cache line again, but at\nthe very least it would make it a lot tighter, since it looks like it\nadds 12 bytes to the size of each one.\n\nIt's also a little hard to believe that this doesn't hurt performance\non workloads with a lot of LWLock contention, although maybe not; it\ndoesn't seem crazy expensive, just possibly enough to matter.\n\nI thought a little bit about what this might buy as compared with just\nsampling wait events. That by itself is enough to tell you which\nLWLocks are heavily contended. It doesn't tell you what they are\ncontending against, so this would be superior in that regard. However,\nI wonder how much of a problem that actually is. Typically, LWLocks\naren't being taken for long periods, so all the things that are\naccessing the lock spend some time waiting (which you will see via\nwait events in pg_stat_activity) and some time holding the lock\n(making you see other things in pg_stat_activity). It's possible to\nhave cases where this isn't true; e.g. a relatively small number of\nbackends committing transactions could be slowing down a much larger\nnumber of backends taking snapshots, and you'd mostly only see the\nlatter waiting for ProcArrayLock. However, those kinds of cases don't\nseem super-common or super-difficult to figure out.\n\nWhat kinds of scenarios motivate you to propose this?\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n","msg_date":"Mon, 10 Aug 2020 18:27:17 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"Hi,\n\nOn 2020-08-10 18:27:17 -0400, Robert Haas wrote:\n> On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com> wrote:\n> > the patch adds into the LWLock struct:\n> >\n> > last_holding_pid: last pid owner of the lock\n> > last_mode: last holding mode of the last pid owner of the lock\n> > nholders: number of holders (could be >1 in case of LW_SHARED)\n> \n> There's been significant work done over the years to get the size of\n> an LWLock down; I'm not very enthusiastic about making it bigger\n> again. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\n> which embeds one of the LWLocks associated with a BufferDesc into the\n> structure to reduce the number of cache lines associated with common\n> buffer operations. I'm not sure whether this patch would increase the\n> space usage of a BufferDesc to more than one cache line again, but at\n> the very least it would make it a lot tighter, since it looks like it\n> adds 12 bytes to the size of each one.\n\n+many. If anything I would like to make them *smaller*. We should strive\nto make locking more and more granular, and that requires the space\noverhead to be small. I'm unhappy enough about the tranche being in\nthere, and requiring padding etc.\n\nI spent a *LOT* of sweat getting where we are, I'd be unhappy to regress\non size or efficiency.\n\n\n> It's also a little hard to believe that this doesn't hurt performance\n> on workloads with a lot of LWLock contention, although maybe not; it\n> doesn't seem crazy expensive, just possibly enough to matter.\n\nYea.\n\n\n> I thought a little bit about what this might buy as compared with just\n> sampling wait events. That by itself is enough to tell you which\n> LWLocks are heavily contended. It doesn't tell you what they are\n> contending against, so this would be superior in that regard. However,\n> I wonder how much of a problem that actually is. Typically, LWLocks\n> aren't being taken for long periods, so all the things that are\n> accessing the lock spend some time waiting (which you will see via\n> wait events in pg_stat_activity) and some time holding the lock\n> (making you see other things in pg_stat_activity). It's possible to\n> have cases where this isn't true; e.g. a relatively small number of\n> backends committing transactions could be slowing down a much larger\n> number of backends taking snapshots, and you'd mostly only see the\n> latter waiting for ProcArrayLock. However, those kinds of cases don't\n> seem super-common or super-difficult to figure out.\n\nMost of the cases where this kind of information really is interesting\nseem to benefit a lot from having stack information available. That\nobviously has overhead, so we don't want the cost all the\ntime. The script at\nhttps://postgr.es/m/20170622210845.d2hsbqv6rxu2tiye%40alap3.anarazel.de\ncan give you results like e.g.\nhttps://anarazel.de/t/2017-06-22/pgsemwait_64_async.svg\n\nGreetings,\n\nAndres Freund\n\n\n","msg_date":"Mon, 10 Aug 2020 17:41:36 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"On Mon, Aug 10, 2020 at 5:41 PM Andres Freund <andres@anarazel.de> wrote:\n> Most of the cases where this kind of information really is interesting\n> seem to benefit a lot from having stack information available. That\n> obviously has overhead, so we don't want the cost all the\n> time. The script at\n> https://postgr.es/m/20170622210845.d2hsbqv6rxu2tiye%40alap3.anarazel.de\n> can give you results like e.g.\n> https://anarazel.de/t/2017-06-22/pgsemwait_64_async.svg\n\nIt seems to have bitrot. Do you have a more recent version of the script?\n\n\n-- \nPeter Geoghegan\n\n\n","msg_date":"Wed, 12 Aug 2020 16:47:13 -0700","msg_from":"Peter Geoghegan <pg@bowt.ie>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"Hi,\n\nOn 2020-08-12 16:47:13 -0700, Peter Geoghegan wrote:\n> On Mon, Aug 10, 2020 at 5:41 PM Andres Freund <andres@anarazel.de> wrote:\n> > Most of the cases where this kind of information really is interesting\n> > seem to benefit a lot from having stack information available. That\n> > obviously has overhead, so we don't want the cost all the\n> > time. The script at\n> > https://postgr.es/m/20170622210845.d2hsbqv6rxu2tiye%40alap3.anarazel.de\n> > can give you results like e.g.\n> > https://anarazel.de/t/2017-06-22/pgsemwait_64_async.svg\n> \n> It seems to have bitrot. Do you have a more recent version of the script?\n\nAttached. Needed one python3 fix, and to be adapted so it works with\nfutex based semaphores. Seems to work for both sysv and posix semaphores\nnow, based a very short test.\n\nsudo python3 ./pgsemwait.py -x /home/andres/build/postgres/dev-optimize/vpath/src/backend/postgres -f 3|~/src/flamegraph/flamegraph.pl\n\nWill add a note to the other thread.\n\nGreetings,\n\nAndres Freund","msg_date":"Wed, 12 Aug 2020 17:39:34 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"On Wed, Aug 12, 2020 at 5:39 PM Andres Freund <andres@anarazel.de> wrote:\n> Attached. Needed one python3 fix, and to be adapted so it works with\n> futex based semaphores. Seems to work for both sysv and posix semaphores\n> now, based a very short test.\n\nGreat, thanks!\n\n-- \nPeter Geoghegan\n\n\n","msg_date":"Wed, 12 Aug 2020 18:03:43 -0700","msg_from":"Peter Geoghegan <pg@bowt.ie>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"On 11/08/2020 03:41, Andres Freund wrote:\n> On 2020-08-10 18:27:17 -0400, Robert Haas wrote:\n>> On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com> wrote:\n>>> the patch adds into the LWLock struct:\n>>>\n>>> last_holding_pid: last pid owner of the lock\n>>> last_mode: last holding mode of the last pid owner of the lock\n>>> nholders: number of holders (could be >1 in case of LW_SHARED)\n>>\n>> There's been significant work done over the years to get the size of\n>> an LWLock down; I'm not very enthusiastic about making it bigger\n>> again. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\n>> which embeds one of the LWLocks associated with a BufferDesc into the\n>> structure to reduce the number of cache lines associated with common\n>> buffer operations. I'm not sure whether this patch would increase the\n>> space usage of a BufferDesc to more than one cache line again, but at\n>> the very least it would make it a lot tighter, since it looks like it\n>> adds 12 bytes to the size of each one.\n> \n> +many. If anything I would like to make them *smaller*. We should strive\n> to make locking more and more granular, and that requires the space\n> overhead to be small. I'm unhappy enough about the tranche being in\n> there, and requiring padding etc.\n> \n> I spent a *LOT* of sweat getting where we are, I'd be unhappy to regress\n> on size or efficiency.\n\nThat seems to be the consensus, so I'm marking this as Returned with \nFeeback in the commitfest.\n\n- Heikki\n\n\n","msg_date":"Wed, 18 Nov 2020 11:25:26 +0200","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"},{"msg_contents":"On Wed, Nov 18, 2020 at 5:25 PM Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n\n> On 11/08/2020 03:41, Andres Freund wrote:\n> > On 2020-08-10 18:27:17 -0400, Robert Haas wrote:\n> >> On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com>\n> wrote:\n> >>> the patch adds into the LWLock struct:\n> >>>\n> >>> last_holding_pid: last pid owner of the lock\n> >>> last_mode: last holding mode of the last pid\n> owner of the lock\n> >>> nholders: number of holders (could be >1 in case\n> of LW_SHARED)\n> >>\n> >> There's been significant work done over the years to get the size of\n> >> an LWLock down; I'm not very enthusiastic about making it bigger\n> >> again. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\n> >> which embeds one of the LWLocks associated with a BufferDesc into the\n> >> structure to reduce the number of cache lines associated with common\n> >> buffer operations. I'm not sure whether this patch would increase the\n> >> space usage of a BufferDesc to more than one cache line again, but at\n> >> the very least it would make it a lot tighter, since it looks like it\n> >> adds 12 bytes to the size of each one.\n> >\n> > +many. If anything I would like to make them *smaller*. We should strive\n> > to make locking more and more granular, and that requires the space\n> > overhead to be small. I'm unhappy enough about the tranche being in\n> > there, and requiring padding etc.\n> >\n> > I spent a *LOT* of sweat getting where we are, I'd be unhappy to regress\n> > on size or efficiency.\n>\n> That seems to be the consensus, so I'm marking this as Returned with\n> Feeback in the commitfest.\n>\n\nFor what it's worth, I think that things like this are where we can really\nbenefit from external tracing and observation tools.\n\nInstead of tracking the information persistently in the LWLock struct, we\ncan emit TRACE_POSTGRESQL_LWLOCK_BLOCKED_ON(...) in a context where we have\nthe information available to us, then forget all about it. We don't spend\nanything unless someone's collecting the info.\n\nIf someone wants to track LWLock blocking relationships during debugging\nand performance work, they can use systemtap, dtrace, bpftrace, or a\nsimilar tool to observe the LWLock tracepoints and generate stats on LWLock\nblocking frequencies/durations. Doing so with systemtap should be rather\nsimple.\n\nI actually already had a look at this before. I found that the tracepoints\nthat're in the LWLock code right now don't supply enough information in\ntheir arguments so you have to use DWARF debuginfo based probes, which is a\npain. The tranche name alone doesn't let you identify which lock within a\ntranche is the current target.\n\nI've attached a patch that adds the actual LWLock* to each tracepoint in\nthe LWLock subsystem. That permits different locks to be tracked when\nhandling tracepoint events within a single process.\n\nAnother patch adds tracepoints that were missing from LWLockUpdateVar and\nLWLockWaitForVar. And another removes a stray\nTRACE_POSTGRESQL_LWLOCK_ACQUIRE() in LWLockWaitForVar() which should not\nhave been there, since the lock is not actually acquired by\nLWLockWaitForVar().\n\nI'd hoped to add some sort of \"index within the tranche\" to tracepoints,\nbut it looks like it's not feasible. It turns out to be basically\nimpossible to get a stable identifier for an individual LWLock that is\nvalid across different backends. A LWLock inside a DSM segment might have a\ndifferent address in different backends depending on where the DSM segment\ngot mapped. The LWLock subsystem doesn't keep track of them and doesn't\nhave any way to map a LWLock pointer to any sort of cross-process-valid\nidentifier. So that's a bit of a pain when tracing. To provide something\nstable I think it'd be necessary to add some kind of counter tracked\nper-tranche and set by LWLockInitialize in the LWLock struct itself, which\nwe sure don't want to do. If this ever becomes important for some reason we\ncan probably look up whether the address is within a DSM segment or static\nshmem and compute some kind of relative address to report. For now you\ncan't identify and compare individual locks within a tranche except for\nindividual locks and named tranches.\n\n\nBy the way, the LWLock tracepoints currently fire T_NAME(lock) which calls\nGetLWTrancheName() for each tracepoint hit, so long as Pg is built with\n--enable-dtrace, even when nothing is actually tracing them. We might want\nto consider guarding them in systemtap tracepoint semaphore tests so they\njust become a predicted-away branch when not active. Doing so requires a\nsmall change to how we compile probes.d and the related makefile, but\nshouldn't be too hard. I haven't done that in this patch set.","msg_date":"Thu, 19 Nov 2020 18:33:49 +0800","msg_from":"Craig Ringer <craig.ringer@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Add LWLock blocker(s) information"}],"string":"[\n {\n \"msg_contents\": \"Hi hackers,\\n\\n\\nI've attached a patch to add blocker(s) information for LW Locks.\\nThe motive behind is to be able to get some blocker(s) information (if \\nany) in the context of LW Locks.\\n\\n_Motivation:_\\n\\nWe have seen some cases with heavy contention on some LW Locks (large \\nnumber of backends waiting on the same LW Lock).\\n\\nAdding some blocker information would make the investigations easier, it \\ncould help answering questions like:\\n\\n * how many PIDs are holding the LWLock (could be more than one in case\\n of LW_SHARED)?\\n * Is the blocking PID changing?\\n * Is the number of blocking PIDs changing?\\n * What is the blocking PID doing?\\n * Is the blocking PID waiting?\\n * In which mode request is the blocked PID?\\n * in which mode is the blocker PID holding the lock?\\n\\n_Technical context and proposal:_\\n\\nThere is 2 points in this patch:\\n\\n * Add the instrumentation:\\n\\n * the patch adds into the LWLock struct:\\n\\n last_holding_pid: last pid owner of the lock\\n last_mode: last holding mode of the last pid owner \\nof the lock\\n nholders: number of holders (could be >1 in case of \\nLW_SHARED)\\n\\n * the patch adds into the PGPROC struct:\\n\\n//lwLastHoldingPid: last holder of the LW lock the PID is waiting for\\n lwHolderMode; LW lock mode of last holder of the \\nLW lock the PID is waiting for\\n lwNbHolders: number of holders of the LW lock the \\nPID is waiting for\\n\\n and what is necessary to update this new information.\\n\\n * Provide a way to display the information: the patch also adds a\\n function /pg_lwlock_blocking_pid/ to display this new information.\\n\\n_Outcome Example:_\\n\\n# select * from pg_lwlock_blocking_pid(10259);\\n\\n requested_mode | last_holder_pid | last_holder_mode | nb_holders\\n\\n----------------+-----------------+------------------+------------\\n\\n LW_EXCLUSIVE | 10232 | LW_EXCLUSIVE | 1\\n\\n(1 row)\\n\\n \\n\\n # select query,pid,state,wait_event,wait_event_type,pg_lwlock_blocking_pid(pid),pg_blocking_pids(pid) from pg_stat_activity where state='active' and pid != pg_backend_pid();\\n\\n query | pid | state | wait_event | wait_event_type | pg_lwlock_blocking_pid | pg_blocking_pids\\n\\n--------------------------------+-------+--------+---------------+-----------------+-------------------------------------------+------------------\\n\\n insert into bdtlwa values (1); | 10232 | active | | | (,,,) | {}\\n\\n insert into bdtlwb values (1); | 10254 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\\n\\n create table bdtwt (a int); | 10256 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\\n\\n insert into bdtlwa values (2); | 10259 | active | BufferContent | LWLock | (LW_EXCLUSIVE,10232,LW_EXCLUSIVE,1) | {}\\n\\n drop table bdtlwd; | 10261 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\\n\\n(5 rows)\\n\\n\\nSo, should a PID being blocked on a LWLock we could see:\\n\\n * in which mode request it is waiting\\n * the last pid holding the lock\\n * the mode of the last PID holding the lock\\n * the number of PID(s) holding the lock\\n\\n_Remarks:_\\n\\nI did a few benchmarks so far and did not observe notable performance \\ndegradation (can share more details if needed).\\n\\nI did some quick attempts to get an exhaustive list of blockers (in case \\nof LW_SHARED holders), but I think that would be challenging as:\\n\\n * There is about 40 000 calls to LWLockInitialize and all my attempts\\n to init a list here produced “ FATAL: out of shared memory” or similar.\\n * One way to get rid of using a list in LWLock could be to use\\n proc_list (with proclist_head in LWLock and proclist_node in\\n PGPROC). This is the current implementation for the “waiters” list.\\n But this would not work for the blockers as one PGPROC can hold\\n multiples LW locks so it could mean having a list of about 40K\\n proclist_node per PGPROC.\\n * I also have concerns about possible performance impact by using such\\n a huge list in this context.\\n\\nThose are the reasons why this patch does not provide an exhaustive list \\nof blockers.\\n\\nWhile this patch does not provide an exhaustive list of blockers (in \\ncase of LW_SHARED holders), the information it delivers could already be \\nuseful to get insights during LWLock contention scenario.\\n\\nI will add this patch to the next commitfest. I look forward to your \\nfeedback about the idea and/or implementation.\\n\\nRegards,\\n\\nBertrand\",\n \"msg_date\": \"Tue, 2 Jun 2020 14:24:53 +0200\",\n \"msg_from\": \"\\\"Drouvot, Bertrand\\\" <bdrouvot@amazon.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"Hi hackers,\\n\\nOn 6/2/20 2:24 PM, Drouvot, Bertrand wrote:\\n>\\n> Hi hackers,\\n>\\n>\\n> I've attached a patch to add blocker(s) information for LW Locks.\\n> The motive behind is to be able to get some blocker(s) information (if \\n> any) in the context of LW Locks.\\n>\\n> _Motivation:_\\n>\\n> We have seen some cases with heavy contention on some LW Locks (large \\n> number of backends waiting on the same LW Lock).\\n>\\n> Adding some blocker information would make the investigations easier, \\n> it could help answering questions like:\\n>\\n> * how many PIDs are holding the LWLock (could be more than one in\\n> case of LW_SHARED)?\\n> * Is the blocking PID changing?\\n> * Is the number of blocking PIDs changing?\\n> * What is the blocking PID doing?\\n> * Is the blocking PID waiting?\\n> * In which mode request is the blocked PID?\\n> * in which mode is the blocker PID holding the lock?\\n>\\n> _Technical context and proposal:_\\n>\\n> There is 2 points in this patch:\\n>\\n> * Add the instrumentation:\\n>\\n> * the patch adds into the LWLock struct:\\n>\\n> last_holding_pid: last pid owner of the lock\\n> last_mode: last holding mode of the last pid owner \\n> of the lock\\n> nholders: number of holders (could be >1 in case \\n> of LW_SHARED)\\n>\\n> * the patch adds into the PGPROC struct:\\n>\\n> //lwLastHoldingPid: last holder of the LW lock the PID is waiting for\\n> lwHolderMode; LW lock mode of last holder of the \\n> LW lock the PID is waiting for\\n> lwNbHolders: number of holders of the LW lock the \\n> PID is waiting for\\n>\\n> and what is necessary to update this new information.\\n>\\n> * Provide a way to display the information: the patch also adds a\\n> function /pg_lwlock_blocking_pid/ to display this new information.\\n>\\n> _Outcome Example:_\\n>\\n> # select * from pg_lwlock_blocking_pid(10259);\\n> requested_mode | last_holder_pid | last_holder_mode | nb_holders\\n> ----------------+-----------------+------------------+------------\\n> LW_EXCLUSIVE | 10232 | LW_EXCLUSIVE | 1\\n> (1 row)\\n> \\n> # select query,pid,state,wait_event,wait_event_type,pg_lwlock_blocking_pid(pid),pg_blocking_pids(pid) from pg_stat_activity where state='active' and pid != pg_backend_pid();\\n> query | pid | state | wait_event | wait_event_type | pg_lwlock_blocking_pid | pg_blocking_pids\\n> --------------------------------+-------+--------+---------------+-----------------+-------------------------------------------+------------------\\n> insert into bdtlwa values (1); | 10232 | active | | | (,,,) | {}\\n> insert into bdtlwb values (1); | 10254 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\\n> create table bdtwt (a int); | 10256 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\\n> insert into bdtlwa values (2); | 10259 | active | BufferContent | LWLock | (LW_EXCLUSIVE,10232,LW_EXCLUSIVE,1) | {}\\n> drop table bdtlwd; | 10261 | active | WALInsert | LWLock | (LW_WAIT_UNTIL_FREE,10232,LW_EXCLUSIVE,1) | {}\\n> (5 rows)\\n>\\n>\\n> So, should a PID being blocked on a LWLock we could see:\\n>\\n> * in which mode request it is waiting\\n> * the last pid holding the lock\\n> * the mode of the last PID holding the lock\\n> * the number of PID(s) holding the lock\\n>\\n> _Remarks:_\\n>\\n> I did a few benchmarks so far and did not observe notable performance \\n> degradation (can share more details if needed).\\n>\\n> I did some quick attempts to get an exhaustive list of blockers (in \\n> case of LW_SHARED holders), but I think that would be challenging as:\\n>\\n> * There is about 40 000 calls to LWLockInitialize and all my\\n> attempts to init a list here produced “ FATAL: out of shared\\n> memory” or similar.\\n> * One way to get rid of using a list in LWLock could be to use\\n> proc_list (with proclist_head in LWLock and proclist_node in\\n> PGPROC). This is the current implementation for the “waiters”\\n> list. But this would not work for the blockers as one PGPROC can\\n> hold multiples LW locks so it could mean having a list of about\\n> 40K proclist_node per PGPROC.\\n> * I also have concerns about possible performance impact by using\\n> such a huge list in this context.\\n>\\n> Those are the reasons why this patch does not provide an exhaustive \\n> list of blockers.\\n>\\n> While this patch does not provide an exhaustive list of blockers (in \\n> case of LW_SHARED holders), the information it delivers could already \\n> be useful to get insights during LWLock contention scenario.\\n>\\n> I will add this patch to the next commitfest. I look forward to your \\n> feedback about the idea and/or implementation.\\n>\\n> Regards,\\n>\\n> Bertrand \\n\\nAttaching a new version of the patch with a tiny change to make it pass \\nthe regression tests (opr_sanity was failing due to the new function \\nthat is part of the patch).\\n\\nRegards,\\n\\nBertrand\",\n \"msg_date\": \"Sun, 7 Jun 2020 08:12:59 +0200\",\n \"msg_from\": \"\\\"Drouvot, Bertrand\\\" <bdrouvot@amazon.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"Hi, \\r\\nThis is a very interesting topic. I did apply the 2nd patch to master branch and performed a quick test. I can observe below information,\\r\\npostgres=# select * from pg_lwlock_blocking_pid(26925);\\r\\n requested_mode | last_holder_pid | last_holder_mode | nb_holders \\r\\n----------------+-----------------+------------------+------------\\r\\n LW_EXCLUSIVE | 26844 | LW_EXCLUSIVE | 1\\r\\n(1 row)\\r\\n\\r\\npostgres=# select query,pid,state,wait_event,wait_event_type,pg_lwlock_blocking_pid(pid),pg_blocking_pids(pid) from pg_stat_activity where state='active' and pid != pg_backend_pid();\\r\\n query | pid | state | wait_event | wait_event_type | pg_lwlock_blocking_pid | pg_blocking_pids \\r\\n--------------------------------------------------------------+-------+--------+------------+-----------------+-------------------------------------+------------------\\r\\n INSERT INTO orders SELECT FROM generate_series(1, 10000000); | 26925 | active | WALWrite | LWLock | (LW_EXCLUSIVE,26844,LW_EXCLUSIVE,1) | {}\\r\\n(1 row)\\r\\n\\r\\nAt some points, I have to keep repeating the query in order to capture the \\\"lock info\\\". I think this is probably part of the design, but I was wondering,\\r\\nif a query is in deadlock expecting a developer to take a look using the methods above, will the process be killed before a developer get the chance to execute the one of the query?\\r\\nif some statistics information can be added, it may help the developers to get an overall idea about the lock status, and if the developers can specify some filters, such as, the number of times a query entered into a deadlock, the queries hold the lock more than number of ms, etc, it might help to troubleshooting the \\\"lock\\\" issue even better. And moreover, if this feature can be an independent extension, similar to \\\"pg_buffercache\\\" it will be great.\\r\\nBest regards,\\r\\n\\r\\nDavid\",\n \"msg_date\": \"Fri, 07 Aug 2020 19:53:38 +0000\",\n \"msg_from\": \"David Zhang <david.zhang@highgo.ca>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com> wrote:\\n> the patch adds into the LWLock struct:\\n>\\n> last_holding_pid: last pid owner of the lock\\n> last_mode: last holding mode of the last pid owner of the lock\\n> nholders: number of holders (could be >1 in case of LW_SHARED)\\n\\nThere's been significant work done over the years to get the size of\\nan LWLock down; I'm not very enthusiastic about making it bigger\\nagain. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\\nwhich embeds one of the LWLocks associated with a BufferDesc into the\\nstructure to reduce the number of cache lines associated with common\\nbuffer operations. I'm not sure whether this patch would increase the\\nspace usage of a BufferDesc to more than one cache line again, but at\\nthe very least it would make it a lot tighter, since it looks like it\\nadds 12 bytes to the size of each one.\\n\\nIt's also a little hard to believe that this doesn't hurt performance\\non workloads with a lot of LWLock contention, although maybe not; it\\ndoesn't seem crazy expensive, just possibly enough to matter.\\n\\nI thought a little bit about what this might buy as compared with just\\nsampling wait events. That by itself is enough to tell you which\\nLWLocks are heavily contended. It doesn't tell you what they are\\ncontending against, so this would be superior in that regard. However,\\nI wonder how much of a problem that actually is. Typically, LWLocks\\naren't being taken for long periods, so all the things that are\\naccessing the lock spend some time waiting (which you will see via\\nwait events in pg_stat_activity) and some time holding the lock\\n(making you see other things in pg_stat_activity). It's possible to\\nhave cases where this isn't true; e.g. a relatively small number of\\nbackends committing transactions could be slowing down a much larger\\nnumber of backends taking snapshots, and you'd mostly only see the\\nlatter waiting for ProcArrayLock. However, those kinds of cases don't\\nseem super-common or super-difficult to figure out.\\n\\nWhat kinds of scenarios motivate you to propose this?\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n\",\n \"msg_date\": \"Mon, 10 Aug 2020 18:27:17 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020-08-10 18:27:17 -0400, Robert Haas wrote:\\n> On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com> wrote:\\n> > the patch adds into the LWLock struct:\\n> >\\n> > last_holding_pid: last pid owner of the lock\\n> > last_mode: last holding mode of the last pid owner of the lock\\n> > nholders: number of holders (could be >1 in case of LW_SHARED)\\n> \\n> There's been significant work done over the years to get the size of\\n> an LWLock down; I'm not very enthusiastic about making it bigger\\n> again. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\\n> which embeds one of the LWLocks associated with a BufferDesc into the\\n> structure to reduce the number of cache lines associated with common\\n> buffer operations. I'm not sure whether this patch would increase the\\n> space usage of a BufferDesc to more than one cache line again, but at\\n> the very least it would make it a lot tighter, since it looks like it\\n> adds 12 bytes to the size of each one.\\n\\n+many. If anything I would like to make them *smaller*. We should strive\\nto make locking more and more granular, and that requires the space\\noverhead to be small. I'm unhappy enough about the tranche being in\\nthere, and requiring padding etc.\\n\\nI spent a *LOT* of sweat getting where we are, I'd be unhappy to regress\\non size or efficiency.\\n\\n\\n> It's also a little hard to believe that this doesn't hurt performance\\n> on workloads with a lot of LWLock contention, although maybe not; it\\n> doesn't seem crazy expensive, just possibly enough to matter.\\n\\nYea.\\n\\n\\n> I thought a little bit about what this might buy as compared with just\\n> sampling wait events. That by itself is enough to tell you which\\n> LWLocks are heavily contended. It doesn't tell you what they are\\n> contending against, so this would be superior in that regard. However,\\n> I wonder how much of a problem that actually is. Typically, LWLocks\\n> aren't being taken for long periods, so all the things that are\\n> accessing the lock spend some time waiting (which you will see via\\n> wait events in pg_stat_activity) and some time holding the lock\\n> (making you see other things in pg_stat_activity). It's possible to\\n> have cases where this isn't true; e.g. a relatively small number of\\n> backends committing transactions could be slowing down a much larger\\n> number of backends taking snapshots, and you'd mostly only see the\\n> latter waiting for ProcArrayLock. However, those kinds of cases don't\\n> seem super-common or super-difficult to figure out.\\n\\nMost of the cases where this kind of information really is interesting\\nseem to benefit a lot from having stack information available. That\\nobviously has overhead, so we don't want the cost all the\\ntime. The script at\\nhttps://postgr.es/m/20170622210845.d2hsbqv6rxu2tiye%40alap3.anarazel.de\\ncan give you results like e.g.\\nhttps://anarazel.de/t/2017-06-22/pgsemwait_64_async.svg\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n\",\n \"msg_date\": \"Mon, 10 Aug 2020 17:41:36 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 10, 2020 at 5:41 PM Andres Freund <andres@anarazel.de> wrote:\\n> Most of the cases where this kind of information really is interesting\\n> seem to benefit a lot from having stack information available. That\\n> obviously has overhead, so we don't want the cost all the\\n> time. The script at\\n> https://postgr.es/m/20170622210845.d2hsbqv6rxu2tiye%40alap3.anarazel.de\\n> can give you results like e.g.\\n> https://anarazel.de/t/2017-06-22/pgsemwait_64_async.svg\\n\\nIt seems to have bitrot. Do you have a more recent version of the script?\\n\\n\\n-- \\nPeter Geoghegan\\n\\n\\n\",\n \"msg_date\": \"Wed, 12 Aug 2020 16:47:13 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@bowt.ie>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020-08-12 16:47:13 -0700, Peter Geoghegan wrote:\\n> On Mon, Aug 10, 2020 at 5:41 PM Andres Freund <andres@anarazel.de> wrote:\\n> > Most of the cases where this kind of information really is interesting\\n> > seem to benefit a lot from having stack information available. That\\n> > obviously has overhead, so we don't want the cost all the\\n> > time. The script at\\n> > https://postgr.es/m/20170622210845.d2hsbqv6rxu2tiye%40alap3.anarazel.de\\n> > can give you results like e.g.\\n> > https://anarazel.de/t/2017-06-22/pgsemwait_64_async.svg\\n> \\n> It seems to have bitrot. Do you have a more recent version of the script?\\n\\nAttached. Needed one python3 fix, and to be adapted so it works with\\nfutex based semaphores. Seems to work for both sysv and posix semaphores\\nnow, based a very short test.\\n\\nsudo python3 ./pgsemwait.py -x /home/andres/build/postgres/dev-optimize/vpath/src/backend/postgres -f 3|~/src/flamegraph/flamegraph.pl\\n\\nWill add a note to the other thread.\\n\\nGreetings,\\n\\nAndres Freund\",\n \"msg_date\": \"Wed, 12 Aug 2020 17:39:34 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"On Wed, Aug 12, 2020 at 5:39 PM Andres Freund <andres@anarazel.de> wrote:\\n> Attached. Needed one python3 fix, and to be adapted so it works with\\n> futex based semaphores. Seems to work for both sysv and posix semaphores\\n> now, based a very short test.\\n\\nGreat, thanks!\\n\\n-- \\nPeter Geoghegan\\n\\n\\n\",\n \"msg_date\": \"Wed, 12 Aug 2020 18:03:43 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@bowt.ie>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"On 11/08/2020 03:41, Andres Freund wrote:\\n> On 2020-08-10 18:27:17 -0400, Robert Haas wrote:\\n>> On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com> wrote:\\n>>> the patch adds into the LWLock struct:\\n>>>\\n>>> last_holding_pid: last pid owner of the lock\\n>>> last_mode: last holding mode of the last pid owner of the lock\\n>>> nholders: number of holders (could be >1 in case of LW_SHARED)\\n>>\\n>> There's been significant work done over the years to get the size of\\n>> an LWLock down; I'm not very enthusiastic about making it bigger\\n>> again. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\\n>> which embeds one of the LWLocks associated with a BufferDesc into the\\n>> structure to reduce the number of cache lines associated with common\\n>> buffer operations. I'm not sure whether this patch would increase the\\n>> space usage of a BufferDesc to more than one cache line again, but at\\n>> the very least it would make it a lot tighter, since it looks like it\\n>> adds 12 bytes to the size of each one.\\n> \\n> +many. If anything I would like to make them *smaller*. We should strive\\n> to make locking more and more granular, and that requires the space\\n> overhead to be small. I'm unhappy enough about the tranche being in\\n> there, and requiring padding etc.\\n> \\n> I spent a *LOT* of sweat getting where we are, I'd be unhappy to regress\\n> on size or efficiency.\\n\\nThat seems to be the consensus, so I'm marking this as Returned with \\nFeeback in the commitfest.\\n\\n- Heikki\\n\\n\\n\",\n \"msg_date\": \"Wed, 18 Nov 2020 11:25:26 +0200\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n },\n {\n \"msg_contents\": \"On Wed, Nov 18, 2020 at 5:25 PM Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n\\n> On 11/08/2020 03:41, Andres Freund wrote:\\n> > On 2020-08-10 18:27:17 -0400, Robert Haas wrote:\\n> >> On Tue, Jun 2, 2020 at 8:25 AM Drouvot, Bertrand <bdrouvot@amazon.com>\\n> wrote:\\n> >>> the patch adds into the LWLock struct:\\n> >>>\\n> >>> last_holding_pid: last pid owner of the lock\\n> >>> last_mode: last holding mode of the last pid\\n> owner of the lock\\n> >>> nholders: number of holders (could be >1 in case\\n> of LW_SHARED)\\n> >>\\n> >> There's been significant work done over the years to get the size of\\n> >> an LWLock down; I'm not very enthusiastic about making it bigger\\n> >> again. See for example commit 6150a1b08a9fe7ead2b25240be46dddeae9d98e1\\n> >> which embeds one of the LWLocks associated with a BufferDesc into the\\n> >> structure to reduce the number of cache lines associated with common\\n> >> buffer operations. I'm not sure whether this patch would increase the\\n> >> space usage of a BufferDesc to more than one cache line again, but at\\n> >> the very least it would make it a lot tighter, since it looks like it\\n> >> adds 12 bytes to the size of each one.\\n> >\\n> > +many. If anything I would like to make them *smaller*. We should strive\\n> > to make locking more and more granular, and that requires the space\\n> > overhead to be small. I'm unhappy enough about the tranche being in\\n> > there, and requiring padding etc.\\n> >\\n> > I spent a *LOT* of sweat getting where we are, I'd be unhappy to regress\\n> > on size or efficiency.\\n>\\n> That seems to be the consensus, so I'm marking this as Returned with\\n> Feeback in the commitfest.\\n>\\n\\nFor what it's worth, I think that things like this are where we can really\\nbenefit from external tracing and observation tools.\\n\\nInstead of tracking the information persistently in the LWLock struct, we\\ncan emit TRACE_POSTGRESQL_LWLOCK_BLOCKED_ON(...) in a context where we have\\nthe information available to us, then forget all about it. We don't spend\\nanything unless someone's collecting the info.\\n\\nIf someone wants to track LWLock blocking relationships during debugging\\nand performance work, they can use systemtap, dtrace, bpftrace, or a\\nsimilar tool to observe the LWLock tracepoints and generate stats on LWLock\\nblocking frequencies/durations. Doing so with systemtap should be rather\\nsimple.\\n\\nI actually already had a look at this before. I found that the tracepoints\\nthat're in the LWLock code right now don't supply enough information in\\ntheir arguments so you have to use DWARF debuginfo based probes, which is a\\npain. The tranche name alone doesn't let you identify which lock within a\\ntranche is the current target.\\n\\nI've attached a patch that adds the actual LWLock* to each tracepoint in\\nthe LWLock subsystem. That permits different locks to be tracked when\\nhandling tracepoint events within a single process.\\n\\nAnother patch adds tracepoints that were missing from LWLockUpdateVar and\\nLWLockWaitForVar. And another removes a stray\\nTRACE_POSTGRESQL_LWLOCK_ACQUIRE() in LWLockWaitForVar() which should not\\nhave been there, since the lock is not actually acquired by\\nLWLockWaitForVar().\\n\\nI'd hoped to add some sort of \\\"index within the tranche\\\" to tracepoints,\\nbut it looks like it's not feasible. It turns out to be basically\\nimpossible to get a stable identifier for an individual LWLock that is\\nvalid across different backends. A LWLock inside a DSM segment might have a\\ndifferent address in different backends depending on where the DSM segment\\ngot mapped. The LWLock subsystem doesn't keep track of them and doesn't\\nhave any way to map a LWLock pointer to any sort of cross-process-valid\\nidentifier. So that's a bit of a pain when tracing. To provide something\\nstable I think it'd be necessary to add some kind of counter tracked\\nper-tranche and set by LWLockInitialize in the LWLock struct itself, which\\nwe sure don't want to do. If this ever becomes important for some reason we\\ncan probably look up whether the address is within a DSM segment or static\\nshmem and compute some kind of relative address to report. For now you\\ncan't identify and compare individual locks within a tranche except for\\nindividual locks and named tranches.\\n\\n\\nBy the way, the LWLock tracepoints currently fire T_NAME(lock) which calls\\nGetLWTrancheName() for each tracepoint hit, so long as Pg is built with\\n--enable-dtrace, even when nothing is actually tracing them. We might want\\nto consider guarding them in systemtap tracepoint semaphore tests so they\\njust become a predicted-away branch when not active. Doing so requires a\\nsmall change to how we compile probes.d and the related makefile, but\\nshouldn't be too hard. I haven't done that in this patch set.\",\n \"msg_date\": \"Thu, 19 Nov 2020 18:33:49 +0800\",\n \"msg_from\": \"Craig Ringer <craig.ringer@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Add LWLock blocker(s) information\"\n }\n]","isConversational":false}}},{"rowIdx":50398,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi all,\n\nI have been looking at the ODBC driver and the need for currtid() as\nwell as currtid2(), and as mentioned already in [1], matching with my\nlookup of things, these are actually not needed by the driver as long\nas we connect to a server newer than 8.2 able to support RETURNING. I\nam adding in CC of this thread Saito-san and Inoue-san who are the\ntwo main maintainers of the driver for comments. It is worth noting\nthat on its latest HEAD the ODBC driver requires libpq from at least\n9.2.\n\nI would like to remove those two functions and the surrounding code\nfor v14, leading to some cleanup:\n 6 files changed, 326 deletions(-)\n\nWhile on it, I have noticed that heap_get_latest_tid() is still\nlocated within heapam.c, but we can just move it within\nheapam_handler.c.\n\nAttached are two patches to address both points. Comments are\nwelcome.\n\nThanks,\n\n[1]: https://www.postgresql.org/message-id/20200529005559.jl2gsolomyro4l4n@alap3.anarazel.de\n--\nMichael","msg_date":"Wed, 3 Jun 2020 11:14:48 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Michael Paquier <michael@paquier.xyz> writes:\n> I would like to remove those two functions and the surrounding code\n> for v14, leading to some cleanup:\n\n+1\n\n> While on it, I have noticed that heap_get_latest_tid() is still\n> located within heapam.c, but we can just move it within\n> heapam_handler.c.\n\nIt looks like table_beginscan_tid wouldn't need to be exported anymore\neither.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Tue, 02 Jun 2020 22:34:05 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"I wrote:\n> It looks like table_beginscan_tid wouldn't need to be exported anymore\n> either.\n\nAh, scratch that, I misread it.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Tue, 02 Jun 2020 22:47:50 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Hi,\n\nOn 2020/06/03 11:14, Michael Paquier wrote:\n> Hi all,\n\n> I have been looking at the ODBC driver and the need for currtid() as\n> well as currtid2(), and as mentioned already in [1], matching with my\n> lookup of things, these are actually not needed by the driver as long\n> as we connect to a server newer than 8.2 able to support RETURNING.\n\nThough currtid2() is necessary even for servers which support RETURNING,\nI don't object to remove it.\n\nregards,\nHiroshi Inoue\n\n> I\n> am adding in CC of this thread Saito-san and Inoue-san who are the\n> two main maintainers of the driver for comments. It is worth noting\n> that on its latest HEAD the ODBC driver requires libpq from at least\n> 9.2.\n>\n> I would like to remove those two functions and the surrounding code\n> for v14, leading to some cleanup:\n> 6 files changed, 326 deletions(-)\n>\n> While on it, I have noticed that heap_get_latest_tid() is still\n> located within heapam.c, but we can just move it within\n> heapam_handler.c.\n>\n> Attached are two patches to address both points. Comments are\n> welcome.\n>\n> Thanks,\n>\n> [1]: https://www.postgresql.org/message-id/20200529005559.jl2gsolomyro4l4n@alap3.anarazel.de\n> --\n> Michael\n\n\n\n","msg_date":"Wed, 3 Jun 2020 22:10:21 +0900","msg_from":"\"Inoue, Hiroshi\" <h-inoue@dream.email.ne.jp>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Hi,\n\nOn 2020-06-03 11:14:48 +0900, Michael Paquier wrote:\n> I would like to remove those two functions and the surrounding code\n> for v14, leading to some cleanup:\n> 6 files changed, 326 deletions(-)\n\n+1\n\n\n> While on it, I have noticed that heap_get_latest_tid() is still\n> located within heapam.c, but we can just move it within\n> heapam_handler.c.\n\nWhat's the point of that change? I think the differentiation between\nheapam_handler.c and heapam.c could be clearer, but if anything, I'd\nargue that heap_get_latest_tid is sufficiently low-level that it'd\nbelong in heapam.c.\n\n\nGreetings,\n\nAndres Freund\n\n\n","msg_date":"Thu, 4 Jun 2020 10:59:05 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Thu, Jun 04, 2020 at 10:59:05AM -0700, Andres Freund wrote:\n> What's the point of that change? I think the differentiation between\n> heapam_handler.c and heapam.c could be clearer, but if anything, I'd\n> argue that heap_get_latest_tid is sufficiently low-level that it'd\n> belong in heapam.c.\n\nWell, heap_get_latest_tid() is only called in heapam_handler.c if\nanything, as it is not used elsewhere and not publish it. And IMO we\nshould try to encourage using table_get_latest_tid() instead if some\nplugins need that. Anyway, if you are opposed to this change, I won't\npush hard for it either.\n--\nMichael","msg_date":"Fri, 5 Jun 2020 15:07:34 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Wed, Jun 03, 2020 at 10:10:21PM +0900, Inoue, Hiroshi wrote:\n> On 2020/06/03 11:14, Michael Paquier wrote:\n>> I have been looking at the ODBC driver and the need for currtid() as\n>> well as currtid2(), and as mentioned already in [1], matching with my\n>> lookup of things, these are actually not needed by the driver as long\n>> as we connect to a server newer than 8.2 able to support RETURNING.\n> \n> Though currtid2() is necessary even for servers which support RETURNING,\n> I don't object to remove it.\n\nIn which cases is it getting used then? From what I can see there is\nzero coverage for that part in the tests. And based on a rough read\nof the code, this would get called with LATEST_TUPLE_LOAD being set,\nwhere there is some kind of bulk deletion involved. Couldn't that be\na problem?\n--\nMichael","msg_date":"Fri, 5 Jun 2020 15:22:28 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On 2020/06/05 15:22, Michael Paquier wrote:\n> On Wed, Jun 03, 2020 at 10:10:21PM +0900, Inoue, Hiroshi wrote:\n>> On 2020/06/03 11:14, Michael Paquier wrote:\n>>> I have been looking at the ODBC driver and the need for currtid() as\n>>> well as currtid2(), and as mentioned already in [1], matching with my\n>>> lookup of things, these are actually not needed by the driver as long\n>>> as we connect to a server newer than 8.2 able to support RETURNING.\n>> Though currtid2() is necessary even for servers which support RETURNING,\n>> I don't object to remove it.\n> In which cases is it getting used then?\n\nKeyset-driven cursors always detect changes made by other applications\n(and themselves). currtid() is necessary to detect the changes.\nCTIDs are changed by updates unfortunately.\n\nregards,\nHiroshi Inoue\n\n> From what I can see there is\n> zero coverage for that part in the tests. And based on a rough read\n> of the code, this would get called with LATEST_TUPLE_LOAD being set,\n> where there is some kind of bulk deletion involved. Couldn't that be\n> a problem?\n> --\n> Michael\n\n\n\n\n\n\n\n\n\nOn 2020/06/05 15:22, Michael Paquier\n wrote:\n\n\nOn Wed, Jun 03, 2020 at 10:10:21PM +0900, Inoue, Hiroshi wrote:\n\n\nOn 2020/06/03 11:14, Michael Paquier wrote:\n\n\nI have been looking at the ODBC driver and the need for currtid() as\nwell as currtid2(), and as mentioned already in [1], matching with my\nlookup of things, these are actually not needed by the driver as long\nas we connect to a server newer than 8.2 able to support RETURNING.\n\n\n\nThough currtid2() is necessary even for servers which support RETURNING,\nI don't object to remove it.\n\n\n\nIn which cases is it getting used then?\n\n\nKeyset-driven cursors always detect changes made by other\n applications\n (and themselves). currtid() is necessary to detect the changes.\n CTIDs are changed by updates unfortunately.\n\n regards,\n Hiroshi Inoue\n\n\n\n From what I can see there is\nzero coverage for that part in the tests. And based on a rough read\nof the code, this would get called with LATEST_TUPLE_LOAD being set,\nwhere there is some kind of bulk deletion involved. Couldn't that be\na problem?\n--\nMichael","msg_date":"Fri, 5 Jun 2020 22:25:00 +0900","msg_from":"\"Inoue, Hiroshi\" <h-inoue@dream.email.ne.jp>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Fri, Jun 05, 2020 at 10:25:00PM +0900, Inoue, Hiroshi wrote:\n> Keyset-driven cursors always detect changes made by other applications\n> (and themselves). currtid() is necessary to detect the changes.\n> CTIDs are changed by updates unfortunately.\n\nYou mean currtid2() here and not currtid(), right? We have two\nproblems here then:\n1) We cannot actually really remove currtid2() from the backend yet\nwithout removing the dependency in the driver, or that may break some\nusers.\n2) The driver does not include tests for that stuff yet.\n--\nMichael","msg_date":"Mon, 8 Jun 2020 15:52:41 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Sorry for the reply.\n\nOn 2020/06/08 15:52, Michael Paquier wrote:\n> On Fri, Jun 05, 2020 at 10:25:00PM +0900, Inoue, Hiroshi wrote:\n>> Keyset-driven cursors always detect changes made by other applications\n>> (and themselves). currtid() is necessary to detect the changes.\n>> CTIDs are changed by updates unfortunately.\n> You mean currtid2() here and not currtid(), right?\n\nYes.\n\n> We have two\n> problems here then:\n> 1) We cannot actually really remove currtid2() from the backend yet\n> without removing the dependency in the driver, or that may break some\n> users.\n\nI think only ODBC driver uses currtid2().\n\n> 2) The driver does not include tests for that stuff yet.\n\nSQLSetPos(.., .., SQL_REFRESH, ..) call in positioned-update-test passes \nthe stuff\n �when 'Use Declare/Fetch' option is turned off. In other words, \nkeyset-driven cursor\nis not supported when 'Use Declare/Fetch' option is turned on. Probably \nkeyset-driven\ncursor support would be lost regardless of 'Use Declare/Fetch' option \nafter the\nremoval of currtid2().\n\n> --\n> Michael\n\n\n\n","msg_date":"Mon, 15 Jun 2020 20:50:23 +0900","msg_from":"\"Inoue, Hiroshi\" <h-inoue@dream.email.ne.jp>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Mon, Jun 15, 2020 at 08:50:23PM +0900, Inoue, Hiroshi wrote:\n> Sorry for the reply.\n\nNo problem, thanks for taking the time.\n\n> On 2020/06/08 15:52, Michael Paquier wrote:\n>> On Fri, Jun 05, 2020 at 10:25:00PM +0900, Inoue, Hiroshi wrote:\n>> We have two\n>> problems here then:\n>> 1) We cannot actually really remove currtid2() from the backend yet\n>> without removing the dependency in the driver, or that may break some\n>> users.\n> \n> I think only ODBC driver uses currtid2().\n\nCheck. I think so too.\n\n>> 2) The driver does not include tests for that stuff yet.\n> \n> SQLSetPos(.., .., SQL_REFRESH, ..) call in positioned-update-test passes the\n> stuff\n> when 'Use Declare/Fetch' option is turned off. In other words,\n> keyset-driven cursor\n> is not supported when 'Use Declare/Fetch' option is turned on. Probably\n> keyset-driven\n> cursor support would be lost regardless of 'Use Declare/Fetch' option after\n> the removal of currtid2().\n\nSorry, but I am not quite sure what is the relationship between\nUseDeclareFetch and currtid2()? Is that related to the use of\nSQL_CURSOR_KEYSET_DRIVEN? The only thing I can be sure of here is\nthat we never call currtid2() in any of the regression tests present\nin the ODBC code for any of the scenarios covered by installcheck-all,\nso that does not really bring any confidence that removing currtid2()\nis a wise thing to do, because we may silently break stuff. If the\nfunction is used, it would be good to close the gap with a test to\nstress that at least in the driver.\n\ncurrtid(), on the contrary, would be fine as far as I understand\nbecause the ODBC code relies on a RETURNING ctid instead, and that's\nsupported for ages in the Postgres backend.\n--\nMichael","msg_date":"Tue, 23 Jun 2020 13:29:06 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Tue, Jun 23, 2020 at 01:29:06PM +0900, Michael Paquier wrote:\n> Sorry, but I am not quite sure what is the relationship between\n> UseDeclareFetch and currtid2()? Is that related to the use of\n> SQL_CURSOR_KEYSET_DRIVEN? The only thing I can be sure of here is\n> that we never call currtid2() in any of the regression tests present\n> in the ODBC code for any of the scenarios covered by installcheck-all,\n> so that does not really bring any confidence that removing currtid2()\n> is a wise thing to do, because we may silently break stuff. If the\n> function is used, it would be good to close the gap with a test to\n> stress that at least in the driver.\n\nActually, while reviewing the code, the only code path where we use\ncurrtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\nonly location where this happens is in SC_pos_reload_with_key(), where\nI don't actually see how it would be possible to not have a keyset and\nstill use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\ncould it be possible that the code paths of currtid2() are actually\njust dead code?\n--\nMichael","msg_date":"Tue, 23 Jun 2020 14:02:33 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Tue, Jun 23, 2020 at 02:02:33PM +0900, Michael Paquier wrote:\n> Actually, while reviewing the code, the only code path where we use\n> currtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\n> only location where this happens is in SC_pos_reload_with_key(), where\n> I don't actually see how it would be possible to not have a keyset and\n> still use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\n> could it be possible that the code paths of currtid2() are actually\n> just dead code?\n\nI have dug more into this one, and we actually stressed this code path\nquite a lot up to commit d9cb23f in the ODBC driver, with tests\ncursor-block-delete, positioned-update and bulkoperations particularly\nwhen calling SQLSetPos(). However, 86e2e7a has reworked the code in\nsuch a way that we visibly don't use anymore CTIDs if we don't have a\nkeyset, and that combinations of various options like UseDeclareFetch\nor UpdatableCursors don't trigger this code path anymore. In short,\ncurrtid2() does not get used. Inoue-san, Saito-san, what do you\nthink? I am adding also Tsunakawa-san in CC who has some experience\nin this area.\n--\nMichael","msg_date":"Wed, 24 Jun 2020 11:11:10 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Hi Michael,\n\nWhere do you test, on Windows or on *nix?\nHow do you test there?\n\nregards,\nHiroshi Inoue\n\nOn 2020/06/24 11:11, Michael Paquier wrote:\n> On Tue, Jun 23, 2020 at 02:02:33PM +0900, Michael Paquier wrote:\n>> Actually, while reviewing the code, the only code path where we use\n>> currtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\n>> only location where this happens is in SC_pos_reload_with_key(), where\n>> I don't actually see how it would be possible to not have a keyset and\n>> still use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\n>> could it be possible that the code paths of currtid2() are actually\n>> just dead code?\n> I have dug more into this one, and we actually stressed this code path\n> quite a lot up to commit d9cb23f in the ODBC driver, with tests\n> cursor-block-delete, positioned-update and bulkoperations particularly\n> when calling SQLSetPos(). However, 86e2e7a has reworked the code in\n> such a way that we visibly don't use anymore CTIDs if we don't have a\n> keyset, and that combinations of various options like UseDeclareFetch\n> or UpdatableCursors don't trigger this code path anymore. In short,\n> currtid2() does not get used. Inoue-san, Saito-san, what do you\n> think? I am adding also Tsunakawa-san in CC who has some experience\n> in this area.\n> --\n> Michael\n\n\n\n","msg_date":"Wed, 24 Jun 2020 17:20:42 +0900","msg_from":"\"Inoue, Hiroshi\" <h-inoue@dream.email.ne.jp>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Hi Inoue-san,\n\nOn Wed, Jun 24, 2020 at 05:20:42PM +0900, Inoue, Hiroshi wrote:\n> Where do you test, on Windows or on *nix?\n> How do you test there?\n\nI have been testing the driver on macos only, with various backend\nversions, from 11 to 14.\n\nThanks,\n--\nMichael","msg_date":"Wed, 24 Jun 2020 18:00:23 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Hi,\n\nI seem to have invalidated KEYSET-DRIVEN cursors used in \npositioned-update test .\nIt was introduced by the commit 4a272fd but was invalidated by the \ncommit 2be35a6.\n\nI don't object to the removal of currtid(2) because keyset-driven \ncursors in psqlodbc are changed into static cursors in many cases and \nI've hardly ever heard a complaint about it.\n\nregards,\nHiroshi Inoue\n\nOn 2020/06/24 11:11, Michael Paquier wrote:\n> On Tue, Jun 23, 2020 at 02:02:33PM +0900, Michael Paquier wrote:\n>> Actually, while reviewing the code, the only code path where we use\n>> currtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\n>> only location where this happens is in SC_pos_reload_with_key(), where\n>> I don't actually see how it would be possible to not have a keyset and\n>> still use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\n>> could it be possible that the code paths of currtid2() are actually\n>> just dead code?\n> I have dug more into this one, and we actually stressed this code path\n> quite a lot up to commit d9cb23f in the ODBC driver, with tests\n> cursor-block-delete, positioned-update and bulkoperations particularly\n> when calling SQLSetPos(). However, 86e2e7a has reworked the code in\n> such a way that we visibly don't use anymore CTIDs if we don't have a\n> keyset, and that combinations of various options like UseDeclareFetch\n> or UpdatableCursors don't trigger this code path anymore. In short,\n> currtid2() does not get used. Inoue-san, Saito-san, what do you\n> think? I am adding also Tsunakawa-san in CC who has some experience\n> in this area.\n> --\n> Michael\n\n\n\n","msg_date":"Thu, 25 Jun 2020 22:14:00 +0900","msg_from":"\"Inoue, Hiroshi\" <h-inoue@dream.email.ne.jp>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Thu, Jun 25, 2020 at 10:14:00PM +0900, Inoue, Hiroshi wrote:\n> I seem to have invalidated KEYSET-DRIVEN cursors used in positioned-update\n> test. It was introduced by the commit 4a272fd but was invalidated by the\n> commit 2be35a6.\n> \n> I don't object to the removal of currtid(2) because keyset-driven cursors in\n> psqlodbc are changed into static cursors in many cases and I've hardly ever\n> heard a complaint about it.\n\nHmm. I am not sure that this completely answers my original concern\nthough. In short, don't we still have corner cases where\nkeyset-driven cursors are not changed into static cursors, meaning\nthat currtid2() could get used? The removal of the in-core functions\nwould hurt applications using that, meaning that we should at least\nprovide an equivalent of currtid2() in the worse case as a contrib\nmodule, no? If the code paths of currtid2() are reachable, shouldn't\nwe also make sure that they are still reached in the regression tests\nof the driver, meaning that the driver code needs more coverage? I\nhave been looking at the tests and tried to tweak them using\nSQLSetPos() so as the code paths involving currtid2() get reached, but \nI am not really able to do so. It does not mean that that currtid2()\nnever gets reached, it just means that I am not able to be sure that\nthis part can be safely removed from the Postgres backend code :( \n\nFrom what I can see on this thread, we could just remove currtid() per\nthe arguments of the RETURNING ctid clause supported since PG 8.2, but\nit would make more sense to me to just remove both currtid/currtid2()\nat once.\n--\nMichael","msg_date":"Fri, 26 Jun 2020 13:11:55 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Fri, Jun 26, 2020 at 01:11:55PM +0900, Michael Paquier wrote:\n> From what I can see on this thread, we could just remove currtid() per\n> the arguments of the RETURNING ctid clause supported since PG 8.2, but\n> it would make more sense to me to just remove both currtid/currtid2()\n> at once.\n\nThe CF bot is complaining, so here is a rebase for the main patch.\nOpinions are welcome about the arguments of upthread.\n--\nMichael","msg_date":"Thu, 3 Sep 2020 19:14:15 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On 2020-09-03 12:14, Michael Paquier wrote:\n> On Fri, Jun 26, 2020 at 01:11:55PM +0900, Michael Paquier wrote:\n>> From what I can see on this thread, we could just remove currtid() per\n>> the arguments of the RETURNING ctid clause supported since PG 8.2, but\n>> it would make more sense to me to just remove both currtid/currtid2()\n>> at once.\n> \n> The CF bot is complaining, so here is a rebase for the main patch.\n> Opinions are welcome about the arguments of upthread.\n\nIt appears that currtid2() is still used, so we ought to keep it.\n\n\n","msg_date":"Fri, 20 Nov 2020 16:14:49 +0100","msg_from":"Peter Eisentraut <peter.eisentraut@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Peter Eisentraut <peter.eisentraut@enterprisedb.com> writes:\n> On 2020-09-03 12:14, Michael Paquier wrote:\n>> Opinions are welcome about the arguments of upthread.\n\n> It appears that currtid2() is still used, so we ought to keep it.\n\nYeah, if pgODBC were not using it at all then I think it'd be fine\nto get rid of, but if it still contains calls then we cannot.\nThe suggestion upthread that those calls might be unreachable\nis interesting, but it seems unproven.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Fri, 20 Nov 2020 11:53:11 -0500","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Fri, Nov 20, 2020 at 11:53:11AM -0500, Tom Lane wrote:\n> Yeah, if pgODBC were not using it at all then I think it'd be fine\n> to get rid of, but if it still contains calls then we cannot.\n> The suggestion upthread that those calls might be unreachable\n> is interesting, but it seems unproven.\n\nYeah, I am not 100% sure that there are no code paths calling\ncurrtid2(), and the ODBC is too obscure to me to get to a clear\nconclusion. currtid() though, is a different deal thanks to\nRETURNING. What about cutting the cake in two and just remove\ncurrtid() then?\n--\nMichael","msg_date":"Sat, 21 Nov 2020 10:12:09 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Michael Paquier <michael@paquier.xyz> writes:\n> What about cutting the cake in two and just remove\n> currtid() then?\n\n+1. That'd still let us get rid of setLastTid() which is\nthe ugliest part of the thing, IMO.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Fri, 20 Nov 2020 21:50:08 -0500","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Fri, Nov 20, 2020 at 09:50:08PM -0500, Tom Lane wrote:\n> Michael Paquier <michael@paquier.xyz> writes:\n>> What about cutting the cake in two and just remove\n>> currtid() then?\n> \n> +1. That'd still let us get rid of setLastTid() which is\n> the ugliest part of the thing, IMO.\n\nIndeed, this could go. There is a recursive call for views, but in\norder to maintain compatibility with that we can just remove one\nfunction and move the second to use a regclass as argument, like the\nattached, while removing setLastTid(). Any thoughts?\n--\nMichael","msg_date":"Sat, 21 Nov 2020 14:45:30 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Michael Paquier <michael@paquier.xyz> writes:\n> Indeed, this could go. There is a recursive call for views, but in\n> order to maintain compatibility with that we can just remove one\n> function and move the second to use a regclass as argument, like the\n> attached, while removing setLastTid(). Any thoughts?\n\nConsidering that we're preserving this only for backwards compatibility,\nI doubt that changing the signature is a good idea. It maybe risks\nbreaking something, and the ODBC driver is hardly going to notice\nany improved ease-of-use.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Sat, 21 Nov 2020 13:13:35 -0500","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Hi,\n\n+1 for getting rid of whatever we can without too much trouble.\n\nOn 2020-11-21 13:13:35 -0500, Tom Lane wrote:\n> Michael Paquier <michael@paquier.xyz> writes:\n> > Indeed, this could go. There is a recursive call for views, but in\n> > order to maintain compatibility with that we can just remove one\n> > function and move the second to use a regclass as argument, like the\n> > attached, while removing setLastTid(). Any thoughts?\n> \n> Considering that we're preserving this only for backwards compatibility,\n> I doubt that changing the signature is a good idea. It maybe risks\n> breaking something, and the ODBC driver is hardly going to notice\n> any improved ease-of-use.\n\n+1.\n\nRegards,\n\nAndres\n\n\n","msg_date":"Sat, 21 Nov 2020 10:33:58 -0800","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Sat, Nov 21, 2020 at 01:13:35PM -0500, Tom Lane wrote:\n> Considering that we're preserving this only for backwards compatibility,\n> I doubt that changing the signature is a good idea. It maybe risks\n> breaking something, and the ODBC driver is hardly going to notice\n> any improved ease-of-use.\n\nSo, what you are basically saying is to switch currtid_byreloid() to\nbecome a function local to tid.c. And then have just\ncurrtid_byrelname() and currtid_for_view() call that, right?\n--\nMichael","msg_date":"Sun, 22 Nov 2020 11:09:32 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"Michael Paquier <michael@paquier.xyz> writes:\n> So, what you are basically saying is to switch currtid_byreloid() to\n> become a function local to tid.c. And then have just\n> currtid_byrelname() and currtid_for_view() call that, right?\n\nYeah, that sounds about right.\n\n\t\t\tregards, tom lane\n\n\n","msg_date":"Sat, 21 Nov 2020 21:39:28 -0500","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Sat, Nov 21, 2020 at 09:39:28PM -0500, Tom Lane wrote:\n> Michael Paquier <michael@paquier.xyz> writes:\n>> So, what you are basically saying is to switch currtid_byreloid() to\n>> become a function local to tid.c. And then have just\n>> currtid_byrelname() and currtid_for_view() call that, right?\n> \n> Yeah, that sounds about right.\n\nOkay, here you go with the attached. If there are any other comments,\nplease feel free.\n--\nMichael","msg_date":"Sun, 22 Nov 2020 20:11:21 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"},{"msg_contents":"On Sun, Nov 22, 2020 at 08:11:21PM +0900, Michael Paquier wrote:\n> Okay, here you go with the attached. If there are any other comments,\n> please feel free.\n\nHearing nothing, applied this one after going through the ODBC driver\ncode again this morning. Compatibility is exactly the same for\ncurrtid2(), while currtid() is now gone.\n--\nMichael","msg_date":"Wed, 25 Nov 2020 12:21:57 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: Removal of currtid()/currtid2() and some table AM cleanup"}],"string":"[\n {\n \"msg_contents\": \"Hi all,\\n\\nI have been looking at the ODBC driver and the need for currtid() as\\nwell as currtid2(), and as mentioned already in [1], matching with my\\nlookup of things, these are actually not needed by the driver as long\\nas we connect to a server newer than 8.2 able to support RETURNING. I\\nam adding in CC of this thread Saito-san and Inoue-san who are the\\ntwo main maintainers of the driver for comments. It is worth noting\\nthat on its latest HEAD the ODBC driver requires libpq from at least\\n9.2.\\n\\nI would like to remove those two functions and the surrounding code\\nfor v14, leading to some cleanup:\\n 6 files changed, 326 deletions(-)\\n\\nWhile on it, I have noticed that heap_get_latest_tid() is still\\nlocated within heapam.c, but we can just move it within\\nheapam_handler.c.\\n\\nAttached are two patches to address both points. Comments are\\nwelcome.\\n\\nThanks,\\n\\n[1]: https://www.postgresql.org/message-id/20200529005559.jl2gsolomyro4l4n@alap3.anarazel.de\\n--\\nMichael\",\n \"msg_date\": \"Wed, 3 Jun 2020 11:14:48 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael@paquier.xyz> writes:\\n> I would like to remove those two functions and the surrounding code\\n> for v14, leading to some cleanup:\\n\\n+1\\n\\n> While on it, I have noticed that heap_get_latest_tid() is still\\n> located within heapam.c, but we can just move it within\\n> heapam_handler.c.\\n\\nIt looks like table_beginscan_tid wouldn't need to be exported anymore\\neither.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Tue, 02 Jun 2020 22:34:05 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"I wrote:\\n> It looks like table_beginscan_tid wouldn't need to be exported anymore\\n> either.\\n\\nAh, scratch that, I misread it.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Tue, 02 Jun 2020 22:47:50 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020/06/03 11:14, Michael Paquier wrote:\\n> Hi all,\\n\\n> I have been looking at the ODBC driver and the need for currtid() as\\n> well as currtid2(), and as mentioned already in [1], matching with my\\n> lookup of things, these are actually not needed by the driver as long\\n> as we connect to a server newer than 8.2 able to support RETURNING.\\n\\nThough currtid2() is necessary even for servers which support RETURNING,\\nI don't object to remove it.\\n\\nregards,\\nHiroshi Inoue\\n\\n> I\\n> am adding in CC of this thread Saito-san and Inoue-san who are the\\n> two main maintainers of the driver for comments. It is worth noting\\n> that on its latest HEAD the ODBC driver requires libpq from at least\\n> 9.2.\\n>\\n> I would like to remove those two functions and the surrounding code\\n> for v14, leading to some cleanup:\\n> 6 files changed, 326 deletions(-)\\n>\\n> While on it, I have noticed that heap_get_latest_tid() is still\\n> located within heapam.c, but we can just move it within\\n> heapam_handler.c.\\n>\\n> Attached are two patches to address both points. Comments are\\n> welcome.\\n>\\n> Thanks,\\n>\\n> [1]: https://www.postgresql.org/message-id/20200529005559.jl2gsolomyro4l4n@alap3.anarazel.de\\n> --\\n> Michael\\n\\n\\n\\n\",\n \"msg_date\": \"Wed, 3 Jun 2020 22:10:21 +0900\",\n \"msg_from\": \"\\\"Inoue, Hiroshi\\\" <h-inoue@dream.email.ne.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 2020-06-03 11:14:48 +0900, Michael Paquier wrote:\\n> I would like to remove those two functions and the surrounding code\\n> for v14, leading to some cleanup:\\n> 6 files changed, 326 deletions(-)\\n\\n+1\\n\\n\\n> While on it, I have noticed that heap_get_latest_tid() is still\\n> located within heapam.c, but we can just move it within\\n> heapam_handler.c.\\n\\nWhat's the point of that change? I think the differentiation between\\nheapam_handler.c and heapam.c could be clearer, but if anything, I'd\\nargue that heap_get_latest_tid is sufficiently low-level that it'd\\nbelong in heapam.c.\\n\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n\",\n \"msg_date\": \"Thu, 4 Jun 2020 10:59:05 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Thu, Jun 04, 2020 at 10:59:05AM -0700, Andres Freund wrote:\\n> What's the point of that change? I think the differentiation between\\n> heapam_handler.c and heapam.c could be clearer, but if anything, I'd\\n> argue that heap_get_latest_tid is sufficiently low-level that it'd\\n> belong in heapam.c.\\n\\nWell, heap_get_latest_tid() is only called in heapam_handler.c if\\nanything, as it is not used elsewhere and not publish it. And IMO we\\nshould try to encourage using table_get_latest_tid() instead if some\\nplugins need that. Anyway, if you are opposed to this change, I won't\\npush hard for it either.\\n--\\nMichael\",\n \"msg_date\": \"Fri, 5 Jun 2020 15:07:34 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 03, 2020 at 10:10:21PM +0900, Inoue, Hiroshi wrote:\\n> On 2020/06/03 11:14, Michael Paquier wrote:\\n>> I have been looking at the ODBC driver and the need for currtid() as\\n>> well as currtid2(), and as mentioned already in [1], matching with my\\n>> lookup of things, these are actually not needed by the driver as long\\n>> as we connect to a server newer than 8.2 able to support RETURNING.\\n> \\n> Though currtid2() is necessary even for servers which support RETURNING,\\n> I don't object to remove it.\\n\\nIn which cases is it getting used then? From what I can see there is\\nzero coverage for that part in the tests. And based on a rough read\\nof the code, this would get called with LATEST_TUPLE_LOAD being set,\\nwhere there is some kind of bulk deletion involved. Couldn't that be\\na problem?\\n--\\nMichael\",\n \"msg_date\": \"Fri, 5 Jun 2020 15:22:28 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On 2020/06/05 15:22, Michael Paquier wrote:\\n> On Wed, Jun 03, 2020 at 10:10:21PM +0900, Inoue, Hiroshi wrote:\\n>> On 2020/06/03 11:14, Michael Paquier wrote:\\n>>> I have been looking at the ODBC driver and the need for currtid() as\\n>>> well as currtid2(), and as mentioned already in [1], matching with my\\n>>> lookup of things, these are actually not needed by the driver as long\\n>>> as we connect to a server newer than 8.2 able to support RETURNING.\\n>> Though currtid2() is necessary even for servers which support RETURNING,\\n>> I don't object to remove it.\\n> In which cases is it getting used then?\\n\\nKeyset-driven cursors always detect changes made by other applications\\n(and themselves). currtid() is necessary to detect the changes.\\nCTIDs are changed by updates unfortunately.\\n\\nregards,\\nHiroshi Inoue\\n\\n> From what I can see there is\\n> zero coverage for that part in the tests. And based on a rough read\\n> of the code, this would get called with LATEST_TUPLE_LOAD being set,\\n> where there is some kind of bulk deletion involved. Couldn't that be\\n> a problem?\\n> --\\n> Michael\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nOn 2020/06/05 15:22, Michael Paquier\\n wrote:\\n\\n\\nOn Wed, Jun 03, 2020 at 10:10:21PM +0900, Inoue, Hiroshi wrote:\\n\\n\\nOn 2020/06/03 11:14, Michael Paquier wrote:\\n\\n\\nI have been looking at the ODBC driver and the need for currtid() as\\nwell as currtid2(), and as mentioned already in [1], matching with my\\nlookup of things, these are actually not needed by the driver as long\\nas we connect to a server newer than 8.2 able to support RETURNING.\\n\\n\\n\\nThough currtid2() is necessary even for servers which support RETURNING,\\nI don't object to remove it.\\n\\n\\n\\nIn which cases is it getting used then?\\n\\n\\nKeyset-driven cursors always detect changes made by other\\n applications\\n (and themselves). currtid() is necessary to detect the changes.\\n CTIDs are changed by updates unfortunately.\\n\\n regards,\\n Hiroshi Inoue\\n\\n\\n\\n From what I can see there is\\nzero coverage for that part in the tests. And based on a rough read\\nof the code, this would get called with LATEST_TUPLE_LOAD being set,\\nwhere there is some kind of bulk deletion involved. Couldn't that be\\na problem?\\n--\\nMichael\",\n \"msg_date\": \"Fri, 5 Jun 2020 22:25:00 +0900\",\n \"msg_from\": \"\\\"Inoue, Hiroshi\\\" <h-inoue@dream.email.ne.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Fri, Jun 05, 2020 at 10:25:00PM +0900, Inoue, Hiroshi wrote:\\n> Keyset-driven cursors always detect changes made by other applications\\n> (and themselves). currtid() is necessary to detect the changes.\\n> CTIDs are changed by updates unfortunately.\\n\\nYou mean currtid2() here and not currtid(), right? We have two\\nproblems here then:\\n1) We cannot actually really remove currtid2() from the backend yet\\nwithout removing the dependency in the driver, or that may break some\\nusers.\\n2) The driver does not include tests for that stuff yet.\\n--\\nMichael\",\n \"msg_date\": \"Mon, 8 Jun 2020 15:52:41 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Sorry for the reply.\\n\\nOn 2020/06/08 15:52, Michael Paquier wrote:\\n> On Fri, Jun 05, 2020 at 10:25:00PM +0900, Inoue, Hiroshi wrote:\\n>> Keyset-driven cursors always detect changes made by other applications\\n>> (and themselves). currtid() is necessary to detect the changes.\\n>> CTIDs are changed by updates unfortunately.\\n> You mean currtid2() here and not currtid(), right?\\n\\nYes.\\n\\n> We have two\\n> problems here then:\\n> 1) We cannot actually really remove currtid2() from the backend yet\\n> without removing the dependency in the driver, or that may break some\\n> users.\\n\\nI think only ODBC driver uses currtid2().\\n\\n> 2) The driver does not include tests for that stuff yet.\\n\\nSQLSetPos(.., .., SQL_REFRESH, ..) call in positioned-update-test passes \\nthe stuff\\n �when 'Use Declare/Fetch' option is turned off. In other words, \\nkeyset-driven cursor\\nis not supported when 'Use Declare/Fetch' option is turned on. Probably \\nkeyset-driven\\ncursor support would be lost regardless of 'Use Declare/Fetch' option \\nafter the\\nremoval of currtid2().\\n\\n> --\\n> Michael\\n\\n\\n\\n\",\n \"msg_date\": \"Mon, 15 Jun 2020 20:50:23 +0900\",\n \"msg_from\": \"\\\"Inoue, Hiroshi\\\" <h-inoue@dream.email.ne.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Mon, Jun 15, 2020 at 08:50:23PM +0900, Inoue, Hiroshi wrote:\\n> Sorry for the reply.\\n\\nNo problem, thanks for taking the time.\\n\\n> On 2020/06/08 15:52, Michael Paquier wrote:\\n>> On Fri, Jun 05, 2020 at 10:25:00PM +0900, Inoue, Hiroshi wrote:\\n>> We have two\\n>> problems here then:\\n>> 1) We cannot actually really remove currtid2() from the backend yet\\n>> without removing the dependency in the driver, or that may break some\\n>> users.\\n> \\n> I think only ODBC driver uses currtid2().\\n\\nCheck. I think so too.\\n\\n>> 2) The driver does not include tests for that stuff yet.\\n> \\n> SQLSetPos(.., .., SQL_REFRESH, ..) call in positioned-update-test passes the\\n> stuff\\n> when 'Use Declare/Fetch' option is turned off. In other words,\\n> keyset-driven cursor\\n> is not supported when 'Use Declare/Fetch' option is turned on. Probably\\n> keyset-driven\\n> cursor support would be lost regardless of 'Use Declare/Fetch' option after\\n> the removal of currtid2().\\n\\nSorry, but I am not quite sure what is the relationship between\\nUseDeclareFetch and currtid2()? Is that related to the use of\\nSQL_CURSOR_KEYSET_DRIVEN? The only thing I can be sure of here is\\nthat we never call currtid2() in any of the regression tests present\\nin the ODBC code for any of the scenarios covered by installcheck-all,\\nso that does not really bring any confidence that removing currtid2()\\nis a wise thing to do, because we may silently break stuff. If the\\nfunction is used, it would be good to close the gap with a test to\\nstress that at least in the driver.\\n\\ncurrtid(), on the contrary, would be fine as far as I understand\\nbecause the ODBC code relies on a RETURNING ctid instead, and that's\\nsupported for ages in the Postgres backend.\\n--\\nMichael\",\n \"msg_date\": \"Tue, 23 Jun 2020 13:29:06 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Tue, Jun 23, 2020 at 01:29:06PM +0900, Michael Paquier wrote:\\n> Sorry, but I am not quite sure what is the relationship between\\n> UseDeclareFetch and currtid2()? Is that related to the use of\\n> SQL_CURSOR_KEYSET_DRIVEN? The only thing I can be sure of here is\\n> that we never call currtid2() in any of the regression tests present\\n> in the ODBC code for any of the scenarios covered by installcheck-all,\\n> so that does not really bring any confidence that removing currtid2()\\n> is a wise thing to do, because we may silently break stuff. If the\\n> function is used, it would be good to close the gap with a test to\\n> stress that at least in the driver.\\n\\nActually, while reviewing the code, the only code path where we use\\ncurrtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\\nonly location where this happens is in SC_pos_reload_with_key(), where\\nI don't actually see how it would be possible to not have a keyset and\\nstill use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\\ncould it be possible that the code paths of currtid2() are actually\\njust dead code?\\n--\\nMichael\",\n \"msg_date\": \"Tue, 23 Jun 2020 14:02:33 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Tue, Jun 23, 2020 at 02:02:33PM +0900, Michael Paquier wrote:\\n> Actually, while reviewing the code, the only code path where we use\\n> currtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\\n> only location where this happens is in SC_pos_reload_with_key(), where\\n> I don't actually see how it would be possible to not have a keyset and\\n> still use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\\n> could it be possible that the code paths of currtid2() are actually\\n> just dead code?\\n\\nI have dug more into this one, and we actually stressed this code path\\nquite a lot up to commit d9cb23f in the ODBC driver, with tests\\ncursor-block-delete, positioned-update and bulkoperations particularly\\nwhen calling SQLSetPos(). However, 86e2e7a has reworked the code in\\nsuch a way that we visibly don't use anymore CTIDs if we don't have a\\nkeyset, and that combinations of various options like UseDeclareFetch\\nor UpdatableCursors don't trigger this code path anymore. In short,\\ncurrtid2() does not get used. Inoue-san, Saito-san, what do you\\nthink? I am adding also Tsunakawa-san in CC who has some experience\\nin this area.\\n--\\nMichael\",\n \"msg_date\": \"Wed, 24 Jun 2020 11:11:10 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Hi Michael,\\n\\nWhere do you test, on Windows or on *nix?\\nHow do you test there?\\n\\nregards,\\nHiroshi Inoue\\n\\nOn 2020/06/24 11:11, Michael Paquier wrote:\\n> On Tue, Jun 23, 2020 at 02:02:33PM +0900, Michael Paquier wrote:\\n>> Actually, while reviewing the code, the only code path where we use\\n>> currtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\\n>> only location where this happens is in SC_pos_reload_with_key(), where\\n>> I don't actually see how it would be possible to not have a keyset and\\n>> still use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\\n>> could it be possible that the code paths of currtid2() are actually\\n>> just dead code?\\n> I have dug more into this one, and we actually stressed this code path\\n> quite a lot up to commit d9cb23f in the ODBC driver, with tests\\n> cursor-block-delete, positioned-update and bulkoperations particularly\\n> when calling SQLSetPos(). However, 86e2e7a has reworked the code in\\n> such a way that we visibly don't use anymore CTIDs if we don't have a\\n> keyset, and that combinations of various options like UseDeclareFetch\\n> or UpdatableCursors don't trigger this code path anymore. In short,\\n> currtid2() does not get used. Inoue-san, Saito-san, what do you\\n> think? I am adding also Tsunakawa-san in CC who has some experience\\n> in this area.\\n> --\\n> Michael\\n\\n\\n\\n\",\n \"msg_date\": \"Wed, 24 Jun 2020 17:20:42 +0900\",\n \"msg_from\": \"\\\"Inoue, Hiroshi\\\" <h-inoue@dream.email.ne.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Hi Inoue-san,\\n\\nOn Wed, Jun 24, 2020 at 05:20:42PM +0900, Inoue, Hiroshi wrote:\\n> Where do you test, on Windows or on *nix?\\n> How do you test there?\\n\\nI have been testing the driver on macos only, with various backend\\nversions, from 11 to 14.\\n\\nThanks,\\n--\\nMichael\",\n \"msg_date\": \"Wed, 24 Jun 2020 18:00:23 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nI seem to have invalidated KEYSET-DRIVEN cursors used in \\npositioned-update test .\\nIt was introduced by the commit 4a272fd but was invalidated by the \\ncommit 2be35a6.\\n\\nI don't object to the removal of currtid(2) because keyset-driven \\ncursors in psqlodbc are changed into static cursors in many cases and \\nI've hardly ever heard a complaint about it.\\n\\nregards,\\nHiroshi Inoue\\n\\nOn 2020/06/24 11:11, Michael Paquier wrote:\\n> On Tue, Jun 23, 2020 at 02:02:33PM +0900, Michael Paquier wrote:\\n>> Actually, while reviewing the code, the only code path where we use\\n>> currtid2() involves positioned_load() and LATEST_TUPLE_LOAD. And the\\n>> only location where this happens is in SC_pos_reload_with_key(), where\\n>> I don't actually see how it would be possible to not have a keyset and\\n>> still use a CTID, which would led to LATEST_TUPLE_LOAD being used. So\\n>> could it be possible that the code paths of currtid2() are actually\\n>> just dead code?\\n> I have dug more into this one, and we actually stressed this code path\\n> quite a lot up to commit d9cb23f in the ODBC driver, with tests\\n> cursor-block-delete, positioned-update and bulkoperations particularly\\n> when calling SQLSetPos(). However, 86e2e7a has reworked the code in\\n> such a way that we visibly don't use anymore CTIDs if we don't have a\\n> keyset, and that combinations of various options like UseDeclareFetch\\n> or UpdatableCursors don't trigger this code path anymore. In short,\\n> currtid2() does not get used. Inoue-san, Saito-san, what do you\\n> think? I am adding also Tsunakawa-san in CC who has some experience\\n> in this area.\\n> --\\n> Michael\\n\\n\\n\\n\",\n \"msg_date\": \"Thu, 25 Jun 2020 22:14:00 +0900\",\n \"msg_from\": \"\\\"Inoue, Hiroshi\\\" <h-inoue@dream.email.ne.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Thu, Jun 25, 2020 at 10:14:00PM +0900, Inoue, Hiroshi wrote:\\n> I seem to have invalidated KEYSET-DRIVEN cursors used in positioned-update\\n> test. It was introduced by the commit 4a272fd but was invalidated by the\\n> commit 2be35a6.\\n> \\n> I don't object to the removal of currtid(2) because keyset-driven cursors in\\n> psqlodbc are changed into static cursors in many cases and I've hardly ever\\n> heard a complaint about it.\\n\\nHmm. I am not sure that this completely answers my original concern\\nthough. In short, don't we still have corner cases where\\nkeyset-driven cursors are not changed into static cursors, meaning\\nthat currtid2() could get used? The removal of the in-core functions\\nwould hurt applications using that, meaning that we should at least\\nprovide an equivalent of currtid2() in the worse case as a contrib\\nmodule, no? If the code paths of currtid2() are reachable, shouldn't\\nwe also make sure that they are still reached in the regression tests\\nof the driver, meaning that the driver code needs more coverage? I\\nhave been looking at the tests and tried to tweak them using\\nSQLSetPos() so as the code paths involving currtid2() get reached, but \\nI am not really able to do so. It does not mean that that currtid2()\\nnever gets reached, it just means that I am not able to be sure that\\nthis part can be safely removed from the Postgres backend code :( \\n\\nFrom what I can see on this thread, we could just remove currtid() per\\nthe arguments of the RETURNING ctid clause supported since PG 8.2, but\\nit would make more sense to me to just remove both currtid/currtid2()\\nat once.\\n--\\nMichael\",\n \"msg_date\": \"Fri, 26 Jun 2020 13:11:55 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Fri, Jun 26, 2020 at 01:11:55PM +0900, Michael Paquier wrote:\\n> From what I can see on this thread, we could just remove currtid() per\\n> the arguments of the RETURNING ctid clause supported since PG 8.2, but\\n> it would make more sense to me to just remove both currtid/currtid2()\\n> at once.\\n\\nThe CF bot is complaining, so here is a rebase for the main patch.\\nOpinions are welcome about the arguments of upthread.\\n--\\nMichael\",\n \"msg_date\": \"Thu, 3 Sep 2020 19:14:15 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On 2020-09-03 12:14, Michael Paquier wrote:\\n> On Fri, Jun 26, 2020 at 01:11:55PM +0900, Michael Paquier wrote:\\n>> From what I can see on this thread, we could just remove currtid() per\\n>> the arguments of the RETURNING ctid clause supported since PG 8.2, but\\n>> it would make more sense to me to just remove both currtid/currtid2()\\n>> at once.\\n> \\n> The CF bot is complaining, so here is a rebase for the main patch.\\n> Opinions are welcome about the arguments of upthread.\\n\\nIt appears that currtid2() is still used, so we ought to keep it.\\n\\n\\n\",\n \"msg_date\": \"Fri, 20 Nov 2020 16:14:49 +0100\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Peter Eisentraut <peter.eisentraut@enterprisedb.com> writes:\\n> On 2020-09-03 12:14, Michael Paquier wrote:\\n>> Opinions are welcome about the arguments of upthread.\\n\\n> It appears that currtid2() is still used, so we ought to keep it.\\n\\nYeah, if pgODBC were not using it at all then I think it'd be fine\\nto get rid of, but if it still contains calls then we cannot.\\nThe suggestion upthread that those calls might be unreachable\\nis interesting, but it seems unproven.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Fri, 20 Nov 2020 11:53:11 -0500\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Fri, Nov 20, 2020 at 11:53:11AM -0500, Tom Lane wrote:\\n> Yeah, if pgODBC were not using it at all then I think it'd be fine\\n> to get rid of, but if it still contains calls then we cannot.\\n> The suggestion upthread that those calls might be unreachable\\n> is interesting, but it seems unproven.\\n\\nYeah, I am not 100% sure that there are no code paths calling\\ncurrtid2(), and the ODBC is too obscure to me to get to a clear\\nconclusion. currtid() though, is a different deal thanks to\\nRETURNING. What about cutting the cake in two and just remove\\ncurrtid() then?\\n--\\nMichael\",\n \"msg_date\": \"Sat, 21 Nov 2020 10:12:09 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael@paquier.xyz> writes:\\n> What about cutting the cake in two and just remove\\n> currtid() then?\\n\\n+1. That'd still let us get rid of setLastTid() which is\\nthe ugliest part of the thing, IMO.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Fri, 20 Nov 2020 21:50:08 -0500\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Fri, Nov 20, 2020 at 09:50:08PM -0500, Tom Lane wrote:\\n> Michael Paquier <michael@paquier.xyz> writes:\\n>> What about cutting the cake in two and just remove\\n>> currtid() then?\\n> \\n> +1. That'd still let us get rid of setLastTid() which is\\n> the ugliest part of the thing, IMO.\\n\\nIndeed, this could go. There is a recursive call for views, but in\\norder to maintain compatibility with that we can just remove one\\nfunction and move the second to use a regclass as argument, like the\\nattached, while removing setLastTid(). Any thoughts?\\n--\\nMichael\",\n \"msg_date\": \"Sat, 21 Nov 2020 14:45:30 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael@paquier.xyz> writes:\\n> Indeed, this could go. There is a recursive call for views, but in\\n> order to maintain compatibility with that we can just remove one\\n> function and move the second to use a regclass as argument, like the\\n> attached, while removing setLastTid(). Any thoughts?\\n\\nConsidering that we're preserving this only for backwards compatibility,\\nI doubt that changing the signature is a good idea. It maybe risks\\nbreaking something, and the ODBC driver is hardly going to notice\\nany improved ease-of-use.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Sat, 21 Nov 2020 13:13:35 -0500\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\n+1 for getting rid of whatever we can without too much trouble.\\n\\nOn 2020-11-21 13:13:35 -0500, Tom Lane wrote:\\n> Michael Paquier <michael@paquier.xyz> writes:\\n> > Indeed, this could go. There is a recursive call for views, but in\\n> > order to maintain compatibility with that we can just remove one\\n> > function and move the second to use a regclass as argument, like the\\n> > attached, while removing setLastTid(). Any thoughts?\\n> \\n> Considering that we're preserving this only for backwards compatibility,\\n> I doubt that changing the signature is a good idea. It maybe risks\\n> breaking something, and the ODBC driver is hardly going to notice\\n> any improved ease-of-use.\\n\\n+1.\\n\\nRegards,\\n\\nAndres\\n\\n\\n\",\n \"msg_date\": \"Sat, 21 Nov 2020 10:33:58 -0800\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Sat, Nov 21, 2020 at 01:13:35PM -0500, Tom Lane wrote:\\n> Considering that we're preserving this only for backwards compatibility,\\n> I doubt that changing the signature is a good idea. It maybe risks\\n> breaking something, and the ODBC driver is hardly going to notice\\n> any improved ease-of-use.\\n\\nSo, what you are basically saying is to switch currtid_byreloid() to\\nbecome a function local to tid.c. And then have just\\ncurrtid_byrelname() and currtid_for_view() call that, right?\\n--\\nMichael\",\n \"msg_date\": \"Sun, 22 Nov 2020 11:09:32 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael@paquier.xyz> writes:\\n> So, what you are basically saying is to switch currtid_byreloid() to\\n> become a function local to tid.c. And then have just\\n> currtid_byrelname() and currtid_for_view() call that, right?\\n\\nYeah, that sounds about right.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n\",\n \"msg_date\": \"Sat, 21 Nov 2020 21:39:28 -0500\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Sat, Nov 21, 2020 at 09:39:28PM -0500, Tom Lane wrote:\\n> Michael Paquier <michael@paquier.xyz> writes:\\n>> So, what you are basically saying is to switch currtid_byreloid() to\\n>> become a function local to tid.c. And then have just\\n>> currtid_byrelname() and currtid_for_view() call that, right?\\n> \\n> Yeah, that sounds about right.\\n\\nOkay, here you go with the attached. If there are any other comments,\\nplease feel free.\\n--\\nMichael\",\n \"msg_date\": \"Sun, 22 Nov 2020 20:11:21 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n },\n {\n \"msg_contents\": \"On Sun, Nov 22, 2020 at 08:11:21PM +0900, Michael Paquier wrote:\\n> Okay, here you go with the attached. If there are any other comments,\\n> please feel free.\\n\\nHearing nothing, applied this one after going through the ODBC driver\\ncode again this morning. Compatibility is exactly the same for\\ncurrtid2(), while currtid() is now gone.\\n--\\nMichael\",\n \"msg_date\": \"Wed, 25 Nov 2020 12:21:57 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Removal of currtid()/currtid2() and some table AM cleanup\"\n }\n]","isConversational":false}}},{"rowIdx":50399,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi all,\n\nI have bumped into $subject, causing a replica identity index to\nbe considered as dropped if running REINDEX CONCURRENTLY on it. This\nmeans that the old tuple information would get lost in this case, as\na REPLICA IDENTITY USING INDEX without a dropped index is the same as\nNOTHING.\n\nAttached is a fix for this issue, that needs a backpatch down to 12.\nThanks,\n--\nMichael","msg_date":"Wed, 3 Jun 2020 15:53:40 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"REINDEX CONCURRENTLY and indisreplident"},{"msg_contents":"On Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:\n\n> Hi all,\n>\n> I have bumped into $subject, causing a replica identity index to\n> be considered as dropped if running REINDEX CONCURRENTLY on it. This\n> means that the old tuple information would get lost in this case, as\n> a REPLICA IDENTITY USING INDEX without a dropped index is the same as\n> NOTHING.\n>\n> LGTM. I tested in both versions (12, master) and it works accordingly.\n\n\n-- \nEuler Taveira http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\nOn Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:Hi all,\n\nI have bumped into $subject, causing a replica identity index to\nbe considered as dropped if running REINDEX CONCURRENTLY on it. This\nmeans that the old tuple information would get lost in this case, as\na REPLICA IDENTITY USING INDEX without a dropped index is the same as\nNOTHING.\nLGTM. I tested in both versions (12, master) and it works accordingly.-- Euler Taveira http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services","msg_date":"Wed, 3 Jun 2020 12:40:38 -0300","msg_from":"Euler Taveira <euler.taveira@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: REINDEX CONCURRENTLY and indisreplident"},{"msg_contents":"On Wed, Jun 03, 2020 at 12:40:38PM -0300, Euler Taveira wrote:\n> On Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:\n>> I have bumped into $subject, causing a replica identity index to\n>> be considered as dropped if running REINDEX CONCURRENTLY on it. This\n>> means that the old tuple information would get lost in this case, as\n>> a REPLICA IDENTITY USING INDEX without a dropped index is the same as\n>> NOTHING.\n>\n> LGTM. I tested in both versions (12, master) and it works accordingly.\n\nThanks for the review. I'll try to get that fixed soon.\n\nBy the way, your previous email was showing up as part of my own email\nwith the indentation that was used so I missed it first. That's the\ncase as well here:\nhttps://www.postgresql.org/message-id/CAH503wDaejzhP7+wA-hHS6c7NzE69oWqe5Zf_TYFu1epAwp6EQ@mail.gmail.com\n--\nMichael","msg_date":"Thu, 4 Jun 2020 11:23:36 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: REINDEX CONCURRENTLY and indisreplident"},{"msg_contents":"On Thu, Jun 04, 2020 at 11:23:36AM +0900, Michael Paquier wrote:\n> On Wed, Jun 03, 2020 at 12:40:38PM -0300, Euler Taveira wrote:\n> > On Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:\n> >> I have bumped into $subject, causing a replica identity index to\n> >> be considered as dropped if running REINDEX CONCURRENTLY on it. This\n> >> means that the old tuple information would get lost in this case, as\n> >> a REPLICA IDENTITY USING INDEX without a dropped index is the same as\n> >> NOTHING.\n> >\n> > LGTM. I tested in both versions (12, master) and it works accordingly.\n> \n> Thanks for the review. I'll try to get that fixed soon.\n\nApplied this one, just in time before the branching:\nhttps://www.postgresql.org/message-id/1931934b-09dc-e93e-fab9-78c5bc72743d@postgresql.org\n--\nMichael","msg_date":"Fri, 5 Jun 2020 11:04:39 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":true,"msg_subject":"Re: REINDEX CONCURRENTLY and indisreplident"}],"string":"[\n {\n \"msg_contents\": \"Hi all,\\n\\nI have bumped into $subject, causing a replica identity index to\\nbe considered as dropped if running REINDEX CONCURRENTLY on it. This\\nmeans that the old tuple information would get lost in this case, as\\na REPLICA IDENTITY USING INDEX without a dropped index is the same as\\nNOTHING.\\n\\nAttached is a fix for this issue, that needs a backpatch down to 12.\\nThanks,\\n--\\nMichael\",\n \"msg_date\": \"Wed, 3 Jun 2020 15:53:40 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"REINDEX CONCURRENTLY and indisreplident\"\n },\n {\n \"msg_contents\": \"On Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:\\n\\n> Hi all,\\n>\\n> I have bumped into $subject, causing a replica identity index to\\n> be considered as dropped if running REINDEX CONCURRENTLY on it. This\\n> means that the old tuple information would get lost in this case, as\\n> a REPLICA IDENTITY USING INDEX without a dropped index is the same as\\n> NOTHING.\\n>\\n> LGTM. I tested in both versions (12, master) and it works accordingly.\\n\\n\\n-- \\nEuler Taveira http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\nOn Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:Hi all,\\n\\nI have bumped into $subject, causing a replica identity index to\\nbe considered as dropped if running REINDEX CONCURRENTLY on it. This\\nmeans that the old tuple information would get lost in this case, as\\na REPLICA IDENTITY USING INDEX without a dropped index is the same as\\nNOTHING.\\nLGTM. I tested in both versions (12, master) and it works accordingly.-- Euler Taveira http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\",\n \"msg_date\": \"Wed, 3 Jun 2020 12:40:38 -0300\",\n \"msg_from\": \"Euler Taveira <euler.taveira@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: REINDEX CONCURRENTLY and indisreplident\"\n },\n {\n \"msg_contents\": \"On Wed, Jun 03, 2020 at 12:40:38PM -0300, Euler Taveira wrote:\\n> On Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:\\n>> I have bumped into $subject, causing a replica identity index to\\n>> be considered as dropped if running REINDEX CONCURRENTLY on it. This\\n>> means that the old tuple information would get lost in this case, as\\n>> a REPLICA IDENTITY USING INDEX without a dropped index is the same as\\n>> NOTHING.\\n>\\n> LGTM. I tested in both versions (12, master) and it works accordingly.\\n\\nThanks for the review. I'll try to get that fixed soon.\\n\\nBy the way, your previous email was showing up as part of my own email\\nwith the indentation that was used so I missed it first. That's the\\ncase as well here:\\nhttps://www.postgresql.org/message-id/CAH503wDaejzhP7+wA-hHS6c7NzE69oWqe5Zf_TYFu1epAwp6EQ@mail.gmail.com\\n--\\nMichael\",\n \"msg_date\": \"Thu, 4 Jun 2020 11:23:36 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: REINDEX CONCURRENTLY and indisreplident\"\n },\n {\n \"msg_contents\": \"On Thu, Jun 04, 2020 at 11:23:36AM +0900, Michael Paquier wrote:\\n> On Wed, Jun 03, 2020 at 12:40:38PM -0300, Euler Taveira wrote:\\n> > On Wed, 3 Jun 2020 at 03:54, Michael Paquier <michael@paquier.xyz> wrote:\\n> >> I have bumped into $subject, causing a replica identity index to\\n> >> be considered as dropped if running REINDEX CONCURRENTLY on it. This\\n> >> means that the old tuple information would get lost in this case, as\\n> >> a REPLICA IDENTITY USING INDEX without a dropped index is the same as\\n> >> NOTHING.\\n> >\\n> > LGTM. I tested in both versions (12, master) and it works accordingly.\\n> \\n> Thanks for the review. I'll try to get that fixed soon.\\n\\nApplied this one, just in time before the branching:\\nhttps://www.postgresql.org/message-id/1931934b-09dc-e93e-fab9-78c5bc72743d@postgresql.org\\n--\\nMichael\",\n \"msg_date\": \"Fri, 5 Jun 2020 11:04:39 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: REINDEX CONCURRENTLY and indisreplident\"\n }\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":503,"numItemsPerPage":100,"numTotalItems":58371,"offset":50300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MDg5NzU0OSwic3ViIjoiL2RhdGFzZXRzL3dhbnNoZW5sL3Bnc3FsLWhhY2tlcnMiLCJleHAiOjE3ODA5MDExNDksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.xoTnamodLTZtWHworrC2UtRagICmRYP0PgHIYkou8R1vnAdL5_S5TED_s8Mk2bNWmmZCnoe_moer4svP9oHRAA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":58371,"numBytesParquet":368254123}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
threads listlengths 1 2.99k |
|---|
[
{
"msg_contents": "Hi:\n\nWhen I run make -C subscription check, then I see the following logs\nin ./tmp_check/log/013_partition_publisher.log\n\n2020-05-11 09:37:40.778 CST [69541] sub_viaroot WARNING: terminating\nconnection because of crash of another server process\n\n2020-05-11 09:37:40.778 CST [69541] s... |
[
{
"msg_contents": "Hi,\n\nAttached is a draft of the press release for the 2020-05-14 cumulative\nupdate. Please let me know your feedback by 2020-05-13 :)\n\nThanks,\n\nJonathan",
"msg_date": "Sun, 10 May 2020 22:08:46 -0400",
"msg_from": "\"Jonathan S. Katz\" <jkatz@postgresql.org>",
"msg_from_op"... |
[
{
"msg_contents": "Hello hackers,\r\n\r\nI am researching about 'origin' in PostgreSQL, mainly it used in logical\r\ndecoding to filter transaction from non-local source. I notice that the\r\n'origin' is stored in commit_ts so that I think we are possible to get 'origin'\r\nof a transaction from commit_ts.\r\n\... |
[
{
"msg_contents": "Hello\n\nPer discussion in thread [1], I propose the following patch to give\nanother adjustment to the xlogreader API. This results in a small but\nnot insignificat net reduction of lines of code. What this patch does\nis adjust the signature of these new xlogreader callbacks, making the\n... |
[
{
"msg_contents": "There are a couple of things left to do yet:\n\n* Collapse temporary OID assignments down to the permanent range.\nAFAICS there's no reason to delay this step any longer, since there\naren't any open issues that seem likely to touch the catalog data.\n\n* In recent years we've usually done a ... |
[
{
"msg_contents": "Hello.\n\nThere is a recent commit about changes in way read-only commands are\nprevented to be executed [1].\n\nIt seems like hs_standby_disallowed test is broken now.\n\nSo, a simple patch to fix the test is attached.\n\nThanks,\nMichail.\n\n[1] https://www.postgresql.org/message-id/flat/15... |
[
{
"msg_contents": "Skimming through the code in event_trigger.c and noticed that while most of\nthe stanzas that reference IsUnderPostmaster refer back to the code comment\nbeginning on line 675 the block for table rewrite copied it in\nverbatim starting at line 842. The currentEventTriggerState comment at\nli... |
[
{
"msg_contents": "Hello hackers,\n\n1. StartupXLOG() does fsync on the whole data directory early in the crash\nrecovery. I'm wondering if we could skip some directories (at least the\npg_log/, table directories) since wal, etc could ensure consistency. Here\nis the related code.\n\n if (ControlFile->stat... |
[
{
"msg_contents": "Hi,\n\nWhen we run prepared statements, as far as I know, running\nEXPLAIN is the only way to know whether executed plans are\ngeneric or custom.\nThere seems no way to know how many times a prepared\nstatement was executed as generic and custom.\n\nI think it may be useful to record the numb... |
[
{
"msg_contents": "Rebased onto current master (fb544735f1).\n\n-- \nAndrey Lepikhov\nPostgres Professional\nhttps://postgrespro.com\nThe Russian Postgres Company",
"msg_date": "Tue, 12 May 2020 15:24:18 +0500",
"msg_from": "Andrey Lepikhov <a.lepikhov@postgrespro.ru>",
"msg_from_op": true,
"msg... |
[
{
"msg_contents": "I was doing some memory testing under fractional CPU allocations and it became\npainfully obvious that the repeat() function needs CHECK_FOR_INTERRUPTS().\n\nI exchanged a few emails offlist with Tom about it, and (at the risk of putting\nwords in his mouth) he agreed and felt it was a candid... |
[
{
"msg_contents": "I've been trying to reformat table 27.4 (wait events) to fit\ninto PDF output, which has caused me to study its contents\nmore than I ever had before. The lack of consistency, or\neven any weak attempt at consistency, is not just glaring;\nit's embarrassing.\n\nWe have a lot of wait event na... |
[
{
"msg_contents": "I happened to come across this code added by 28cac71bd:\n\nstatic PgStat_MsgSLRU *\nslru_entry(SlruCtl ctl)\n{\n int idx = pgstat_slru_index(ctl->shared->lwlock_tranche_name);\n\n Assert((idx >= 0) && (idx < SLRU_NUM_ELEMENTS));\n\n return &SLRUStats[idx];\n}\n\nwhich is invok... |
[
{
"msg_contents": "Hi,\n\npgstat_read_statsfiles() sets each stat_reset_timestamp to\nthe current timestamp, at the beginning of the function,\njust in case we fail to load the existing statsfile. This code is\noriginally introduced by commit 4c468b37a2.\n\nBut commit ad1b5c842b changed pgstat_read_statsfiles()... |
[
{
"msg_contents": "Hi,\n\nWhen track_io_timing is on, I/O timing information is\ndisplayed in pg_stat_database, in the output of EXPLAIN\nwhen the BUFFERS option is used, and in pg_stat_statements\nas documented in [1].\n\nThis is also described in the manual for pg_stat_statements\n[2], however, manuals for pg... |
[
{
"msg_contents": "I read about the utility – https://github.com/dataegret/pgcompacttable . It\nis more careful about resources, because it works on slightly different\nprinciples. The main point of pgcompacttable is that it moves all live rows\nto the beginning of the table with updates in the table. And then ... |
[
{
"msg_contents": "The comment which refers to the OpenSSL PEM password callback type has a small\ntypo, the type is called pem_password_cb and not pem_passwd_cb (which is an\neasy typo to make to make since confusingly enough the functions in OpenSSL are\ncalled SSL_*_passwd_cb). PFA patch to fix this.\n\nche... |
[
{
"msg_contents": "Reviewing TLS changes for v13 I came across one change which I think might be\nbetter off with a library qualified name. The libpq frontend sslpassword hook\nadded in 4dc63552109f65 is OpenSSL specific, but it has a very generic name:\n\n\tPQsetSSLKeyPassHook(PQsslKeyPassHook_type hook);\n\n... |
[
{
"msg_contents": "Hi,\nItemPointerData, on the contrary, from what the name says,\nit is not a pointer to a structure, but a structure in fact.\nWhen assigning the name of the structure variable to a pointer, it may even\nwork,\nbut, it is not the right thing to do and it becomes a nightmare,\nto discover that... |
[
{
"msg_contents": "Hi,\n\nI've attached the patch for $subject. The old comment seems to be\nborrowed from WalSndShmemInit().\n\nRegards,\n\n-- \nMasahiko Sawada http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services",
"msg_date": "Fri, 15 May 2020 12:4... |
[
{
"msg_contents": "Hi,\n\nI have just noticed that pg_bsd_indent complains since\n-Wimplicit-fallthrough=3 has been added to the default set of switches\nif available.\n\nSomething like the attached is fine to take care of those warnings,\nbut what's our current patching policy for this tool?\n\nThanks,\n--\nMi... |
[
{
"msg_contents": "Hi,\n\nAs discussed in the thread that introduced d140f2f3 to rename\nreceivedUpto to flushedUpto and add writtenUpto to the WAL receiver's\nshared memory information, the equivalent columns in\npg_stat_wal_receiver have not been renamed:\nhttps://www.postgresql.org/message-id/CA+hUKGJ06d3h5J... |
[
{
"msg_contents": "Hi Postgres Hackers,\n\nI am wondering is there any elegant way for self-spawned background process\n(forked by us) to get notified when the regular client-connected process\nexit from the current database (switch db or even terminate)?\n\nThe background is that we are integrating a thread-mo... |
[
{
"msg_contents": "Hey,\n\nSo I'm new to poking around in the PostgreSQL code, so this is a bit of\na shot in the dark. I'm having some problems with pg_dump, and a\ndatabase with tablespaces. A couple of the tables are not in the default\ntablespace, and I want to ignore this for the dump.\n\nLooking at the pg... |
[
{
"msg_contents": "The attached patch implements NSS (Network Security Services) [0] with the\nrequired NSPR runtime [1] as a TLS backend for PostgreSQL.\n\nWhile all sslmodes are implemented and work for the most part, the patch is\n*not* ready yet but I wanted to show progress early so that anyone interested\... |
[
{
"msg_contents": "\nAs I was resuscitating my buildfarm animal lousyjack, which runs tests\nunder valgrind, I neglected to turn off force_parallel=regress in the\nconfiguration settings. The results were fairly disastrous. The runs\ntook about 4 times as long, and some steps failed. I'm not sure if this\nis a ... |
[
{
"msg_contents": "If pg_dump can't seek on its output stream when writing a dump in the\ncustom archive format (possibly because you piped its stdout to a file)\nit can't update that file with data offsets. These files will often\nbreak parallel restoration. Warn when the user is doing pg_restore on\nsuch a fi... |
[
{
"msg_contents": "I'm the creator of the PostgreSQL driver pgx (https://github.com/jackc/pgx)\nfor the Go language. I have found significant performance advantages to\nusing the extended protocol and binary format values -- in particular for\ntypes such as timestamptz.\n\nHowever, I was recently very surprised... |
[
{
"msg_contents": "Hi hackers,\n\nAttached is a small patch for adding \"edit-and-execute-command\" readline \nsupport to psql. Bash has this concept and I miss it when using psql. It \nallows you to amend the current line in an editor by pressing \"v\" (when \nin vi mode) or \"C-x C-e\" (when in emacs mode). T... |
[
{
"msg_contents": "Hello:\n\nBefore I want to pay attention to some optimizer features, I want to\nestimate how much benefits it can create for customers, at least for our\ncurrent\nrunning customer. So I want to have some basic idea what kind of the query\nis\nrunning now in respect of optimizer.\n\n\nMy basic... |
[
{
"msg_contents": "Attached diff fixes two small typos in the optimizer README.\n\ncheers ./daniel",
"msg_date": "Mon, 18 May 2020 11:31:14 +0200",
"msg_from": "Daniel Gustafsson <daniel@yesql.se>",
"msg_from_op": true,
"msg_subject": "Optimizer docs typos"
},
{
"msg_contents": "On Mon, ... |
[
{
"msg_contents": "The syntax for FETCH FIRST allows the <fetch first quantity> to be\nabsent (implying 1).\n\nWe implement this correctly for ONLY, but WITH TIES didn't get the memo.\n\nPatch attached.\n-- \nVik Fearing",
"msg_date": "Mon, 18 May 2020 16:41:23 +0200",
"msg_from": "Vik Fearing <vik@post... |
[
{
"msg_contents": "There have been occasional discussions about deprecating or phasing out \npostfix operators, to make various things easier in the parser.\n\nThe first step would in any case be to provide alternatives for the \nexisting postfix operators. There is currently one, namely the numeric \nfactoria... |
[
{
"msg_contents": "Unless I'm missing something, the g_comment_start and g_comment_end variables\nin pg_dump.c seems to have been unused since 30ab5bd43d8f2082659191 (in the 7.2\ncycle) and can probably be safely removed by now. The attached passes make\ncheck.\n\ncheers ./daniel",
"msg_date": "Mon, 18 May... |
[
{
"msg_contents": "Hi\n\nLast week I played with dbms_sql extension and some patterns of usage\ncursor in PL/SQL and PL/pgSQL. I found fact, so iteration over cursor (FOR\nstatement) doesn't support unbound cursors. I think so this limit is not\nnecessary. This statement can open portal for bound cursor or can ... |
[
{
"msg_contents": "Hi\n\nI am a member of a small UK based team with extensive database experience. We are considering a project using PostgresSQL source code which only uses the insert data capabilities.\n\nIs there a contact who we could speak with and discuss our project aims in principal.\n\nThanks\n\nLuke\... |
[
{
"msg_contents": "Hi,\n\nAttached is a draft of the release announcement for the PostgreSQL 13\nBeta 1 release this week.\n\nThe goal of this release announcement is to make people aware of the new\nfeatures that are introduced in PostgreSQL 13 and, importantly, get them\nto start testing. I have tried to incl... |
[
{
"msg_contents": "Hi,\n\nI noticed that if a row level policy is defined on an extension\nobject, even in the extension creation script, pg_dump dumps a\nseparate CREATE POLICY statement for such policies. That makes the\ndump unrestorable because the CREATE EXTENSION and CREATE POLICY then\nconflicts.\n\nHere... |
[
{
"msg_contents": "Here is a series of patches to do some refactoring in the grammar around \nthe commands COMMENT, DROP, SECURITY LABEL, and ALTER EXTENSION ... \nADD/DROP. In the grammar, these commands (with some exceptions) \nbasically just take a reference to an object and later look it up in C \ncode. S... |
[
{
"msg_contents": "Hi all,\n\nWhile digging into my backlog, I have found this message from Peter E\nmentioning about $subject:\nhttps://www.postgresql.org/message-id/e6aac026-174c-9952-689f-6bee76f9ab68@2ndquadrant.com\n\nIt seems to me that it would be a good idea to make those checks more\nconsistent, and at... |
[
{
"msg_contents": "Since commit 74a308cf5221f we use explicit_bzero on pgpass and connhost\npassword in libpq, but not sslpassword which seems an oversight. The attached\nperforms an explicit_bzero before freeing like the pattern for other password\nvariables.\n\ncheers ./daniel",
"msg_date": "Tue, 19 May ... |
[
{
"msg_contents": "Definition of pg_atomic_compare_exchange_u64 requires alignment of \nexpected pointer on 8-byte boundary.\n\npg_atomic_compare_exchange_u64(volatile pg_atomic_uint64 *ptr,\n uint64 *expected, uint64 newval)\n{\n#ifndef PG_HAVE_ATOMIC_U64_SIMULATION\n AssertP... |
[
{
"msg_contents": "Hi,\n\nI've been running some TPC-H benchmarks on master, to check if there's\nsomething unexpected, and I ran into some annoying issues with Q17 and\nQ20. I'll use Q17 as it's a bit simpler.\n\nI think there are two related problem - with costing and with excessive\nI/O due to using logical ... |
[
{
"msg_contents": "Hello hackers,\n\nParallel sequential scan relies on the kernel detecting sequential\naccess, but we don't make the job easy. The resulting striding\npattern works terribly on strict next-block systems like FreeBSD UFS,\nand degrades rapidly when you add too many workers on sliding window\ns... |
[
{
"msg_contents": "Hello,\n\nI've discovered something today that I didn't really expect. When a user\ndumps a database with the --schema flag of pg_dump, extensions in this\nschema aren't dumped. As far as I can tell, the documentation isn't clear\nabout this (\"Dump only schemas matching pattern; this selects... |
[
{
"msg_contents": "If I run pgindent on a built tree on macos, I get this error\n\nFailure in ./src/backend/utils/probes.h: Error@375: Stuff missing from \nend of file\n\nThe file in question is built by the dtrace command. I have attached it \nhere.\n\nIs this something to fix in pgindent? Or should this fil... |
[
{
"msg_contents": "The following documentation comment has been logged on the website:\n\nPage: https://www.postgresql.org/docs/12/tutorial-join.html\nDescription:\n\nThe tutorial about joins makes the following statement about the explicit\nJOIN operator:\r\n\r\n> This syntax is not as commonly used as the one... |
[
{
"msg_contents": "Hackers,\n\nOver on [1], Heikki mentioned about the usefulness of caching results\nfrom parameterized subplans so that they could be used again for\nsubsequent scans which have the same parameters as a previous scan.\nOn [2], I mentioned that parameterized nested loop joins could see\nsimilar... |
[
{
"msg_contents": "I have implemented the SEARCH and CYCLE clauses.\n\nThis is standard SQL syntax attached to a recursive CTE to compute a \ndepth- or breadth-first ordering and cycle detection, respectively. \nThis is just convenience syntax for what you can already do manually. \nThe original discussion abou... |
[
{
"msg_contents": "Commit 911e7020770 added a variety of new support routines to index\nAMs. For example, it added a support function 5 to btree (see\nBTOPTIONS_PROC), but didn't document this alongside the other support\nfunctions in btree.sgml.\n\nIt looks like the new support functions are fundamentally diff... |
[
{
"msg_contents": "Hi Forum,\n If I have a cluster with Synchronous replication enabled with three nodes,\nfor eg:\n\n[primary] [hot stand by 1] [host stand by 2]\n\nAnd for some unforeseen reasons, if primary fails, the failover will kick\nin and hot stand by 1 will become new primary and cluster setup will l... |
[
{
"msg_contents": "Hi all,\n\nNormally $subject would have been discussed at the developer meeting\nin Ottawa, but that's not going to happen per the current situation.\n\nFor the last couple of years, we have been using the same timeline for\nfor commit fests in a development cycle, so why not going with the\n... |
[
{
"msg_contents": "Hello hackers!\n\nThis email is about the proposal to implement OLTP-oriented compression on PostgreSQL.\n\nAlthough there are currently some alternative ways to achieve compression, such as using a file system that supports compression.\nHowever, this depends on a specific file system and is... |
[
{
"msg_contents": "Hi,\n\nAttached is a patch to use perfect hashing to speed up Unicode\nnormalization quick check.\n\n0001 changes the set of multipliers attempted when generating the hash\nfunction. The set in HEAD works for the current set of NFC codepoints,\nbut not for the other types. Also, the updated m... |
[
{
"msg_contents": "Hi all,\n\nWhile working on some other logical decoding patch recently, I bumped\ninto the fact that we have special handling for the case of REPLICA\nIDENTITY USING INDEX when the dependent index is dropped, where the\ncode handles that case as an equivalent of NOTHING.\n\nAttached is a patc... |
[
{
"msg_contents": "Hi hackers,\n\nFor EXISTS SubLink, in some cases the subquery can be reduced to\nconstant TRUE or FALSE, based on the knowledge that it's being used in\nEXISTS(). One such case is when the subquery has aggregates without\nGROUP BY or HAVING, and we know its result is exactly one row, unless\n... |
[
{
"msg_contents": "Hi All,\n\nI am getting ERROR when using the \"FOR UPDATE\" clause for the partitioned\ntable. below is a reproducible test case for the same.\n\nCREATE TABLE tbl (c1 INT,c2 TEXT) PARTITION BY LIST (c1);\nCREATE TABLE tbl_null PARTITION OF tbl FOR VALUES IN (NULL);\nCREATE TABLE tbl_1 PARTITI... |
[
{
"msg_contents": "Snowball has made a release! With a tag!\n\nI have prepared a patch to update PostgreSQL's copy. (not attached \nhere, 566230 bytes, but see \nhttps://github.com/petere/postgresql/commit/52a6133b58c77ada4210a96e5155cbe4da5e5583)\n\nSince we last updated our copy from their commit date 2019-... |
[
{
"msg_contents": "We didn't get anywhere with making the default authentication method in \na source build anything other than trust. But perhaps we should change \nthe default for password_encryption to nudge people to adopt SCRAM? \nRight now, passwords are still hashed using MD5 by default, unless you \nsp... |
[
{
"msg_contents": "Here is a patch to provide default gucs for EXPLAIN options.\n\nI have two goals with this patch. The first is that I personally\n*always* want BUFFERS turned on, so this would allow me to do it without\ntyping it every time.\n\nThe second is it would make it easier to change the actual defa... |
[
{
"msg_contents": "There are a couple of function call overheads I observed in pl/pgsql\ncode : exec_stmt() and exec_cast_value(). Removing these overheads\nresulted in some performance gains.\n\nexec_stmt() :\n\nplpgsql_exec_function() and other toplevel block executors currently\ncall exec_stmt(). But actuall... |
[
{
"msg_contents": "Hi,\nThere was news in Phoronix about the Beta 1 Release of Postgres (1).\nUnfortunately for Postgres advocacy it does not bring good news,\nit is showing regressions in the benchmarks compared to version 12.\nWithout going into the technical merits of how the test was done,\nthey have no way... |
[
{
"msg_contents": "Greetings.\n\nI am getting random failures in `CREATE INDEX USING gist` over ltree column\nwhile performing pg_restore.\nI get either\n ERROR: stack depth limit exceeded\nor\n ERROR: failed to add item to index page\n\nThing is — if I retry index creation manually, I get it successful... |
[
{
"msg_contents": "Hi hackers,\n\nWhile browsing the system catalog docs earlier I noticed that a lot of\nthem mention other catalogs or views in the introductory paragrah\nwithout hyperlinking them. Now, most of these are linked in the\n\"references\" column in the table, but some, like pg_proc's mention of\n... |
[
{
"msg_contents": "Hi all,\n\nI have been playing with the new APIs of xlogreader.h, and while\nmerging some of my stuff with 13, I found the handling around\n->seg.ws_file overcomplicated and confusing as it is necessary for a\nplugin to manipulate directly the fd of an opened segment in the WAL\nsegment open/... |
[
{
"msg_contents": "Hi\n\nIn this list:\n\n https://www.postgresql.org/docs/devel/views-overview.html\n\n\"pg_shmem_allocations\" is not quite in alphabetical order and\nneeds to be swapped with the preceding entry, per attached patch.\n\n\nRegards\n\nIan Barwick\n\n--\nIan Barwick https://ww... |
[
{
"msg_contents": "Certificates I get at $work come four layers deep:\n\n\nSelf-signed CA cert from \"WE ISSUE TO EVERYBODY.COM\"\n\n Intermediate from \"WE ISSUE TO LOTS OF FOLKS.COM\"\n\n Intermediate from \"WE ISSUE TO ORGS LIKE YOURS.COM\"\n\n End-entity cert for my server.\n\n\nUntil today, we had... |
[
{
"msg_contents": "I recently noticed this in a customer log file:\n ERROR: could not read from hash-join temporary file: Success\n\nThe problem is we're reporting with %m when the problem is a partial\nread or write.\n\nI propose the attached patch to solve it: report \"wrote only X of X\nbytes\". This caus... |
[
{
"msg_contents": "I am reposting this from a few months back (see below). I am not trying to\nbe a pest, just very motivated. I really think this feature has merit, and\nif not generally worthwhile, I'd be willing to pay someone to code it for\nme as I don't have strong enough C skills to modify the PostgreSQL... |
[
{
"msg_contents": "Hello,\n\nI think it is more useful if the name list of the\npg_shmem_allocations view is listed in one page.\n\nFor example,\n* Wal Sender Ctl: walsender-related shared memory\n* AutoVacuum Data: autovacuum-related shared memory\n* PROCLOCK hash: shared memory for hash table for PROCLOCK str... |
[
{
"msg_contents": "Consider the below example:\n\ncreate table j1(i int, im5 int, im100 int, im1000 int);\ninsert into j1 select i, i%5, i%100, i%1000 from generate_series(1,\n10000000)i;\ncreate index j1_i_im5 on j1(i, im5);\ncreate index j1_i_im100 on j1(i, im100);\nanalyze j1;\nexplain select * from j1 wher... |
[
{
"msg_contents": "In postgresql.conf, it says:\n\n#max_slot_wal_keep_size = -1 # measured in bytes; -1 disables\n\nI don't know if that is describing the dimension of this parameter or the\nunits of it, but the default units for it are megabytes, not individual\nbytes, so I think it is pretty confusing.\n\nCh... |
[
{
"msg_contents": "Hi,\n\nIs there way to insert the cron job execution status to a table?\nOr any other method to identify the job status without checking the log\nfile?\n\n*Regards,*\n*Rajin *\n\nHi,Is there way to insert the cron job execution status to a table? Or any other method to identify the job status... |
[
{
"msg_contents": "Hackers,\n\nAttached is a patch for a `pg' command that consolidates various PostgreSQL functionality into a single command, along the lines of how `git' commands are run from a single 'git' executable. In other words,\n\n `pg upgrade` # instead of `pg_upgrade`\n `pg resetwal` # instea... |
[
{
"msg_contents": "The recent discussion about EXPLAIN and the possible inclusion of\ndefault-specifying GUCs raised a behavior that I did not fully appreciate\nnor find to be self-evident. Running EXPLAIN ANALYZE results in any\nside-effects of the explained and analyzed statement being permanently\nwritten t... |
[
{
"msg_contents": "Hello! My name is Grigory Kryachko, I decided to join the efforts with\nAndrey Borodin in his working on amcheck.\n\nHere is the patch which I (with Andrey as my advisor) built on the top of\nthe last patch from this thread: https://commitfest.postgresql.org/25/1800/\n.\nIt adds an ability to... |
[
{
"msg_contents": "\nHello devs,\n\n commit 2c24051bacd2d0eb7141fc4adb870281aec4e714\n Author: Craig Topper <craig.topper@gmail.com>\n Date: Fri Apr 24 22:12:21 2020 -0700\n\n [CallSite removal] Rename CallSite.h to AbstractCallSite.h. NFC\n\n The CallSite and ImmutableCallSite were removed in a pr... |
[
{
"msg_contents": "Hi,\n\nPgjdbc test suite identified a SIGSEGV in the recent HEAD builds of\nPostgreSQL, Ubuntu 14.04.5 LTS\n\nHere's a call stack:\nhttps://travis-ci.org/github/pgjdbc/pgjdbc/jobs/691794110#L7484\nThe crash is consistent, and it reproduces 100% of the cases so far.\n\nThe CI history shows tha... |
[
{
"msg_contents": "Hi all,\n\nWhile working on some monitoring tasks I realised that the pg_monitor\nrole doesn't have access to the pg_replication_origin_status.\n\nAre there any strong thoughts on not giving pg_monitor access to this\nview, or is it just something that nobody asked for yet? I can't find\nany ... |
[
{
"msg_contents": "The comment in be-secure-openssl.c didn't get the memo that the hardcoded DH\nparameters moved in 573bd08b99e277026e87bb55ae69c489fab321b8. The attached\nupdates the wording, keeping it generic enough that we wont need to update it\nshould the parameters move again.\n\ncheers ./daniel",
... |
[
{
"msg_contents": "Hi!\n\nI think I’ve found a bug related to the strength of collations. Attached is a\nWIP patch, that address some other issues too.\n\nIn this this example, the conflict of implicit collations propagates correctly:\n\n WITH data (c, posix) AS (\n values ('a' COLLATE \"C... |
[
{
"msg_contents": "Since OpenSSL is now releasing 3.0.0-alpha versions, I took a look at using it\nwith postgres to see what awaits us. As it is now shipping in releases (with\nGA planned for Q4), users will probably soon start to test against it so I\nwanted to be prepared.\n\nRegarding the deprecations, we c... |
[
{
"msg_contents": "There's the age-old problem of SET NOT NULL being impossible on large actively used tables, because it needs to lock the table and do a table scan to check if there are any existing NULL values. I currently have a table that's not particularly huge but a scan takes 70 seconds, which causes un... |
[
{
"msg_contents": "Hi,\n\nIn [1] I mentioned that I'd like to look into coding a data structure\nto allow Node types to be looked up more efficiently than what List\nallows. There are many places in the planner where we must determine\nif a given Node is in some List of Nodes. This is an O(n) operation.\nWe co... |
[
{
"msg_contents": "Hi,\n\nIs there any extension or option in PG to keep information of any (memory\ncontext/some memory address) of backend process after getting killed in\n(postgres server process/postmaster process)\n\nThanks\nBraj\n\nHi,Is there any extension or option in PG to keep information of any (mem... |
[
{
"msg_contents": "Hello,\n\nI noticed pg_dump failed to not dump creation or comment commands for public\nschema when we explicitly ask it to dump public schema.\n\nShorter example: pg_dump -n public dump will give:\n\n--\n-- Name: public; Type: SCHEMA; Schema: -; Owner: postgres\n--\n\nCREATE SCHEMA public;\n... |
[
{
"msg_contents": "Hi\n\none my customer has to specify dumped tables name by name. After years and\nincreasing database size and table numbers he has problem with too short\ncommand line. He need to read the list of tables from file (or from stdin).\n\nI wrote simple PoC patch\n\nComments, notes, ideas?\n\nReg... |
[
{
"msg_contents": "Hi All,\n\nPlease check the below scenario, with pseudotype \"anyelement\" for IN, OUT\nparameter and the RETURN record in a function.\n\npostgres=# create table tab1(c1 int, c2 int, c3 timestamp) ;\nCREATE TABLE\npostgres=# CREATE OR REPLACE FUNCTION func_any(IN anyelement, IN\nanyelement, O... |
[
{
"msg_contents": "Hello!\nWhen parameter cannot be changed without restarting the server postgresql\nwrite:\n\"LOG: configuration file \"/var/lib/postgresql/data/postgresql.auto.conf\"\ncontains errors; unaffected changes were applied\"\nMay be not write this string to LOG?\n\nThis string confuses people. If a... |
[
{
"msg_contents": "This thread is a follow-up of thread [1] where I don't have a good writing\nto\ndescribe the issue and solution in my mind. So I start this thread to fix\nthat\nand also enrich the topic by taking the advices from Ashutosh, Tomas and\nTom.\n\nInaccurate statistics is not avoidable and can cau... |
[
{
"msg_contents": "I noticed that the PostgreSQL entry in a pan-database feature matrix by\nModern SQL was not reflecting the reality of our features.[1]\n\nIt turns out that test case used by the author produced an error which\nthe tool took to mean the feature was not implemented. I don't have the\nactual te... |
[
{
"msg_contents": "Hi, hackers!\n\nCurrently i see, COPY FROM insertion into the partitioned table with \nforeign partitions is not optimal: even if table constraints allows can \ndo multi insert copy, we will flush the buffers and prepare new INSERT \nquery for each tuple, routed into the foreign partition.\nT... |
[
{
"msg_contents": "Hello hackers\n\nI think I found a bug about estimating width of table column when I\nperform SQL with UNION statement.\n\nI think table column width of UNION statement should be equal one of UNION ALL.\nBut they don't match.This can be reproduce it on HEAD.\n\nSee following example.\n\n--CR... |
[
{
"msg_contents": "One line change to remove a duplicate check.\n\n\n\n\n—\nMark Dilger\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company",
"msg_date": "Mon, 1 Jun 2020 08:37:12 -0700",
"msg_from": "Mark Dilger <mark.dilger@enterprisedb.com>",
"msg_from_op": true,
"ms... |
[
{
"msg_contents": "Hi all,\n\nWhen reading pg_stat_replication doc of PG13, I thought it's better to\nmention that tracking of spilled transactions works only for logical\nreplication like we already mentioned about replication lag tracking:\n\n <para>\n Lag times work automatically for physical replication.... |
[
{
"msg_contents": "Hi all,\n\nTracking of spilled transactions has been introduced to PG13. These\nnew statistics values, spill_txns, spill_count, and spill_bytes, are\ncumulative total values unlike other statistics values in\npg_stat_replication. How can we reset these values? We can reset\nstatistics values ... |
[
{
"msg_contents": "Hello.\n\nI noticed that UpdateSpillStats calls \"elog(DEBUG2\" within\nSpinLockAcquire section on MyWalSnd. The lock doesn't protect rb and\nin the first place the rb cannot be modified during the function is\nrunning.\n\nIt should be out of the lock section.\n\nregards.\n\n-- \nKyotaro Hor... |
[
{
"msg_contents": "Hi hackers,\n\n\nI've attached a patch to add blocker(s) information for LW Locks.\nThe motive behind is to be able to get some blocker(s) information (if \nany) in the context of LW Locks.\n\n_Motivation:_\n\nWe have seen some cases with heavy contention on some LW Locks (large \nnumber of b... |
[
{
"msg_contents": "Hi all,\n\nI have been looking at the ODBC driver and the need for currtid() as\nwell as currtid2(), and as mentioned already in [1], matching with my\nlookup of things, these are actually not needed by the driver as long\nas we connect to a server newer than 8.2 able to support RETURNING. I... |
[
{
"msg_contents": "Hi all,\n\nI have bumped into $subject, causing a replica identity index to\nbe considered as dropped if running REINDEX CONCURRENTLY on it. This\nmeans that the old tuple information would get lost in this case, as\na REPLICA IDENTITY USING INDEX without a dropped index is the same as\nNOTH... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.