wrote:\n> Ah, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per page\n> bitmap size. Thats about 36 bytes for 8K page. IOW if on an average there\n> are 6 or more dead tuples per page, bitmap will outperform the current\n> representation, assuming max allocation for bitmap. If we can use additional\n> estimates to restrict the size to somewhat more conservative value and then\n> keep overflow area, then probably the break-even happens even earlier than\n> that. I hope this gives us a good starting point, but let me know if you\n> think it's still a wrong approach to pursue.\n\nWell, it's certainly a bigger change. I think the big concern is that\nthe amount of memory now becomes fixed based on the table size. So\none problem is that you have to figure out what you're going to do if\nthe bitmap doesn't fit in maintenance_work_mem. A related problem is\nthat it might fit but use more memory than before, which could cause\nproblems for some people. Now on the other hand it could also use\nless memory for some people, and that would be good.\n\nI am kind of doubtful about this whole line of investigation because\nwe're basically trying pretty hard to fix something that I'm not sure\nis broken. I do agree that, all other things being equal, the TID\nlookups will probably be faster with a bitmap than with a binary\nsearch, but maybe not if the table is large and the number of dead\nTIDs is small, because cache efficiency is pretty important. But even\nif it's always faster, does TID lookup speed even really matter to\noverall VACUUM performance? Claudio's early results suggest that it\nmight, but maybe that's just a question of some optimization that\nhasn't been done yet.\n\nI'm fairly sure that our number one priority should be to minimize the\nnumber of cases where we need to do multiple scans of the indexes to\nstay within maintenance_work_mem. If we're satisfied we've met that\ngoal, then within that we should try to make VACUUM as fast as\npossible with as little memory usage as possible. I'm not 100% sure I\nknow how to get there, or how much work it's worth expending. In\ntheory we could even start with the list of TIDs and switch to the\nbitmap if the TID list becomes larger than the bitmap would have been,\nbut I don't know if it's worth the effort.\n\n/me thinks a bit.\n\nActually, I think that probably *is* worthwhile, specifically because\nit might let us avoid multiple index scans in cases where we currently\nrequire them. Right now, our default maintenance_work_mem value is\n64MB, which is enough to hold a little over ten million tuples. It's\nalso large enough to hold a bitmap for a 14GB table. So right now if\nyou deleted, say, 100 tuples per page you would end up with an index\nvacuum cycles for every ~100,000 pages = 800MB, whereas switching to\nthe bitmap representation for such cases would require only one index\nvacuum cycle for every 14GB, more than an order of magnitude\nimprovement!\n\nOn the other hand, if we switch to the bitmap as the ONLY possible\nrepresentation, we will lose badly when there are scattered updates -\ne.g. 1 deleted tuple every 10 pages. So it seems like we probably\nwant to have both options. One tricky part is figuring out how we\nswitch between them when memory gets tight; we have to avoid bursting\nabove our memory limit while making the switch. And even if our\nmemory limit is very high, we want to avoid using memory gratuitously;\nI think we should try to grow memory usage incrementally with either\nrepresentation.\n\nFor instance, one idea to grow memory usage incrementally would be to\nstore dead tuple information separately for each 1GB segment of the\nrelation. So we have an array of dead-tuple-representation objects,\none for every 1GB of the relation. If there are no dead tuples in a\ngiven 1GB segment, then this pointer can just be NULL. Otherwise, it\ncan point to either the bitmap representation (which will take ~4.5MB)\nor it can point to an array of TIDs (which will take 6 bytes/TID).\nThat could handle an awfully wide variety of usage patterns\nefficiently; it's basically never worse than what we're doing today,\nand when the dead tuple density is high for any portion of the\nrelation it's a lot better.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 14 Sep 2016 11:17:48 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>\n> I am kind of doubtful about this whole line of investigation because\n> we're basically trying pretty hard to fix something that I'm not sure\n> is broken. I do agree that, all other things being equal, the TID\n> lookups will probably be faster with a bitmap than with a binary\n> search, but maybe not if the table is large and the number of dead\n> TIDs is small, because cache efficiency is pretty important. But even\n> if it's always faster, does TID lookup speed even really matter to\n> overall VACUUM performance? Claudio's early results suggest that it\n> might, but maybe that's just a question of some optimization that\n> hasn't been done yet.\n\nFYI, the reported impact was on CPU time, not runtime. There was no\nsignificant difference in runtime (real time), because my test is\nheavily I/O bound.\n\nI tested with a few small tables and there was no significant\ndifference either, but small tables don't stress the array lookup\nanyway so that's expected.\n\nBut on the assumption that some systems may be CPU bound during vacuum\n(particularly those able to do more than 300-400MB/s sequential I/O),\nin those cases the increased or decreased cost of lazy_tid_reaped will\ndirectly correlate to runtime. It's just none of my systems, which all\nrun on amazon and is heavily bandwidth constrained (fastest I/O\nsubsystem I can get my hands on does 200MB/s).\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 14 Sep 2016 12:24:13 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Sep 14, 2016 5:18 PM, \"Robert Haas\" <robertmhaas@gmail.com> wrote:\n>\n> On Wed, Sep 14, 2016 at 8:16 AM, Pavan Deolasee\n> <pavan.deolasee@gmail.com> wrote:\n> > Ah, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per\npage\n> > bitmap size. Thats about 36 bytes for 8K page. IOW if on an average\nthere\n> > are 6 or more dead tuples per page, bitmap will outperform the current\n> > representation, assuming max allocation for bitmap. If we can use\nadditional\n> > estimates to restrict the size to somewhat more conservative value and\nthen\n> > keep overflow area, then probably the break-even happens even earlier\nthan\n> > that. I hope this gives us a good starting point, but let me know if you\n> > think it's still a wrong approach to pursue.\n>\n> Well, it's certainly a bigger change. I think the big concern is that\n> the amount of memory now becomes fixed based on the table size. So\n> one problem is that you have to figure out what you're going to do if\n> the bitmap doesn't fit in maintenance_work_mem. A related problem is\n> that it might fit but use more memory than before, which could cause\n> problems for some people. Now on the other hand it could also use\n> less memory for some people, and that would be good.\n>\n> I am kind of doubtful about this whole line of investigation because\n> we're basically trying pretty hard to fix something that I'm not sure\n> is broken. I do agree that, all other things being equal, the TID\n> lookups will probably be faster with a bitmap than with a binary\n> search, but maybe not if the table is large and the number of dead\n> TIDs is small, because cache efficiency is pretty important. But even\n> if it's always faster, does TID lookup speed even really matter to\n> overall VACUUM performance? Claudio's early results suggest that it\n> might, but maybe that's just a question of some optimization that\n> hasn't been done yet.\n>\n> I'm fairly sure that our number one priority should be to minimize the\n> number of cases where we need to do multiple scans of the indexes to\n> stay within maintenance_work_mem. If we're satisfied we've met that\n> goal, then within that we should try to make VACUUM as fast as\n> possible with as little memory usage as possible. I'm not 100% sure I\n> know how to get there, or how much work it's worth expending. In\n> theory we could even start with the list of TIDs and switch to the\n> bitmap if the TID list becomes larger than the bitmap would have been,\n> but I don't know if it's worth the effort.\n>\n> /me thinks a bit.\n>\n> Actually, I think that probably *is* worthwhile, specifically because\n> it might let us avoid multiple index scans in cases where we currently\n> require them. Right now, our default maintenance_work_mem value is\n> 64MB, which is enough to hold a little over ten million tuples. It's\n> also large enough to hold a bitmap for a 14GB table. So right now if\n> you deleted, say, 100 tuples per page you would end up with an index\n> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\n> the bitmap representation for such cases would require only one index\n> vacuum cycle for every 14GB, more than an order of magnitude\n> improvement!\n>\n> On the other hand, if we switch to the bitmap as the ONLY possible\n> representation, we will lose badly when there are scattered updates -\n> e.g. 1 deleted tuple every 10 pages. So it seems like we probably\n> want to have both options. One tricky part is figuring out how we\n> switch between them when memory gets tight; we have to avoid bursting\n> above our memory limit while making the switch. And even if our\n> memory limit is very high, we want to avoid using memory gratuitously;\n> I think we should try to grow memory usage incrementally with either\n> representation.\n>\n> For instance, one idea to grow memory usage incrementally would be to\n> store dead tuple information separately for each 1GB segment of the\n> relation. So we have an array of dead-tuple-representation objects,\n> one for every 1GB of the relation. If there are no dead tuples in a\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\n> can point to either the bitmap representation (which will take ~4.5MB)\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\n> That could handle an awfully wide variety of usage patterns\n> efficiently; it's basically never worse than what we're doing today,\n> and when the dead tuple density is high for any portion of the\n> relation it's a lot better.\n>\n> --\n> Robert Haas\n> EnterpriseDB: http://www.enterprisedb.com\n> The Enterprise PostgreSQL Company\n>\n>\n> --\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\n> To make changes to your subscription:\n> http://www.postgresql.org/mailpref/pgsql-hackers\n\nI'd say it's an idea worth pursuing. It's the base idea behind roaring\nbitmaps, arguably the best overall compressed bitmap implementation.\n\n\nOn Sep 14, 2016 5:18 PM, \"Robert Haas\" <robertmhaas@gmail.com> wrote:\n>\n> On Wed, Sep 14, 2016 at 8:16 AM, Pavan Deolasee\n> <pavan.deolasee@gmail.com> wrote:\n> > Ah, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per page\n> > bitmap size. Thats about 36 bytes for 8K page. IOW if on an average there\n> > are 6 or more dead tuples per page, bitmap will outperform the current\n> > representation, assuming max allocation for bitmap. If we can use additional\n> > estimates to restrict the size to somewhat more conservative value and then\n> > keep overflow area, then probably the break-even happens even earlier than\n> > that. I hope this gives us a good starting point, but let me know if you\n> > think it's still a wrong approach to pursue.\n>\n> Well, it's certainly a bigger change. I think the big concern is that\n> the amount of memory now becomes fixed based on the table size. So\n> one problem is that you have to figure out what you're going to do if\n> the bitmap doesn't fit in maintenance_work_mem. A related problem is\n> that it might fit but use more memory than before, which could cause\n> problems for some people. Now on the other hand it could also use\n> less memory for some people, and that would be good.\n>\n> I am kind of doubtful about this whole line of investigation because\n> we're basically trying pretty hard to fix something that I'm not sure\n> is broken. I do agree that, all other things being equal, the TID\n> lookups will probably be faster with a bitmap than with a binary\n> search, but maybe not if the table is large and the number of dead\n> TIDs is small, because cache efficiency is pretty important. But even\n> if it's always faster, does TID lookup speed even really matter to\n> overall VACUUM performance? Claudio's early results suggest that it\n> might, but maybe that's just a question of some optimization that\n> hasn't been done yet.\n>\n> I'm fairly sure that our number one priority should be to minimize the\n> number of cases where we need to do multiple scans of the indexes to\n> stay within maintenance_work_mem. If we're satisfied we've met that\n> goal, then within that we should try to make VACUUM as fast as\n> possible with as little memory usage as possible. I'm not 100% sure I\n> know how to get there, or how much work it's worth expending. In\n> theory we could even start with the list of TIDs and switch to the\n> bitmap if the TID list becomes larger than the bitmap would have been,\n> but I don't know if it's worth the effort.\n>\n> /me thinks a bit.\n>\n> Actually, I think that probably *is* worthwhile, specifically because\n> it might let us avoid multiple index scans in cases where we currently\n> require them. Right now, our default maintenance_work_mem value is\n> 64MB, which is enough to hold a little over ten million tuples. It's\n> also large enough to hold a bitmap for a 14GB table. So right now if\n> you deleted, say, 100 tuples per page you would end up with an index\n> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\n> the bitmap representation for such cases would require only one index\n> vacuum cycle for every 14GB, more than an order of magnitude\n> improvement!\n>\n> On the other hand, if we switch to the bitmap as the ONLY possible\n> representation, we will lose badly when there are scattered updates -\n> e.g. 1 deleted tuple every 10 pages. So it seems like we probably\n> want to have both options. One tricky part is figuring out how we\n> switch between them when memory gets tight; we have to avoid bursting\n> above our memory limit while making the switch. And even if our\n> memory limit is very high, we want to avoid using memory gratuitously;\n> I think we should try to grow memory usage incrementally with either\n> representation.\n>\n> For instance, one idea to grow memory usage incrementally would be to\n> store dead tuple information separately for each 1GB segment of the\n> relation. So we have an array of dead-tuple-representation objects,\n> one for every 1GB of the relation. If there are no dead tuples in a\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\n> can point to either the bitmap representation (which will take ~4.5MB)\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\n> That could handle an awfully wide variety of usage patterns\n> efficiently; it's basically never worse than what we're doing today,\n> and when the dead tuple density is high for any portion of the\n> relation it's a lot better.\n>\n> --\n> Robert Haas\n> EnterpriseDB: http://www.enterprisedb.com\n> The Enterprise PostgreSQL Company\n>\n>\n> --\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\n> To make changes to your subscription:\n> http://www.postgresql.org/mailpref/pgsql-hackers\nI'd say it's an idea worth pursuing. It's the base idea behind roaring bitmaps, arguably the best overall compressed bitmap implementation.","msg_date":"Wed, 14 Sep 2016 17:59:16 +0200","msg_from":"Arthur Silva <arthurprs@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Sep 14, 2016 at 8:47 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n\n>\n>\n> I am kind of doubtful about this whole line of investigation because\n> we're basically trying pretty hard to fix something that I'm not sure\n> is broken. I do agree that, all other things being equal, the TID\n> lookups will probably be faster with a bitmap than with a binary\n> search, but maybe not if the table is large and the number of dead\n> TIDs is small, because cache efficiency is pretty important. But even\n> if it's always faster, does TID lookup speed even really matter to\n> overall VACUUM performance? Claudio's early results suggest that it\n> might, but maybe that's just a question of some optimization that\n> hasn't been done yet.\n\n\nYeah, I wouldn't worry only about lookup speedup, but if does speeds up,\nthat's a bonus. But the bitmaps seem to win even for memory consumption. As\ntheory and experiments both show, at 10% dead tuple ratio, bitmaps will win\nhandsomely.\n\n In\n> theory we could even start with the list of TIDs and switch to the\n> bitmap if the TID list becomes larger than the bitmap would have been,\n> but I don't know if it's worth the effort.\n>\n>\nYes, that works too. Or may be even better because we already know the\nbitmap size requirements, definitely for the tuples collected so far. We\nmight need to maintain some more stats to further optimise the\nrepresentation, but that seems like unnecessary detailing at this point.\n\n\n>\n> On the other hand, if we switch to the bitmap as the ONLY possible\n> representation, we will lose badly when there are scattered updates -\n> e.g. 1 deleted tuple every 10 pages.\n\n\nSure. I never suggested that. What I'd suggested is to switch back to array\nrepresentation once we realise bitmaps are not going to work. But I see\nit's probably better the other way round.\n\n\n\n> So it seems like we probably\n> want to have both options. One tricky part is figuring out how we\n> switch between them when memory gets tight; we have to avoid bursting\n> above our memory limit while making the switch.\n\n\nYes, I was thinking about this problem. Some modelling will be necessary to\nensure that we don't go (much) beyond the maintenance_work_mem while\nswitching representation, which probably means you need to do that earlier\nthan necessary.\n\n\n> For instance, one idea to grow memory usage incrementally would be to\n> store dead tuple information separately for each 1GB segment of the\n> relation. So we have an array of dead-tuple-representation objects,\n> one for every 1GB of the relation. If there are no dead tuples in a\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\n> can point to either the bitmap representation (which will take ~4.5MB)\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\n> That could handle an awfully wide variety of usage patterns\n> efficiently; it's basically never worse than what we're doing today,\n> and when the dead tuple density is high for any portion of the\n> relation it's a lot better.\n>\n>\nYes seems like a good idea. Another idea that I'd in mind is to use some\nsort of indirection map where bitmap for every block or a set of blocks\nwill either be recorded or not, depending on whether a bit is set for the\nrange. If the bitmap exists, the indirection map will give out the offset\ninto the larger bitmap area. Seems similar to what you described.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Wed, Sep 14, 2016 at 8:47 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n\nI am kind of doubtful about this whole line of investigation because\nwe're basically trying pretty hard to fix something that I'm not sure\nis broken. I do agree that, all other things being equal, the TID\nlookups will probably be faster with a bitmap than with a binary\nsearch, but maybe not if the table is large and the number of dead\nTIDs is small, because cache efficiency is pretty important. But even\nif it's always faster, does TID lookup speed even really matter to\noverall VACUUM performance? Claudio's early results suggest that it\nmight, but maybe that's just a question of some optimization that\nhasn't been done yet. Yeah, I wouldn't worry only about lookup speedup, but if does speeds up, that's a bonus. But the bitmaps seem to win even for memory consumption. As theory and experiments both show, at 10% dead tuple ratio, bitmaps will win handsomely. In\ntheory we could even start with the list of TIDs and switch to the\nbitmap if the TID list becomes larger than the bitmap would have been,\nbut I don't know if it's worth the effort.\nYes, that works too. Or may be even better because we already know the bitmap size requirements, definitely for the tuples collected so far. We might need to maintain some more stats to further optimise the representation, but that seems like unnecessary detailing at this point. \n\nOn the other hand, if we switch to the bitmap as the ONLY possible\nrepresentation, we will lose badly when there are scattered updates -\ne.g. 1 deleted tuple every 10 pages. Sure. I never suggested that. What I'd suggested is to switch back to array representation once we realise bitmaps are not going to work. But I see it's probably better the other way round. So it seems like we probably\nwant to have both options. One tricky part is figuring out how we\nswitch between them when memory gets tight; we have to avoid bursting\nabove our memory limit while making the switch.Yes, I was thinking about this problem. Some modelling will be necessary to ensure that we don't go (much) beyond the maintenance_work_mem while switching representation, which probably means you need to do that earlier than necessary. For instance, one idea to grow memory usage incrementally would be to\nstore dead tuple information separately for each 1GB segment of the\nrelation. So we have an array of dead-tuple-representation objects,\none for every 1GB of the relation. If there are no dead tuples in a\ngiven 1GB segment, then this pointer can just be NULL. Otherwise, it\ncan point to either the bitmap representation (which will take ~4.5MB)\nor it can point to an array of TIDs (which will take 6 bytes/TID).\nThat could handle an awfully wide variety of usage patterns\nefficiently; it's basically never worse than what we're doing today,\nand when the dead tuple density is high for any portion of the\nrelation it's a lot better.\n\nYes seems like a good idea. Another idea that I'd in mind is to use some sort of indirection map where bitmap for every block or a set of blocks will either be recorded or not, depending on whether a bit is set for the range. If the bitmap exists, the indirection map will give out the offset into the larger bitmap area. Seems similar to what you described.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Wed, 14 Sep 2016 21:49:43 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> For instance, one idea to grow memory usage incrementally would be to\n> store dead tuple information separately for each 1GB segment of the\n> relation. So we have an array of dead-tuple-representation objects,\n> one for every 1GB of the relation. If there are no dead tuples in a\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\n> can point to either the bitmap representation (which will take ~4.5MB)\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\n> That could handle an awfully wide variety of usage patterns\n> efficiently; it's basically never worse than what we're doing today,\n> and when the dead tuple density is high for any portion of the\n> relation it's a lot better.\n\nIf you compress the list into a bitmap a posteriori, you know the\nnumber of tuples per page, so you could encode the bitmap even more\nefficiently.\n\nIt's not a bad idea, one that can be slapped on top of the multiarray\npatch - when closing a segment, it can be decided whether to turn it\ninto a bitmap or not.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 14 Sep 2016 13:42:38 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Robert Haas wrote:\n\n> Actually, I think that probably *is* worthwhile, specifically because\n> it might let us avoid multiple index scans in cases where we currently\n> require them. Right now, our default maintenance_work_mem value is\n> 64MB, which is enough to hold a little over ten million tuples. It's\n> also large enough to hold a bitmap for a 14GB table. So right now if\n> you deleted, say, 100 tuples per page you would end up with an index\n> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\n> the bitmap representation for such cases would require only one index\n> vacuum cycle for every 14GB, more than an order of magnitude\n> improvement!\n\nYeah, this sounds worthwhile. If we switch to the more compact\nin-memory representation close to the point where we figure the TID\narray is not going to fit in m_w_m, then we're saving some number of\nadditional index scans, and I'm pretty sure that the time to transform\nfrom array to bitmap is going to be more than paid back by the I/O\nsavings.\n\nOne thing not quite clear to me is how do we create the bitmap\nrepresentation starting from the array representation in midflight\nwithout using twice as much memory transiently. Are we going to write\nthe array to a temp file, free the array memory, then fill the bitmap by\nreading the array from disk?\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 14 Sep 2016 14:23:54 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 14 September 2016 at 11:19, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\n\n>> In\n>> theory we could even start with the list of TIDs and switch to the\n>> bitmap if the TID list becomes larger than the bitmap would have been,\n>> but I don't know if it's worth the effort.\n>>\n>\n> Yes, that works too. Or may be even better because we already know the\n> bitmap size requirements, definitely for the tuples collected so far. We\n> might need to maintain some more stats to further optimise the\n> representation, but that seems like unnecessary detailing at this point.\n\nThat sounds best to me... build the simple representation, but as we\ndo maintain stats to show to what extent that set of tuples is\ncompressible.\n\nWhen we hit the limit on memory we can then selectively compress\nchunks to stay within memory, starting with the most compressible\nchunks.\n\nI think we should use the chunking approach Robert suggests, though\nmainly because that allows us to consider how parallel VACUUM should\nwork - writing the chunks to shmem. That would also allow us to apply\na single global limit for vacuum memory rather than an allocation per\nVACUUM.\nWe can then scan multiple indexes at once in parallel, all accessing\nthe shmem data structure.\n\nWe should also find the compression is better when we consider chunks\nrather than the whole data structure at once.\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 14 Sep 2016 12:40:00 -0500","msg_from":"Simon Riggs <simon@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\nwrote:\n\n>\n>\n> One thing not quite clear to me is how do we create the bitmap\n> representation starting from the array representation in midflight\n> without using twice as much memory transiently. Are we going to write\n> the array to a temp file, free the array memory, then fill the bitmap by\n> reading the array from disk?\n>\n\nWe could do that. Or may be compress TID array when consumed half m_w_m and\ndo this repeatedly with remaining memory. For example, if we start with 1GB\nmemory, we decide to compress at 512MB. Say that results in 300MB for\nbitmap. We then continue to accumulate TID and do another round of fold up\nwhen another 350MB is consumed.\n\nI think we should maintain per offset count of number of dead tuples to\nchoose the most optimal bitmap size (that needs overflow region). We can\nalso track how many blocks or block ranges have at least one dead tuple to\nknow if it's worthwhile to have some sort of indirection. Together that can\ntell us how much compression can be achieved and allow us to choose the\nmost optimal representation.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com> wrote:\n\nOne thing not quite clear to me is how do we create the bitmap\nrepresentation starting from the array representation in midflight\nwithout using twice as much memory transiently. Are we going to write\nthe array to a temp file, free the array memory, then fill the bitmap by\nreading the array from disk?We could do that. Or may be compress TID array when consumed half m_w_m and do this repeatedly with remaining memory. For example, if we start with 1GB memory, we decide to compress at 512MB. Say that results in 300MB for bitmap. We then continue to accumulate TID and do another round of fold up when another 350MB is consumed.I think we should maintain per offset count of number of dead tuples to choose the most optimal bitmap size (that needs overflow region). We can also track how many blocks or block ranges have at least one dead tuple to know if it's worthwhile to have some sort of indirection. Together that can tell us how much compression can be achieved and allow us to choose the most optimal representation.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Wed, 14 Sep 2016 23:10:09 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Pavan Deolasee <pavan.deolasee@gmail.com> writes:\n> On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\n> wrote:\n>> One thing not quite clear to me is how do we create the bitmap\n>> representation starting from the array representation in midflight\n>> without using twice as much memory transiently. Are we going to write\n>> the array to a temp file, free the array memory, then fill the bitmap by\n>> reading the array from disk?\n\n> We could do that.\n\nPeople who are vacuuming because they are out of disk space will be very\nvery unhappy with that solution.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 14 Sep 2016 13:57:42 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Sep 14, 2016 at 1:23 PM, Alvaro Herrera\n<alvherre@2ndquadrant.com> wrote:\n> Robert Haas wrote:\n>> Actually, I think that probably *is* worthwhile, specifically because\n>> it might let us avoid multiple index scans in cases where we currently\n>> require them. Right now, our default maintenance_work_mem value is\n>> 64MB, which is enough to hold a little over ten million tuples. It's\n>> also large enough to hold a bitmap for a 14GB table. So right now if\n>> you deleted, say, 100 tuples per page you would end up with an index\n>> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\n>> the bitmap representation for such cases would require only one index\n>> vacuum cycle for every 14GB, more than an order of magnitude\n>> improvement!\n>\n> Yeah, this sounds worthwhile. If we switch to the more compact\n> in-memory representation close to the point where we figure the TID\n> array is not going to fit in m_w_m, then we're saving some number of\n> additional index scans, and I'm pretty sure that the time to transform\n> from array to bitmap is going to be more than paid back by the I/O\n> savings.\n\nYes, that seems pretty clear. The indexes can be arbitrarily large\nand there can be arbitrarily many of them, so we could be save a LOT\nof I/O.\n\n> One thing not quite clear to me is how do we create the bitmap\n> representation starting from the array representation in midflight\n> without using twice as much memory transiently. Are we going to write\n> the array to a temp file, free the array memory, then fill the bitmap by\n> reading the array from disk?\n\nI was just thinking about this exact problem while I was out to\nlunch.[1] I wonder if we could do something like this:\n\n1. Allocate an array large enough for one pointer per gigabyte of the\nunderlying relation.\n\n2. Allocate 64MB, or the remaining amount of maintenance_work_mem if\nit's less, to store TIDs.\n\n3. At the beginning of each 1GB chunk, add a pointer to the first free\nbyte in the slab allocated in step 2 to the array allocated in step 1.\nWrite a header word that identifies this as a TID list (rather than a\nbitmap) and leave space for a TID count; then, write the TIDs\nafterwards. Continue doing this until one of the following things\nhappens: (a) we reach the end of the 1GB chunk - if that happens,\nrestart step 3 for the next chunk; (b) we fill the chunk - see step 4,\nor (c) we write more TIDs for the chunk than the space being used for\nTIDs now exceeds the space needed for a bitmap - see step 5.\n\n4. When we fill up one of the slabs allocated in step 2, allocate a\nnew one and move the tuples for the current 1GB chunk to the beginning\nof the new slab using memmove(). This is wasteful of both CPU time\nand memory, but I think it's not that bad. The maximum possible waste\nis less than 10%, and many allocators have more overhead than that.\nWe could reduce the waste by using, say, 256MB chunks rather than 1GB\nchunks. If no new slab can be allocated because maintenance_work_mem\nis completely exhausted (or the remaining space isn't enough for the\nTIDs that would need to be moved immediately), then stop and do an\nindex vacuum cycle.\n\n5. When we write a large enough number of TIDs for 1GB chunk that the\nbitmap would be smaller, check whether sufficient maintenance_work_mem\nremains to allocate a bitmap for 1GB chunk (~4.5MB). If not, never\nmind; continue with step 3 as if the bitmap representation did not\nexist. If so, allocate space for a bitmap, move all of the TIDs for\nthe current chunk into it, and update the array allocated in step 1 to\npoint to it. Then, finish scanning the current 1GB chunk, updating\nthat bitmap rather than inserting TIDs into the slab. Rewind our\npointer into the slab to where it was at the beginning of the current\n1GB chunk, so that the memory we consumed for TIDs can be reused now\nthat those TIDs have been transferred to a bitmap. If, earlier in the\ncurrent 1GB chunk, we did a memmove-to-next-slab operation as\ndescribed in step 4, this \"rewind\" might move our pointer back into\nthe previous slab, in which case we can free the now-empty slab. (The\nnext 1GB segment might have few enough TIDs that they will fit into\nthe leftover space in the previous slab.)\n\nWith this algorithm, we never exceed maintenance_work_mem, not even\ntransiently. When memory is no longer sufficient to convert to the\nbitmap representation without bursting above maintenance_work_mem, we\nsimply don't perform the conversion. Also, we do very little memory\ncopying. An alternative I considered was to do a separate allocation\nfor each 1GB chunk rather than carving the dead-tuple space out of\nslabs. But the problem with that is that you'll have to start those\nout small (in case you don't find many dead tuples) and then grow\nthem, which means reallocating, which is bad both because it can burst\nabove maintenance_work_mem while the repalloc is in process and also\nbecause you have to keep copying the data from the old chunk to the\nnew, bigger chunk. This algorithm only needs to copy TIDs when it\nruns off the end of a chunk, and that can't happen more than once\nevery dozen or so chunks; in contrast, progressively growing the TID\narrays for a given 1GB chunk would potentially memcpy() multiple times\nper 1GB chunk, and if you used power-of-two reallocation as we\nnormally do the waste would be much more than what step 4 of this\nalgorithm leaves on the table.\n\nThere are, nevertheless, corner cases where this can lose: if you had\na number of TIDs that were going to just BARELY fit within\nmaintenance_work_mem, and if the bitmap representation never wins for\nyou, the additional array allocated in step 1 and the end-of-slab\nwastage in step 4 could push you over the line. We might be able to\ntweak things here or there to reduce the potential for that, but it's\npretty well unavoidable; the flat array we're using right now has\nexactly zero allocator overhead, and anything more complex will have\nsome.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n[1] Or am I always out to lunch?\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 14 Sep 2016 14:10:05 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Sep 15, 2016 at 2:40 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\n> On 14 September 2016 at 11:19, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\n>\n>>> In\n>>> theory we could even start with the list of TIDs and switch to the\n>>> bitmap if the TID list becomes larger than the bitmap would have been,\n>>> but I don't know if it's worth the effort.\n>>>\n>>\n>> Yes, that works too. Or may be even better because we already know the\n>> bitmap size requirements, definitely for the tuples collected so far. We\n>> might need to maintain some more stats to further optimise the\n>> representation, but that seems like unnecessary detailing at this point.\n>\n> That sounds best to me... build the simple representation, but as we\n> do maintain stats to show to what extent that set of tuples is\n> compressible.\n>\n> When we hit the limit on memory we can then selectively compress\n> chunks to stay within memory, starting with the most compressible\n> chunks.\n>\n> I think we should use the chunking approach Robert suggests, though\n> mainly because that allows us to consider how parallel VACUUM should\n> work - writing the chunks to shmem. That would also allow us to apply\n> a single global limit for vacuum memory rather than an allocation per\n> VACUUM.\n> We can then scan multiple indexes at once in parallel, all accessing\n> the shmem data structure.\n>\n\nYeah, the chunking approach Robert suggested seems like a good idea\nbut considering implementing parallel vacuum, it would be more\ncomplicated IMO.\nI think It's better the multiple process simply allocate memory space\nfor its process than that the single process allocate huge memory\nspace using complicated way.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 16 Sep 2016 00:19:05 +0900","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 09/14/2016 07:57 PM, Tom Lane wrote:\n> Pavan Deolasee <pavan.deolasee@gmail.com> writes:\n>> On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\n>> wrote:\n>>> One thing not quite clear to me is how do we create the bitmap\n>>> representation starting from the array representation in midflight\n>>> without using twice as much memory transiently. Are we going to write\n>>> the array to a temp file, free the array memory, then fill the bitmap by\n>>> reading the array from disk?\n>\n>> We could do that.\n>\n> People who are vacuuming because they are out of disk space will be very\n> very unhappy with that solution.\n\nThe people are usually running out of space for data, while these files \nwould be temporary files placed wherever temp_tablespaces points to. I'd \nargue if this is a source of problems, the people are already in deep \ntrouble due to sorts, CREATE INDEX, ... as those commands may also \ngenerate a lot of temporary files.\n\nregards\nTomas\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 17:50:28 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 09/14/2016 05:17 PM, Robert Haas wrote:\n> I am kind of doubtful about this whole line of investigation because\n> we're basically trying pretty hard to fix something that I'm not sure\n> is broken. I do agree that, all other things being equal, the TID\n> lookups will probably be faster with a bitmap than with a binary\n> search, but maybe not if the table is large and the number of dead\n> TIDs is small, because cache efficiency is pretty important. But even\n> if it's always faster, does TID lookup speed even really matter to\n> overall VACUUM performance? Claudio's early results suggest that it\n> might, but maybe that's just a question of some optimization that\n> hasn't been done yet.\n\nRegarding the lookup performance, I don't think the bitmap alone can \nsignificantly improve that - it's more efficient memory-wise, no doubt \nabout that, but it's still likely larger than CPU caches and accessed \nmostly randomly (when vacuuming the indexes).\n\nIMHO the best way to speed-up lookups (if it's really an issue, haven't \ndone any benchmarks) would be to build a small bloom filter in front of \nthe TID array / bitmap. It shall be fairly small (depending on the \nnumber of TIDs, error rate etc.) and likely to fit into L2/L3, and \neliminate a lot of probes into the much larger array/bitmap.\n\nOf course, it's another layer of complexity - the good thing is we don't \nneed to build the filter until after we collect the TIDs, so we got \npretty good inputs for the bloom filter parameters.\n\nBut all this is based on the assumption that the lookups are actually \nexpensive, not sure about that.\n\nregards\nTomas\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 18:04:25 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Sep 15, 2016 at 12:50 PM, Tomas Vondra\n<tomas.vondra@2ndquadrant.com> wrote:\n> On 09/14/2016 07:57 PM, Tom Lane wrote:\n>>\n>> Pavan Deolasee <pavan.deolasee@gmail.com> writes:\n>>>\n>>> On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera\n>>> <alvherre@2ndquadrant.com>\n>>> wrote:\n>>>>\n>>>> One thing not quite clear to me is how do we create the bitmap\n>>>> representation starting from the array representation in midflight\n>>>> without using twice as much memory transiently. Are we going to write\n>>>> the array to a temp file, free the array memory, then fill the bitmap by\n>>>> reading the array from disk?\n>>\n>>\n>>> We could do that.\n>>\n>>\n>> People who are vacuuming because they are out of disk space will be very\n>> very unhappy with that solution.\n>\n>\n> The people are usually running out of space for data, while these files\n> would be temporary files placed wherever temp_tablespaces points to. I'd\n> argue if this is a source of problems, the people are already in deep\n> trouble due to sorts, CREATE INDEX, ... as those commands may also generate\n> a lot of temporary files.\n\nOne would not expect \"CREATE INDEX\" to succeed when space is tight,\nbut VACUUM is quite the opposite.\n\nStill, temporary storage could be used if available, and gracefully\nfall back to some other technique (like not using bitmaps) when not.\n\nNot sure it's worth the trouble, though.\n\n\nOn Wed, Sep 14, 2016 at 12:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>\n>> I am kind of doubtful about this whole line of investigation because\n>> we're basically trying pretty hard to fix something that I'm not sure\n>> is broken. I do agree that, all other things being equal, the TID\n>> lookups will probably be faster with a bitmap than with a binary\n>> search, but maybe not if the table is large and the number of dead\n>> TIDs is small, because cache efficiency is pretty important. But even\n>> if it's always faster, does TID lookup speed even really matter to\n>> overall VACUUM performance? Claudio's early results suggest that it\n>> might, but maybe that's just a question of some optimization that\n>> hasn't been done yet.\n>\n> FYI, the reported impact was on CPU time, not runtime. There was no\n> significant difference in runtime (real time), because my test is\n> heavily I/O bound.\n>\n> I tested with a few small tables and there was no significant\n> difference either, but small tables don't stress the array lookup\n> anyway so that's expected.\n>\n> But on the assumption that some systems may be CPU bound during vacuum\n> (particularly those able to do more than 300-400MB/s sequential I/O),\n> in those cases the increased or decreased cost of lazy_tid_reaped will\n> directly correlate to runtime. It's just none of my systems, which all\n> run on amazon and is heavily bandwidth constrained (fastest I/O\n> subsystem I can get my hands on does 200MB/s).\n\nAttached is the patch with the multiarray version.\n\nThe tests are weird. Best case comparison over several runs, to remove\nthe impact of concurrent activity on this host (I couldn't remove all\nbackground activity even when running the tests overnight, the distro\nadds tons of crons and background cleanup tasks it would seem),\nthere's only very mild CPU impact. I'd say insignificant, as it's well\nbelow the mean variance.\n\nWorst case:\n\nDETAIL: CPU 9.90s/80.94u sec elapsed 1232.42 sec.\n\nBest case:\n\nDETAIL: CPU 12.10s/63.82u sec elapsed 832.79 sec.\n\nThere seems to be more variance with the multiarray approach than the\nsingle array one, but I could not figure out why. Even I/O seems less\nstable:\n\nWorst case:\n\nINFO: \"pgbench_accounts\": removed 400000000 row versions in 6557382 pages\nDETAIL: CPU 64.31s/37.60u sec elapsed 2573.88 sec.\n\nBest case:\n\nINFO: \"pgbench_accounts\": removed 400000000 row versions in 6557378 pages\nDETAIL: CPU 54.48s/31.78u sec elapsed 1552.18 sec.\n\nSince this test takes several hours to complete, I could only run a\nfew runs of each version, so the statistical significance of the test\nisn't very bright.\n\nI'll try to compare with smaller pgbench scale numbers and more runs\nover the weekend (gotta script that). It's certainly puzzling, I\ncannot explain the increased variance, especially in I/O, since the\nI/O should be exactly the same. I'm betting it's my system that's\nunpredictable somehow. So I'm posting the patch in case someone gets\ninspired and can spot the reason, and because there's been a lot of\ntalk about this very same approach, so I thought I'd better post the\ncode ;)\n\nI'll also try to get a more predictable system to run the tests on.\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 15 Sep 2016 13:16:52 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Tomas Vondra <tomas.vondra@2ndquadrant.com> writes:\n> On 09/14/2016 07:57 PM, Tom Lane wrote:\n>> People who are vacuuming because they are out of disk space will be very\n>> very unhappy with that solution.\n\n> The people are usually running out of space for data, while these files \n> would be temporary files placed wherever temp_tablespaces points to. I'd \n> argue if this is a source of problems, the people are already in deep \n> trouble due to sorts, CREATE INDEX, ... as those commands may also \n> generate a lot of temporary files.\n\nExcept that if you are trying to recover disk space, VACUUM is what you\nare doing, not CREATE INDEX. Requiring extra disk space to perform a\nvacuum successfully is exactly the wrong direction to be going in.\nSee for example this current commitfest entry:\nhttps://commitfest.postgresql.org/10/649/\nRegardless of what you think of the merits of that patch, it's trying\nto solve a real-world problem. And as Robert has already pointed out,\nmaking this aspect of VACUUM more complicated is not solving any\npressing problem. \"But we made it faster\" is going to be a poor answer\nfor the next person who finds themselves up against the wall with no\nrecourse.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 12:22:16 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Sep 15, 2016 at 12:22 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> Tomas Vondra <tomas.vondra@2ndquadrant.com> writes:\n>> On 09/14/2016 07:57 PM, Tom Lane wrote:\n>>> People who are vacuuming because they are out of disk space will be very\n>>> very unhappy with that solution.\n>\n>> The people are usually running out of space for data, while these files\n>> would be temporary files placed wherever temp_tablespaces points to. I'd\n>> argue if this is a source of problems, the people are already in deep\n>> trouble due to sorts, CREATE INDEX, ... as those commands may also\n>> generate a lot of temporary files.\n>\n> Except that if you are trying to recover disk space, VACUUM is what you\n> are doing, not CREATE INDEX. Requiring extra disk space to perform a\n> vacuum successfully is exactly the wrong direction to be going in.\n> See for example this current commitfest entry:\n> https://commitfest.postgresql.org/10/649/\n> Regardless of what you think of the merits of that patch, it's trying\n> to solve a real-world problem. And as Robert has already pointed out,\n> making this aspect of VACUUM more complicated is not solving any\n> pressing problem. \"But we made it faster\" is going to be a poor answer\n> for the next person who finds themselves up against the wall with no\n> recourse.\n\nI very much agree.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 12:40:18 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 09/15/2016 06:40 PM, Robert Haas wrote:\n> On Thu, Sep 15, 2016 at 12:22 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n>> Tomas Vondra <tomas.vondra@2ndquadrant.com> writes:\n>>> On 09/14/2016 07:57 PM, Tom Lane wrote:\n>>>> People who are vacuuming because they are out of disk space will be very\n>>>> very unhappy with that solution.\n>>\n>>> The people are usually running out of space for data, while these files\n>>> would be temporary files placed wherever temp_tablespaces points to. I'd\n>>> argue if this is a source of problems, the people are already in deep\n>>> trouble due to sorts, CREATE INDEX, ... as those commands may also\n>>> generate a lot of temporary files.\n>>\n>> Except that if you are trying to recover disk space, VACUUM is what you\n>> are doing, not CREATE INDEX. Requiring extra disk space to perform a\n>> vacuum successfully is exactly the wrong direction to be going in.\n>> See for example this current commitfest entry:\n>> https://commitfest.postgresql.org/10/649/\n>> Regardless of what you think of the merits of that patch, it's trying\n>> to solve a real-world problem. And as Robert has already pointed out,\n>> making this aspect of VACUUM more complicated is not solving any\n>> pressing problem. \"But we made it faster\" is going to be a poor answer\n>> for the next person who finds themselves up against the wall with no\n>> recourse.\n>\n> I very much agree.\n>\n\nHow does VACUUM alone help with recovering disk space? AFAIK it only \nmakes the space available for new data, it does not reclaim the disk \nspace at all. Sure, we truncate empty pages at the end of the last \nsegment, but how likely is that in practice? What I do see people doing \nis usually either VACUUM FULL (which is however doomed for obvious \nreasons) or VACUUM + reindexing to get rid of index bloat (which however \nleads to CREATE INDEX using temporary files).\n\nI'm not sure I agree with your claim there's no pressing problem. We do \nsee quite a few people having to do VACUUM with multiple index scans \n(because the TIDs don't fit into m_w_m), which certainly has significant \nimpact on production systems - both in terms of performance and it also \nslows down reclaiming the space. Sure, being able to set m_w_m above 1GB \nis an improvement, but perhaps using a more efficient TID storage would \nimprove the situation further. Writing the TIDs to a temporary file may \nnot the right approach, but I don't see why that would make the original \nproblem less severe?\n\nFor example, we always allocate the TID array as large as we can fit \ninto m_w_m, but maybe we don't need to wait with switching to the bitmap \nuntil filling the whole array - we could wait as long as the bitmap fits \ninto the remaining part of the array, build it there and then copy it to \nthe beginning (and use the bitmap from that point).\n\nregards\nTomas\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 20:48:09 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Sep 15, 2016 at 3:48 PM, Tomas Vondra\n<tomas.vondra@2ndquadrant.com> wrote:\n> For example, we always allocate the TID array as large as we can fit into\n> m_w_m, but maybe we don't need to wait with switching to the bitmap until\n> filling the whole array - we could wait as long as the bitmap fits into the\n> remaining part of the array, build it there and then copy it to the\n> beginning (and use the bitmap from that point).\n\nThe bitmap can be created like that, but grow from the end of the\nsegment backwards.\n\nSo the scan can proceed until the bitmap fills the whole segment\n(filling backwards), no copy required.\n\nI'll try that later, but first I'd like to get multiarray approach\nright since that's the basis of it.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 15:54:41 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Sep 16, 2016 at 12:24 AM, Claudio Freire <klaussfreire@gmail.com>\nwrote:\n\n> On Thu, Sep 15, 2016 at 3:48 PM, Tomas Vondra\n> <tomas.vondra@2ndquadrant.com> wrote:\n> > For example, we always allocate the TID array as large as we can fit into\n> > m_w_m, but maybe we don't need to wait with switching to the bitmap until\n> > filling the whole array - we could wait as long as the bitmap fits into\n> the\n> > remaining part of the array, build it there and then copy it to the\n> > beginning (and use the bitmap from that point).\n>\n> The bitmap can be created like that, but grow from the end of the\n> segment backwards.\n>\n> So the scan can proceed until the bitmap fills the whole segment\n> (filling backwards), no copy required.\n>\n\nI thought about those approaches when I suggested starting with half m_w_m.\nSo you fill in TIDs from one end and upon reaching half point, convert that\ninto bitmap (assuming stats tell you that there is significant savings with\nbitmaps) but fill it from the other end. Then reset the TID array and start\nfilling up again. That guarantees that you can always work within available\nlimit.\n\nBut I actually wonder if we are over engineering things and overestimating\ncost of memmove etc. How about this simpler approach:\n\n1. Divide table in some fixed size chunks like Robert suggested. Say 1GB\n2. Allocate pointer array to store a pointer to each segment. For 1TB\ntable, thats about 8192 bytes.\n3. Allocate a bitmap which can hold MaxHeapTuplesPerPage * chunk size in\npages. For 8192 block and 1GB chunk, thats about 4.6MB. *Note*: I'm\nsuggesting to use a bitmap here because provisioning for worst case, fixed\nsize TID array will cost us 200MB+ where as a bitmap is just 4.6MB.\n4. Collect dead tuples in that 1GB chunk. Also collect stats so that we\nknow about the most optimal representation.\n5. At the end of 1GB scan, if no dead tuples found, set the chunk pointer\nto NULL, move to next chunk and restart step 4. If dead tuples found, then\ncheck:\n a. If bitmap can be further compressed by using less number of bits per\npage. If so, allocate a new bitmap and compress the bitmap.\n b. If TID array will be a more compact representation. If so, allocate a\nTID array of right size and convert bitmap into an array.\n c. Set chunk pointer to whichever representation we choose (of course\nadd headers etc to interpret the representation)\n6. Continue until we consume all m_w_m or end-of-table is reached. If we\nconsume all m_w_m then do a round of index cleanup and restart.\n\nI also realised that we can compact the TID array in step (b) above because\nwe only need to store 17 bits for block numbers (we already know which 1GB\nsegment they belong to). Given that usable offsets are also just 13 bits,\nTID array needs only 4 bytes per TID instead of 6.\n\nMany people are working on implementing different ideas, and I can\nvolunteer to write a patch on these lines unless someone wants to do that.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Fri, Sep 16, 2016 at 12:24 AM, Claudio Freire <klaussfreire@gmail.com> wrote:On Thu, Sep 15, 2016 at 3:48 PM, Tomas Vondra\n<tomas.vondra@2ndquadrant.com> wrote:\n> For example, we always allocate the TID array as large as we can fit into\n> m_w_m, but maybe we don't need to wait with switching to the bitmap until\n> filling the whole array - we could wait as long as the bitmap fits into the\n> remaining part of the array, build it there and then copy it to the\n> beginning (and use the bitmap from that point).\n\nThe bitmap can be created like that, but grow from the end of the\nsegment backwards.\n\nSo the scan can proceed until the bitmap fills the whole segment\n(filling backwards), no copy required.I thought about those approaches when I suggested starting with half m_w_m. So you fill in TIDs from one end and upon reaching half point, convert that into bitmap (assuming stats tell you that there is significant savings with bitmaps) but fill it from the other end. Then reset the TID array and start filling up again. That guarantees that you can always work within available limit.But I actually wonder if we are over engineering things and overestimating cost of memmove etc. How about this simpler approach:1. Divide table in some fixed size chunks like Robert suggested. Say 1GB2. Allocate pointer array to store a pointer to each segment. For 1TB table, thats about 8192 bytes.3. Allocate a bitmap which can hold MaxHeapTuplesPerPage * chunk size in pages. For 8192 block and 1GB chunk, thats about 4.6MB. Note: I'm suggesting to use a bitmap here because provisioning for worst case, fixed size TID array will cost us 200MB+ where as a bitmap is just 4.6MB.4. Collect dead tuples in that 1GB chunk. Also collect stats so that we know about the most optimal representation.5. At the end of 1GB scan, if no dead tuples found, set the chunk pointer to NULL, move to next chunk and restart step 4. If dead tuples found, then check: a. If bitmap can be further compressed by using less number of bits per page. If so, allocate a new bitmap and compress the bitmap. b. If TID array will be a more compact representation. If so, allocate a TID array of right size and convert bitmap into an array. c. Set chunk pointer to whichever representation we choose (of course add headers etc to interpret the representation)6. Continue until we consume all m_w_m or end-of-table is reached. If we consume all m_w_m then do a round of index cleanup and restart.I also realised that we can compact the TID array in step (b) above because we only need to store 17 bits for block numbers (we already know which 1GB segment they belong to). Given that usable offsets are also just 13 bits, TID array needs only 4 bytes per TID instead of 6. Many people are working on implementing different ideas, and I can volunteer to write a patch on these lines unless someone wants to do that.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Fri, 16 Sep 2016 09:09:10 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Sep 16, 2016 at 9:09 AM, Pavan Deolasee <pavan.deolasee@gmail.com>\nwrote:\n\n>\n> I also realised that we can compact the TID array in step (b) above\n> because we only need to store 17 bits for block numbers (we already know\n> which 1GB segment they belong to). Given that usable offsets are also just\n> 13 bits, TID array needs only 4 bytes per TID instead of 6.\n>\n>\nActually this seems like a clear savings of at least 30% for all use cases,\nat the cost of allocating in smaller chunks and doing some transformations.\nBut given the problem we are trying to solve, seems like a small price to\npay.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Fri, Sep 16, 2016 at 9:09 AM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:I also realised that we can compact the TID array in step (b) above because we only need to store 17 bits for block numbers (we already know which 1GB segment they belong to). Given that usable offsets are also just 13 bits, TID array needs only 4 bytes per TID instead of 6. Actually this seems like a clear savings of at least 30% for all use cases, at the cost of allocating in smaller chunks and doing some transformations. But given the problem we are trying to solve, seems like a small price to pay.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Fri, 16 Sep 2016 10:22:22 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\n<pavan.deolasee@gmail.com> wrote:\n> But I actually wonder if we are over engineering things and overestimating\n> cost of memmove etc. How about this simpler approach:\n\nDon't forget that you need to handle the case where\nmaintenance_work_mem is quite small.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 16 Sep 2016 09:33:12 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Sep 16, 2016 at 7:03 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n\n> On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\n> <pavan.deolasee@gmail.com> wrote:\n> > But I actually wonder if we are over engineering things and\n> overestimating\n> > cost of memmove etc. How about this simpler approach:\n>\n> Don't forget that you need to handle the case where\n> maintenance_work_mem is quite small.\n>\n>\nHow small? The default IIRC these days is 64MB and minimum is 1MB. I think\nwe can do some special casing for very small values and ensure that things\nat the very least work and hopefully don't regress for them.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Fri, Sep 16, 2016 at 7:03 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\n<pavan.deolasee@gmail.com> wrote:\n> But I actually wonder if we are over engineering things and overestimating\n> cost of memmove etc. How about this simpler approach:\n\nDon't forget that you need to handle the case where\nmaintenance_work_mem is quite small.\nHow small? The default IIRC these days is 64MB and minimum is 1MB. I think we can do some special casing for very small values and ensure that things at the very least work and hopefully don't regress for them. Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Fri, 16 Sep 2016 19:17:14 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Sep 16, 2016 at 9:47 AM, Pavan Deolasee\n<pavan.deolasee@gmail.com> wrote:\n> On Fri, Sep 16, 2016 at 7:03 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\n>> <pavan.deolasee@gmail.com> wrote:\n>> > But I actually wonder if we are over engineering things and\n>> > overestimating\n>> > cost of memmove etc. How about this simpler approach:\n>>\n>> Don't forget that you need to handle the case where\n>> maintenance_work_mem is quite small.\n>\n> How small? The default IIRC these days is 64MB and minimum is 1MB. I think\n> we can do some special casing for very small values and ensure that things\n> at the very least work and hopefully don't regress for them.\n\nSounds like you need to handle values as small as 1MB, then.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 16 Sep 2016 09:59:32 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Sep 15, 2016 at 1:16 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Sep 14, 2016 at 12:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>>\n>>> I am kind of doubtful about this whole line of investigation because\n>>> we're basically trying pretty hard to fix something that I'm not sure\n>>> is broken. I do agree that, all other things being equal, the TID\n>>> lookups will probably be faster with a bitmap than with a binary\n>>> search, but maybe not if the table is large and the number of dead\n>>> TIDs is small, because cache efficiency is pretty important. But even\n>>> if it's always faster, does TID lookup speed even really matter to\n>>> overall VACUUM performance? Claudio's early results suggest that it\n>>> might, but maybe that's just a question of some optimization that\n>>> hasn't been done yet.\n>>\n>> FYI, the reported impact was on CPU time, not runtime. There was no\n>> significant difference in runtime (real time), because my test is\n>> heavily I/O bound.\n>>\n>> I tested with a few small tables and there was no significant\n>> difference either, but small tables don't stress the array lookup\n>> anyway so that's expected.\n>>\n>> But on the assumption that some systems may be CPU bound during vacuum\n>> (particularly those able to do more than 300-400MB/s sequential I/O),\n>> in those cases the increased or decreased cost of lazy_tid_reaped will\n>> directly correlate to runtime. It's just none of my systems, which all\n>> run on amazon and is heavily bandwidth constrained (fastest I/O\n>> subsystem I can get my hands on does 200MB/s).\n>\n> Attached is the patch with the multiarray version.\n>\n> The tests are weird. Best case comparison over several runs, to remove\n> the impact of concurrent activity on this host (I couldn't remove all\n> background activity even when running the tests overnight, the distro\n> adds tons of crons and background cleanup tasks it would seem),\n> there's only very mild CPU impact. I'd say insignificant, as it's well\n> below the mean variance.\n\nI reran the tests on a really dedicated system, and with a script that\ncaptured a lot more details about the runs.\n\nThe system isn't impressive, an i5 with a single consumer HD and 8GB\nRAM, but it did the job.\n\nThese tests make more sense, so I bet it was the previous tests that\nwere spoiled by concurrent activity on the host.\n\nAttached is the raw output of the test, the script used to create it,\nand just in case the patch set used. I believe it's the same as the\nlast one I posted, just rebased.\n\nIn the results archive, the .vacuum prefix is the patched version with\nboth patch 1 and 2, .git.ref is just patch 1 (without which the\ntruncate takes unholily long).\n\nGrepping the results a bit, picking an average run out of all runs on\neach scale:\n\nTimings:\n\nPatched:\n\ns100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\ns400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\ns4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\n\nUnpatched:\n\ns100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\ns400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\ns4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\n\nTotal I/O (in MB)\n\nPatched:\n\ns100: R:2.4 - W:5862\ns400: R:1337.4 - W:29385.6\ns4000: R:318631 - W:370154\n\nUnpatched:\n\ns100: R:1412.4 - W:7644.6\ns400: R:3180.6 - W:36281.4\ns4000: R:330683 - W:370391\n\n\nSo, in essence, CPU time didn't get adversely affected. If anything,\nit got improved by about 20% on the biggest case (scale 4000).\n\nWhile total runtime didn't change much, I believe this is only due to\nthe fact that the index is perfectly correlated (clustered?) since\nit's a pristine index, so index scans either remove or skip full\npages, never leaving things half-way. A bloated index would probably\nshow a substantially different behavior, I'll try to get a script that\ndoes it by running pgbench a while before the vacuum or something like\nthat.\n\nHowever, the total I/O metric already shows remarkable improvement.\nThis metric is measuring all the I/O including pgbench init, the\ninitial vacuum pgbench init does, the delete and the final vacuum. So\nit's not just the I/O for the vacuum itself, but the whole run. We can\nsee the patched version reading a lot less (less scans over the\nindexes will do that), and in some cases writing less too (again, less\nindex scans may be performing less redundant writes when cleaning\nup/reclaiming index pages).\n\nI'll post when I get the results for the bloated case, but I believe\nthis already shows substantial improvement as is.\n\nThis approach can later be improved upon by turning tid segments into\nbitmaps if they're packed densely enough, but I believe this patch\nrepresents a sensible first step before attempting that.\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 26 Oct 2016 17:25:23 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Oct 27, 2016 at 5:25 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Thu, Sep 15, 2016 at 1:16 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Wed, Sep 14, 2016 at 12:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>>>\n>>>> I am kind of doubtful about this whole line of investigation because\n>>>> we're basically trying pretty hard to fix something that I'm not sure\n>>>> is broken. I do agree that, all other things being equal, the TID\n>>>> lookups will probably be faster with a bitmap than with a binary\n>>>> search, but maybe not if the table is large and the number of dead\n>>>> TIDs is small, because cache efficiency is pretty important. But even\n>>>> if it's always faster, does TID lookup speed even really matter to\n>>>> overall VACUUM performance? Claudio's early results suggest that it\n>>>> might, but maybe that's just a question of some optimization that\n>>>> hasn't been done yet.\n>>>\n>>> FYI, the reported impact was on CPU time, not runtime. There was no\n>>> significant difference in runtime (real time), because my test is\n>>> heavily I/O bound.\n>>>\n>>> I tested with a few small tables and there was no significant\n>>> difference either, but small tables don't stress the array lookup\n>>> anyway so that's expected.\n>>>\n>>> But on the assumption that some systems may be CPU bound during vacuum\n>>> (particularly those able to do more than 300-400MB/s sequential I/O),\n>>> in those cases the increased or decreased cost of lazy_tid_reaped will\n>>> directly correlate to runtime. It's just none of my systems, which all\n>>> run on amazon and is heavily bandwidth constrained (fastest I/O\n>>> subsystem I can get my hands on does 200MB/s).\n>>\n>> Attached is the patch with the multiarray version.\n>>\n>> The tests are weird. Best case comparison over several runs, to remove\n>> the impact of concurrent activity on this host (I couldn't remove all\n>> background activity even when running the tests overnight, the distro\n>> adds tons of crons and background cleanup tasks it would seem),\n>> there's only very mild CPU impact. I'd say insignificant, as it's well\n>> below the mean variance.\n>\n> I reran the tests on a really dedicated system, and with a script that\n> captured a lot more details about the runs.\n>\n> The system isn't impressive, an i5 with a single consumer HD and 8GB\n> RAM, but it did the job.\n>\n> These tests make more sense, so I bet it was the previous tests that\n> were spoiled by concurrent activity on the host.\n>\n> Attached is the raw output of the test, the script used to create it,\n> and just in case the patch set used. I believe it's the same as the\n> last one I posted, just rebased.\n\nI glanced at the patches but the both patches don't obey the coding\nstyle of PostgreSQL.\nPlease refer to [1].\n\n[1] http://wiki.postgresql.org/wiki/Developer_FAQ#What.27s_the_formatting_style_used_in_PostgreSQL_source_code.3F.\n\n>\n> In the results archive, the .vacuum prefix is the patched version with\n> both patch 1 and 2, .git.ref is just patch 1 (without which the\n> truncate takes unholily long).\n\nDid you measure the performance benefit of 0001 patch by comparing\nHEAD with HEAD+0001 patch?\n\n> Grepping the results a bit, picking an average run out of all runs on\n> each scale:\n>\n> Timings:\n>\n> Patched:\n>\n> s100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\n> s400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\n> s4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\n>\n> Unpatched:\n>\n> s100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\n> s400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\n> s4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\n>\n> Total I/O (in MB)\n>\n> Patched:\n>\n> s100: R:2.4 - W:5862\n> s400: R:1337.4 - W:29385.6\n> s4000: R:318631 - W:370154\n>\n> Unpatched:\n>\n> s100: R:1412.4 - W:7644.6\n> s400: R:3180.6 - W:36281.4\n> s4000: R:330683 - W:370391\n>\n>\n> So, in essence, CPU time didn't get adversely affected. If anything,\n> it got improved by about 20% on the biggest case (scale 4000).\n\nAnd this test case deletes all tuples in relation and then measure\nduration of vacuum.\nIt would not be effect much in practical use case.\n\n> While total runtime didn't change much, I believe this is only due to\n> the fact that the index is perfectly correlated (clustered?) since\n> it's a pristine index, so index scans either remove or skip full\n> pages, never leaving things half-way. A bloated index would probably\n> show a substantially different behavior, I'll try to get a script that\n> does it by running pgbench a while before the vacuum or something like\n> that.\n>\n> However, the total I/O metric already shows remarkable improvement.\n> This metric is measuring all the I/O including pgbench init, the\n> initial vacuum pgbench init does, the delete and the final vacuum. So\n> it's not just the I/O for the vacuum itself, but the whole run. We can\n> see the patched version reading a lot less (less scans over the\n> indexes will do that), and in some cases writing less too (again, less\n> index scans may be performing less redundant writes when cleaning\n> up/reclaiming index pages).\n\nWhat value of maintenance_work_mem did you use for this test? Since\nDeadTuplesSegment struct still stores array of ItemPointerData(6byte)\nrepresenting dead tuple I supposed that the frequency of index vacuum\ndoes not change. But according to the test result, a index vacuum is\ninvoked once and removes 400000000 rows at the time. It means that the\nvacuum stored about 2289 MB memory during heap vacuum. On the other\nside, the result of test without 0002 patch show that a index vacuum\nremove 178956737 rows at the time, which means 1GB memory was used.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 18 Nov 2016 02:34:50 +0900","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Nov 17, 2016 at 2:34 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> I glanced at the patches but the both patches don't obey the coding\n> style of PostgreSQL.\n> Please refer to [1].\n>\n> [1] http://wiki.postgresql.org/wiki/Developer_FAQ#What.27s_the_formatting_style_used_in_PostgreSQL_source_code.3F.\n\nI thought I had. I'll go through that list to check what I missed.\n\n>> In the results archive, the .vacuum prefix is the patched version with\n>> both patch 1 and 2, .git.ref is just patch 1 (without which the\n>> truncate takes unholily long).\n>\n> Did you measure the performance benefit of 0001 patch by comparing\n> HEAD with HEAD+0001 patch?\n\nNot the whole test, but yes. Without the 0001 patch the backward scan\nstep during truncate goes between 3 and 5 times slower. I don't have\ntimings because the test never finished without the patch. It would\nhave finished, but it would have taken about a day.\n\n>> Grepping the results a bit, picking an average run out of all runs on\n>> each scale:\n>>\n>> Timings:\n>>\n>> Patched:\n>>\n>> s100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\n>> s400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\n>> s4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\n>>\n>> Unpatched:\n>>\n>> s100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\n>> s400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\n>> s4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\n>>\n>> Total I/O (in MB)\n>>\n>> Patched:\n>>\n>> s100: R:2.4 - W:5862\n>> s400: R:1337.4 - W:29385.6\n>> s4000: R:318631 - W:370154\n>>\n>> Unpatched:\n>>\n>> s100: R:1412.4 - W:7644.6\n>> s400: R:3180.6 - W:36281.4\n>> s4000: R:330683 - W:370391\n>>\n>>\n>> So, in essence, CPU time didn't get adversely affected. If anything,\n>> it got improved by about 20% on the biggest case (scale 4000).\n>\n> And this test case deletes all tuples in relation and then measure\n> duration of vacuum.\n> It would not be effect much in practical use case.\n\nWell, this patch set started because I had to do exactly that, and\nrealized just how inefficient vacuum was in that case.\n\nBut it doesn't mean it won't benefit more realistic use cases. Almost\nany big database ends up hitting this 1GB limit because big tables\ntake very long to vacuum and accumulate a lot of bloat in-between\nvacuums.\n\nIf you have a specific test case in mind I can try to run it.\n\n>> While total runtime didn't change much, I believe this is only due to\n>> the fact that the index is perfectly correlated (clustered?) since\n>> it's a pristine index, so index scans either remove or skip full\n>> pages, never leaving things half-way. A bloated index would probably\n>> show a substantially different behavior, I'll try to get a script that\n>> does it by running pgbench a while before the vacuum or something like\n>> that.\n>>\n>> However, the total I/O metric already shows remarkable improvement.\n>> This metric is measuring all the I/O including pgbench init, the\n>> initial vacuum pgbench init does, the delete and the final vacuum. So\n>> it's not just the I/O for the vacuum itself, but the whole run. We can\n>> see the patched version reading a lot less (less scans over the\n>> indexes will do that), and in some cases writing less too (again, less\n>> index scans may be performing less redundant writes when cleaning\n>> up/reclaiming index pages).\n>\n> What value of maintenance_work_mem did you use for this test?\n\n4GB on both, patched and HEAD.\n\n> Since\n> DeadTuplesSegment struct still stores array of ItemPointerData(6byte)\n> representing dead tuple I supposed that the frequency of index vacuum\n> does not change. But according to the test result, a index vacuum is\n> invoked once and removes 400000000 rows at the time. It means that the\n> vacuum stored about 2289 MB memory during heap vacuum. On the other\n> side, the result of test without 0002 patch show that a index vacuum\n> remove 178956737 rows at the time, which means 1GB memory was used.\n\n1GB is a hardcoded limit on HEAD for vacuum work mem. This patch\nremoves that limit and lets vacuum use all the memory the user gave to\nvacuum.\n\nIn the test, in both cases, 4GB was used as maintenance_work_mem\nvalue, but HEAD cannot use all the 4GB, and it will limit itself to\njust 1GB.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 17 Nov 2016 14:51:27 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Nov 17, 2016 at 2:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Thu, Nov 17, 2016 at 2:34 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>> I glanced at the patches but the both patches don't obey the coding\n>> style of PostgreSQL.\n>> Please refer to [1].\n>>\n>> [1] http://wiki.postgresql.org/wiki/Developer_FAQ#What.27s_the_formatting_style_used_in_PostgreSQL_source_code.3F.\n>\n> I thought I had. I'll go through that list to check what I missed.\n\nAttached is patch 0002 with pgindent applied over it\n\nI don't think there's any other formatting issue, but feel free to\npoint a finger to it if I missed any\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 17 Nov 2016 15:42:55 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> Attached is patch 0002 with pgindent applied over it\n>\n> I don't think there's any other formatting issue, but feel free to\n> point a finger to it if I missed any\n\nHmm, I had imagined making all of the segments the same size rather\nthan having the size grow exponentially. The whole point of this is\nto save memory, and even in the worst case you don't end up with that\nmany segments as long as you pick a reasonable base size (e.g. 64MB).\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 17 Nov 2016 16:34:55 -0500","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> Attached is patch 0002 with pgindent applied over it\n>\n> I don't think there's any other formatting issue, but feel free to\n> point a finger to it if I missed any\n\nHmm, I had imagined making all of the segments the same size rather\nthan having the size grow exponentially. The whole point of this is\nto save memory, and even in the worst case you don't end up with that\nmany segments as long as you pick a reasonable base size (e.g. 64MB).\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 17 Nov 2016 16:38:50 -0500","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> Attached is patch 0002 with pgindent applied over it\n>>\n>> I don't think there's any other formatting issue, but feel free to\n>> point a finger to it if I missed any\n>\n> Hmm, I had imagined making all of the segments the same size rather\n> than having the size grow exponentially. The whole point of this is\n> to save memory, and even in the worst case you don't end up with that\n> many segments as long as you pick a reasonable base size (e.g. 64MB).\n\nWastage is bound by a fraction of the total required RAM, that is,\nit's proportional to the amount of required RAM, not the amount\nallocated. So it should still be fine, and the exponential strategy\nshould improve lookup performance considerably.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 17 Nov 2016 18:54:55 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> Attached is patch 0002 with pgindent applied over it\n>>>\n>>> I don't think there's any other formatting issue, but feel free to\n>>> point a finger to it if I missed any\n>>\n>> Hmm, I had imagined making all of the segments the same size rather\n>> than having the size grow exponentially. The whole point of this is\n>> to save memory, and even in the worst case you don't end up with that\n>> many segments as long as you pick a reasonable base size (e.g. 64MB).\n>\n> Wastage is bound by a fraction of the total required RAM, that is,\n> it's proportional to the amount of required RAM, not the amount\n> allocated. So it should still be fine, and the exponential strategy\n> should improve lookup performance considerably.\n\nI'm concerned that it could use repalloc for large memory area when\nvacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\nand slow. What about using semi-fixed memroy space without repalloc;\nAllocate the array of ItemPointerData array, and each ItemPointerData\narray stores the dead tuple locations. The size of ItemPointerData\narray starts with small size (e.g. 16MB or 32MB). After we used an\narray up, we then allocate next segment with twice size as previous\nsegment. But to prevent over allocating memory, it would be better to\nset a limit of allocating size of ItemPointerData array to 512MB or\n1GB. We could expand array of array using repalloc if needed, but it\nwould not be happend much. Other design is similar to current your\npatch; the offset of the array of array and the offset of a\nItemPointerData array control current location, which are cleared\nafter finished reclaiming garbage on heap and index. And allocated\narray is re-used by subsequent scanning heap.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 22 Nov 2016 02:15:20 +0900","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Nov 21, 2016 at 2:15 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>>> Attached is patch 0002 with pgindent applied over it\n>>>>\n>>>> I don't think there's any other formatting issue, but feel free to\n>>>> point a finger to it if I missed any\n>>>\n>>> Hmm, I had imagined making all of the segments the same size rather\n>>> than having the size grow exponentially. The whole point of this is\n>>> to save memory, and even in the worst case you don't end up with that\n>>> many segments as long as you pick a reasonable base size (e.g. 64MB).\n>>\n>> Wastage is bound by a fraction of the total required RAM, that is,\n>> it's proportional to the amount of required RAM, not the amount\n>> allocated. So it should still be fine, and the exponential strategy\n>> should improve lookup performance considerably.\n>\n> I'm concerned that it could use repalloc for large memory area when\n> vacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\n> and slow.\n\nHow large?\n\nThat array cannot be very large. It contains pointers to\nexponentially-growing arrays, but the repalloc'd array itself is\nsmall: one struct per segment, each segment starts at 128MB and grows\nexponentially.\n\nIn fact, IIRC, it can be proven that such a repalloc strategy has an\namortized cost of O(log log n) per tuple. If it repallocd the whole\ntid array it would be O(log n), but since it handles only pointers to\nsegments of exponentially growing tuples it becomes O(log log n).\n\nFurthermore, n there is still limited to MAX_INT, which means the cost\nper tuple is bound by O(log log 2^32) = 5. And that's an absolute\nworst case that's ignoring the 128MB constant factor which is indeed\nrelevant.\n\n> What about using semi-fixed memroy space without repalloc;\n> Allocate the array of ItemPointerData array, and each ItemPointerData\n> array stores the dead tuple locations. The size of ItemPointerData\n> array starts with small size (e.g. 16MB or 32MB). After we used an\n> array up, we then allocate next segment with twice size as previous\n> segment.\n\nThat's what the patch does.\n\n> But to prevent over allocating memory, it would be better to\n> set a limit of allocating size of ItemPointerData array to 512MB or\n> 1GB.\n\nThere already is a limit to 1GB (the maximum amount palloc can allocate)\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 21 Nov 2016 14:53:59 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Nov 22, 2016 at 4:53 AM, Claudio Freire <klaussfreire@gmail.com>\nwrote:\n\n> On Mon, Nov 21, 2016 at 2:15 PM, Masahiko Sawada <sawada.mshk@gmail.com>\n> wrote:\n> > On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com>\n> wrote:\n> >> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com>\n> wrote:\n> >>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <\n> klaussfreire@gmail.com> wrote:\n> >>>> Attached is patch 0002 with pgindent applied over it\n> >>>>\n> >>>> I don't think there's any other formatting issue, but feel free to\n> >>>> point a finger to it if I missed any\n> >>>\n> >>> Hmm, I had imagined making all of the segments the same size rather\n> >>> than having the size grow exponentially. The whole point of this is\n> >>> to save memory, and even in the worst case you don't end up with that\n> >>> many segments as long as you pick a reasonable base size (e.g. 64MB).\n> >>\n> >> Wastage is bound by a fraction of the total required RAM, that is,\n> >> it's proportional to the amount of required RAM, not the amount\n> >> allocated. So it should still be fine, and the exponential strategy\n> >> should improve lookup performance considerably.\n> >\n> > I'm concerned that it could use repalloc for large memory area when\n> > vacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\n> > and slow.\n>\n> How large?\n>\n> That array cannot be very large. It contains pointers to\n> exponentially-growing arrays, but the repalloc'd array itself is\n> small: one struct per segment, each segment starts at 128MB and grows\n> exponentially.\n>\n> In fact, IIRC, it can be proven that such a repalloc strategy has an\n> amortized cost of O(log log n) per tuple. If it repallocd the whole\n> tid array it would be O(log n), but since it handles only pointers to\n> segments of exponentially growing tuples it becomes O(log log n).\n>\n> Furthermore, n there is still limited to MAX_INT, which means the cost\n> per tuple is bound by O(log log 2^32) = 5. And that's an absolute\n> worst case that's ignoring the 128MB constant factor which is indeed\n> relevant.\n>\n> > What about using semi-fixed memroy space without repalloc;\n> > Allocate the array of ItemPointerData array, and each ItemPointerData\n> > array stores the dead tuple locations. The size of ItemPointerData\n> > array starts with small size (e.g. 16MB or 32MB). After we used an\n> > array up, we then allocate next segment with twice size as previous\n> > segment.\n>\n> That's what the patch does.\n>\n> > But to prevent over allocating memory, it would be better to\n> > set a limit of allocating size of ItemPointerData array to 512MB or\n> > 1GB.\n>\n> There already is a limit to 1GB (the maximum amount palloc can allocate)\n>\n>\nMoved to next CF with \"needs review\" status.\n\nRegards,\nHari Babu\nFujitsu Australia\n\nOn Tue, Nov 22, 2016 at 4:53 AM, Claudio Freire <klaussfreire@gmail.com> wrote:On Mon, Nov 21, 2016 at 2:15 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>>> Attached is patch 0002 with pgindent applied over it\n>>>>\n>>>> I don't think there's any other formatting issue, but feel free to\n>>>> point a finger to it if I missed any\n>>>\n>>> Hmm, I had imagined making all of the segments the same size rather\n>>> than having the size grow exponentially. The whole point of this is\n>>> to save memory, and even in the worst case you don't end up with that\n>>> many segments as long as you pick a reasonable base size (e.g. 64MB).\n>>\n>> Wastage is bound by a fraction of the total required RAM, that is,\n>> it's proportional to the amount of required RAM, not the amount\n>> allocated. So it should still be fine, and the exponential strategy\n>> should improve lookup performance considerably.\n>\n> I'm concerned that it could use repalloc for large memory area when\n> vacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\n> and slow.\n\nHow large?\n\nThat array cannot be very large. It contains pointers to\nexponentially-growing arrays, but the repalloc'd array itself is\nsmall: one struct per segment, each segment starts at 128MB and grows\nexponentially.\n\nIn fact, IIRC, it can be proven that such a repalloc strategy has an\namortized cost of O(log log n) per tuple. If it repallocd the whole\ntid array it would be O(log n), but since it handles only pointers to\nsegments of exponentially growing tuples it becomes O(log log n).\n\nFurthermore, n there is still limited to MAX_INT, which means the cost\nper tuple is bound by O(log log 2^32) = 5. And that's an absolute\nworst case that's ignoring the 128MB constant factor which is indeed\nrelevant.\n\n> What about using semi-fixed memroy space without repalloc;\n> Allocate the array of ItemPointerData array, and each ItemPointerData\n> array stores the dead tuple locations. The size of ItemPointerData\n> array starts with small size (e.g. 16MB or 32MB). After we used an\n> array up, we then allocate next segment with twice size as previous\n> segment.\n\nThat's what the patch does.\n\n> But to prevent over allocating memory, it would be better to\n> set a limit of allocating size of ItemPointerData array to 512MB or\n> 1GB.\n\nThere already is a limit to 1GB (the maximum amount palloc can allocate)\nMoved to next CF with \"needs review\" status.Regards,Hari BabuFujitsu Australia","msg_date":"Mon, 5 Dec 2016 13:29:01 +1100","msg_from":"Haribabu Kommi <kommi.haribabu@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"The following review has been posted through the commitfest application:\nmake installcheck-world: tested, failed\nImplements feature: not tested\nSpec compliant: not tested\nDocumentation: not tested\n\nHi,\r\nI haven't read through the thread yet, just tried to apply the patch and run tests.\r\nAnd it seems that the last attached version is outdated now. It doesn't apply to the master\r\nand after I've tried to fix merge conflict, it segfaults at initdb. \r\n\r\nSo, looking forward to a new version for review.\n\nThe new status of this patch is: Waiting on Author\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 22 Dec 2016 15:15:27 +0000","msg_from":"Anastasia Lubennikova <lubennikovaav@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\n<lubennikovaav@gmail.com> wrote:\n> The following review has been posted through the commitfest application:\n> make installcheck-world: tested, failed\n> Implements feature: not tested\n> Spec compliant: not tested\n> Documentation: not tested\n>\n> Hi,\n> I haven't read through the thread yet, just tried to apply the patch and run tests.\n> And it seems that the last attached version is outdated now. It doesn't apply to the master\n> and after I've tried to fix merge conflict, it segfaults at initdb.\n\n\nI'll rebase when I get some time to do it and post an updated version\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 22 Dec 2016 12:22:25 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Dec 22, 2016 at 12:22 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\n> <lubennikovaav@gmail.com> wrote:\n>> The following review has been posted through the commitfest application:\n>> make installcheck-world: tested, failed\n>> Implements feature: not tested\n>> Spec compliant: not tested\n>> Documentation: not tested\n>>\n>> Hi,\n>> I haven't read through the thread yet, just tried to apply the patch and run tests.\n>> And it seems that the last attached version is outdated now. It doesn't apply to the master\n>> and after I've tried to fix merge conflict, it segfaults at initdb.\n>\n>\n> I'll rebase when I get some time to do it and post an updated version\n\nAttached rebased patches. I called them both v3 to be consistent.\n\nI'm not sure how you ran it, but this works fine for me:\n\n./configure --enable-debug --enable-cassert\nmake clean\nmake check\n\n... after a while ...\n\n=======================\n All 168 tests passed.\n=======================\n\nI reckon the above is equivalent to installcheck, but doesn't require\nsudo or actually installing the server, so installcheck should work\nassuming the install went ok.\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 22 Dec 2016 15:18:07 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"22.12.2016 21:18, Claudio Freire:\n> On Thu, Dec 22, 2016 at 12:22 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\n>> <lubennikovaav@gmail.com> wrote:\n>>> The following review has been posted through the commitfest application:\n>>> make installcheck-world: tested, failed\n>>> Implements feature: not tested\n>>> Spec compliant: not tested\n>>> Documentation: not tested\n>>>\n>>> Hi,\n>>> I haven't read through the thread yet, just tried to apply the patch and run tests.\n>>> And it seems that the last attached version is outdated now. It doesn't apply to the master\n>>> and after I've tried to fix merge conflict, it segfaults at initdb.\n>>\n>> I'll rebase when I get some time to do it and post an updated version\n> Attached rebased patches. I called them both v3 to be consistent.\n>\n> I'm not sure how you ran it, but this works fine for me:\n>\n> ./configure --enable-debug --enable-cassert\n> make clean\n> make check\n>\n> ... after a while ...\n>\n> =======================\n> All 168 tests passed.\n> =======================\n>\n> I reckon the above is equivalent to installcheck, but doesn't require\n> sudo or actually installing the server, so installcheck should work\n> assuming the install went ok.\n\nI found the reason. I configure postgres with CFLAGS=\"-O0\" and it causes \nSegfault on initdb.\nIt works fine and passes tests with default configure flags, but I'm \npretty sure that we should fix segfault before testing the feature.\nIf you need it, I'll send a core dump.\n\n-- \nAnastasia Lubennikova\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 23 Dec 2016 19:39:02 +0300","msg_from":"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n>> On Thu, Dec 22, 2016 at 12:22 PM, Claudio Freire <klaussfreire@gmail.com>\n>> wrote:\n>>>\n>>> On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\n>>> <lubennikovaav@gmail.com> wrote:\n>>>>\n>>>> The following review has been posted through the commitfest application:\n>>>> make installcheck-world: tested, failed\n>>>> Implements feature: not tested\n>>>> Spec compliant: not tested\n>>>> Documentation: not tested\n>>>>\n>>>> Hi,\n>>>> I haven't read through the thread yet, just tried to apply the patch and\n>>>> run tests.\n>>>> And it seems that the last attached version is outdated now. It doesn't\n>>>> apply to the master\n>>>> and after I've tried to fix merge conflict, it segfaults at initdb.\n>>>\n>>>\n>>> I'll rebase when I get some time to do it and post an updated version\n>>\n>> Attached rebased patches. I called them both v3 to be consistent.\n>>\n>> I'm not sure how you ran it, but this works fine for me:\n>>\n>> ./configure --enable-debug --enable-cassert\n>> make clean\n>> make check\n>>\n>> ... after a while ...\n>>\n>> =======================\n>> All 168 tests passed.\n>> =======================\n>>\n>> I reckon the above is equivalent to installcheck, but doesn't require\n>> sudo or actually installing the server, so installcheck should work\n>> assuming the install went ok.\n>\n>\n> I found the reason. I configure postgres with CFLAGS=\"-O0\" and it causes\n> Segfault on initdb.\n> It works fine and passes tests with default configure flags, but I'm pretty\n> sure that we should fix segfault before testing the feature.\n> If you need it, I'll send a core dump.\n\nI just ran it with CFLAGS=\"-O0\" and it passes all checks too:\n\nCFLAGS='-O0' ./configure --enable-debug --enable-cassert\nmake clean && make -j8 && make check-world\n\nA stacktrace and a thorough description of your build environment\nwould be helpful to understand why it breaks on your system.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 23 Dec 2016 16:54:27 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"23.12.2016 22:54, Claudio Freire:\n> On Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\n> <a.lubennikova@postgrespro.ru> wrote:\n>> I found the reason. I configure postgres with CFLAGS=\"-O0\" and it causes\n>> Segfault on initdb.\n>> It works fine and passes tests with default configure flags, but I'm pretty\n>> sure that we should fix segfault before testing the feature.\n>> If you need it, I'll send a core dump.\n> I just ran it with CFLAGS=\"-O0\" and it passes all checks too:\n>\n> CFLAGS='-O0' ./configure --enable-debug --enable-cassert\n> make clean && make -j8 && make check-world\n>\n> A stacktrace and a thorough description of your build environment\n> would be helpful to understand why it breaks on your system.\n\nI ran configure using following set of flags:\n ./configure --enable-tap-tests --enable-cassert --enable-debug \n--enable-depend CFLAGS=\"-O0 -g3 -fno-omit-frame-pointer\"\nAnd then ran make check. Here is the stacktrace:\n\nProgram terminated with signal SIGSEGV, Segmentation fault.\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360, \nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n1417 tblk = \nItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n(gdb) bt\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360, \nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n#1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9, \nvacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\001')\n at vacuumlazy.c:1337\n#2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9, \nparams=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\n#3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, \noptions=9, params=0x7ffe0f866310) at vacuum.c:1418\n#4 0x0000000000690122 in vacuum (options=9, relation=0x0, relid=0, \nparams=0x7ffe0f866310, va_cols=0x0, bstrategy=0x1f1c4a8,\n isTopLevel=1 '\\001') at vacuum.c:320\n#5 0x000000000068fd0b in vacuum (options=-1652367447, relation=0x0, \nrelid=3324614038, params=0x1f11bf0, va_cols=0xb59f63,\n bstrategy=0x1f1c620, isTopLevel=0 '\\000') at vacuum.c:150\n#6 0x0000000000852993 in standard_ProcessUtility (parsetree=0x1f07e60, \nqueryString=0x1f07468 \"VACUUM FREEZE;\\n\",\n context=PROCESS_UTILITY_TOPLEVEL, params=0x0, dest=0xea5cc0 \n<debugtupDR>, completionTag=0x7ffe0f866750 \"\") at utility.c:669\n#7 0x00000000008520da in standard_ProcessUtility \n(parsetree=0x401ef6cd8, queryString=0x18 <error: Cannot access memory at \naddress 0x18>,\n context=PROCESS_UTILITY_TOPLEVEL, params=0x68, dest=0x9e5d62 \n<AllocSetFree+60>, completionTag=0x7ffe0f8663f0 \"`~\\360\\001\")\n at utility.c:360\n#8 0x0000000000851161 in PortalRunMulti (portal=0x7ffe0f866750, \nisTopLevel=0 '\\000', setHoldSnapshot=-39 '\\331',\n dest=0x851161 <PortalRunMulti+19>, altdest=0x7ffe0f8664f0, \ncompletionTag=0x1f07e60 \"\\341\\002\") at pquery.c:1219\n#9 0x0000000000851374 in PortalRunMulti (portal=0x1f0a488, isTopLevel=1 \n'\\001', setHoldSnapshot=0 '\\000', dest=0xea5cc0 <debugtupDR>,\n altdest=0xea5cc0 <debugtupDR>, completionTag=0x7ffe0f866750 \"\") at \npquery.c:1345\n#10 0x0000000000850889 in PortalRun (portal=0x1f0a488, \ncount=9223372036854775807, isTopLevel=1 '\\001', dest=0xea5cc0 <debugtupDR>,\n altdest=0xea5cc0 <debugtupDR>, completionTag=0x7ffe0f866750 \"\") at \npquery.c:824\n#11 0x000000000084a4dc in exec_simple_query (query_string=0x1f07468 \n\"VACUUM FREEZE;\\n\") at postgres.c:1113\n#12 0x000000000084e960 in PostgresMain (argc=10, argv=0x1e60a50, \ndbname=0x1e823b0 \"template1\", username=0x1e672a0 \"anastasia\")\n at postgres.c:4091\n#13 0x00000000006f967e in init_locale (categoryname=0x100000000000000 \n<error: Cannot access memory at address 0x100000000000000>,\n category=32766, locale=0xa004692f0 <error: Cannot access memory at \naddress 0xa004692f0>) at main.c:310\n#14 0x00007f1e5f463830 in __libc_start_main (main=0x6f93e1 <main+85>, \nargc=10, argv=0x7ffe0f866a78, init=<optimized out>,\n fini=<optimized out>, rtld_fini=<optimized out>, \nstack_end=0x7ffe0f866a68) at ../csu/libc-start.c:291\n#15 0x0000000000469319 in _start ()\n\ncore file is quite big, so I didn't attach it to the mail. You can \ndownload it here: core dump file \n<https://drive.google.com/open?id=0B-7gUWL5Lg_gX3VlSXBaZzlKTlk>.\n\nHere are some notes about the first patch:\n\n1. prefetchBlkno = blkno & ~0x1f;\n prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\n\nI didn't get it what for we need these tricks. How does it differ from:\nprefetchBlkno = (blkno > 32) ? blkno - 32 : 0;\n\n2. Why do we decrease prefetchBlckno twice?\n\nHere:\n+ prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\nAnd here:\nif (prefetchBlkno >= 32)\n+ prefetchBlkno -= 32;\n\n\nI'll inspect second patch in a few days and write questions about it.\n\n-- \nAnastasia Lubennikova\nPostgres Professional:http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n\n\n\n\n\n 23.12.2016 22:54, Claudio Freire:\n\nOn Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n\n\nI found the reason. I configure postgres with CFLAGS=\"-O0\" and it causes\nSegfault on initdb.\nIt works fine and passes tests with default configure flags, but I'm pretty\nsure that we should fix segfault before testing the feature.\nIf you need it, I'll send a core dump.\n\n\nI just ran it with CFLAGS=\"-O0\" and it passes all checks too:\n\nCFLAGS='-O0' ./configure --enable-debug --enable-cassert\nmake clean && make -j8 && make check-world\n\nA stacktrace and a thorough description of your build environment\nwould be helpful to understand why it breaks on your system.\n\n\n\n I ran configure using following set of flags:\n ./configure --enable-tap-tests --enable-cassert --enable-debug\n --enable-depend CFLAGS=\"-O0 -g3 -fno-omit-frame-pointer\"\n And then ran make check. Here is the stacktrace:\n\n Program terminated with signal SIGSEGV, Segmentation fault.\n #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n 1417 tblk =\n ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n (gdb) bt\n #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360,\n options=9, vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2,\n aggressive=1 '\\001')\n at vacuumlazy.c:1337\n #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360,\n options=9, params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at\n vacuumlazy.c:290\n #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0,\n options=9, params=0x7ffe0f866310) at vacuum.c:1418\n #4 0x0000000000690122 in vacuum (options=9, relation=0x0, relid=0,\n params=0x7ffe0f866310, va_cols=0x0, bstrategy=0x1f1c4a8, \n isTopLevel=1 '\\001') at vacuum.c:320\n #5 0x000000000068fd0b in vacuum (options=-1652367447, relation=0x0,\n relid=3324614038, params=0x1f11bf0, va_cols=0xb59f63, \n bstrategy=0x1f1c620, isTopLevel=0 '\\000') at vacuum.c:150\n #6 0x0000000000852993 in standard_ProcessUtility\n (parsetree=0x1f07e60, queryString=0x1f07468 \"VACUUM FREEZE;\\n\", \n context=PROCESS_UTILITY_TOPLEVEL, params=0x0, dest=0xea5cc0\n <debugtupDR>, completionTag=0x7ffe0f866750 \"\") at\n utility.c:669\n #7 0x00000000008520da in standard_ProcessUtility\n (parsetree=0x401ef6cd8, queryString=0x18 <error: Cannot access\n memory at address 0x18>, \n context=PROCESS_UTILITY_TOPLEVEL, params=0x68, dest=0x9e5d62\n <AllocSetFree+60>, completionTag=0x7ffe0f8663f0 \"`~\\360\\001\")\n at utility.c:360\n #8 0x0000000000851161 in PortalRunMulti (portal=0x7ffe0f866750,\n isTopLevel=0 '\\000', setHoldSnapshot=-39 '\\331', \n dest=0x851161 <PortalRunMulti+19>, altdest=0x7ffe0f8664f0,\n completionTag=0x1f07e60 \"\\341\\002\") at pquery.c:1219\n #9 0x0000000000851374 in PortalRunMulti (portal=0x1f0a488,\n isTopLevel=1 '\\001', setHoldSnapshot=0 '\\000', dest=0xea5cc0\n <debugtupDR>, \n altdest=0xea5cc0 <debugtupDR>,\n completionTag=0x7ffe0f866750 \"\") at pquery.c:1345\n #10 0x0000000000850889 in PortalRun (portal=0x1f0a488,\n count=9223372036854775807, isTopLevel=1 '\\001', dest=0xea5cc0\n <debugtupDR>, \n altdest=0xea5cc0 <debugtupDR>,\n completionTag=0x7ffe0f866750 \"\") at pquery.c:824\n #11 0x000000000084a4dc in exec_simple_query (query_string=0x1f07468\n \"VACUUM FREEZE;\\n\") at postgres.c:1113\n #12 0x000000000084e960 in PostgresMain (argc=10, argv=0x1e60a50,\n dbname=0x1e823b0 \"template1\", username=0x1e672a0 \"anastasia\")\n at postgres.c:4091\n #13 0x00000000006f967e in init_locale\n (categoryname=0x100000000000000 <error: Cannot access memory at\n address 0x100000000000000>, \n category=32766, locale=0xa004692f0 <error: Cannot access\n memory at address 0xa004692f0>) at main.c:310\n #14 0x00007f1e5f463830 in __libc_start_main (main=0x6f93e1\n <main+85>, argc=10, argv=0x7ffe0f866a78, init=<optimized\n out>, \n fini=<optimized out>, rtld_fini=<optimized out>,\n stack_end=0x7ffe0f866a68) at ../csu/libc-start.c:291\n #15 0x0000000000469319 in _start ()\n\n core file is quite big, so I didn't attach it to the mail. You can\n download it here: core\n dump file.\n\n Here are some notes about the first patch:\n\n 1. prefetchBlkno = blkno & ~0x1f;\n prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 :\n 0;\n\n I didn't get it what for we need these tricks. How does it differ\n from:\n prefetchBlkno = (blkno > 32) ? blkno - 32 : 0;\n\n 2. Why do we decrease prefetchBlckno twice?\n\n Here:\n + prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 :\n 0;\n And here:\n if (prefetchBlkno >= 32)\n + prefetchBlkno -= 32;\n \n\n I'll inspect second patch in a few days and write questions about\n it.\n\n-- \nAnastasia Lubennikova\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company","msg_date":"Tue, 27 Dec 2016 16:41:45 +0300","msg_from":"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Anastasia Lubennikova wrote:\n\n> I ran configure using following set of flags:\n> ./configure --enable-tap-tests --enable-cassert --enable-debug\n> --enable-depend CFLAGS=\"-O0 -g3 -fno-omit-frame-pointer\"\n> And then ran make check. Here is the stacktrace:\n> \n> Program terminated with signal SIGSEGV, Segmentation fault.\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n> 1417 tblk =\n> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n\nThis doesn't make sense, since the patch removes the \"tupindex\"\nvariable in that function.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 27 Dec 2016 10:54:42 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Dec 27, 2016 at 10:54 AM, Alvaro Herrera\n<alvherre@2ndquadrant.com> wrote:\n> Anastasia Lubennikova wrote:\n>\n>> I ran configure using following set of flags:\n>> ./configure --enable-tap-tests --enable-cassert --enable-debug\n>> --enable-depend CFLAGS=\"-O0 -g3 -fno-omit-frame-pointer\"\n>> And then ran make check. Here is the stacktrace:\n>>\n>> Program terminated with signal SIGSEGV, Segmentation fault.\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n>> 1417 tblk =\n>> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n>\n> This doesn't make sense, since the patch removes the \"tupindex\"\n> variable in that function.\n\nThe variable is still there. It just has a slightly different meaning\n(index within the current segment, rather than global index).\n\n\nOn Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n> 23.12.2016 22:54, Claudio Freire:\n>\n> On Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\n> <a.lubennikova@postgrespro.ru> wrote:\n>\n> I found the reason. I configure postgres with CFLAGS=\"-O0\" and it causes\n> Segfault on initdb.\n> It works fine and passes tests with default configure flags, but I'm pretty\n> sure that we should fix segfault before testing the feature.\n> If you need it, I'll send a core dump.\n>\n> I just ran it with CFLAGS=\"-O0\" and it passes all checks too:\n>\n> CFLAGS='-O0' ./configure --enable-debug --enable-cassert\n> make clean && make -j8 && make check-world\n>\n> A stacktrace and a thorough description of your build environment\n> would be helpful to understand why it breaks on your system.\n>\n>\n> I ran configure using following set of flags:\n> ./configure --enable-tap-tests --enable-cassert --enable-debug\n> --enable-depend CFLAGS=\"-O0 -g3 -fno-omit-frame-pointer\"\n> And then ran make check. Here is the stacktrace:\n\nSame procedure runs fine on my end.\n\n> core file is quite big, so I didn't attach it to the mail. You can download it here: core dump file.\n\nCan you attach your binary as well? (it needs to be identical to be\nable to inspect the core dump, and quite clearly my build is\ndifferent)\n\nI'll keep looking for ways it could crash there, but being unable to\nreproduce the crash is a big hindrance, so if you can send the binary\nthat could help speed things up.\n\n\nOn Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n> 1. prefetchBlkno = blkno & ~0x1f;\n> prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\n>\n> I didn't get it what for we need these tricks. How does it differ from:\n> prefetchBlkno = (blkno > 32) ? blkno - 32 : 0;\n\nIt makes all prefetches ranges of 32 blocks aligned to 32-block boundaries.\n\nIt helps since it's at 32 block boundaries that the truncate stops to\ncheck for locking conflicts and abort, guaranteeing no prefetch will\nbe needless (if it goes into that code it *will* read the next 32\nblocks).\n\n> 2. Why do we decrease prefetchBlckno twice?\n>\n> Here:\n> + prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\n> And here:\n> if (prefetchBlkno >= 32)\n> + prefetchBlkno -= 32;\n\nThe first one is outside the loop, it's finding the first prefetch\nrange that is boundary aligned, taking care not to cause underflow.\n\nThe second one is inside the loop, it's moving the prefetch window\ndown as the truncate moves along. Since it's already aligned, it\ndoesn't need to be realigned, just clamped to zero if it happens to\nreach the bottom.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 27 Dec 2016 14:04:12 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n> Program terminated with signal SIGSEGV, Segmentation fault.\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n> 1417 tblk =\n> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n> (gdb) bt\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n> #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\n> vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\001')\n> at vacuumlazy.c:1337\n> #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\n> params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\n> #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\n> params=0x7ffe0f866310) at vacuum.c:1418\n\n\nThose line numbers don't match my code.\n\nWhich commit are you based on?\n\nMy tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 27 Dec 2016 14:14:39 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"27.12.2016 16:54, Alvaro Herrera:\n> Anastasia Lubennikova wrote:\n>\n>> I ran configure using following set of flags:\n>> ./configure --enable-tap-tests --enable-cassert --enable-debug\n>> --enable-depend CFLAGS=\"-O0 -g3 -fno-omit-frame-pointer\"\n>> And then ran make check. Here is the stacktrace:\n>>\n>> Program terminated with signal SIGSEGV, Segmentation fault.\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n>> 1417 tblk =\n>> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n> This doesn't make sense, since the patch removes the \"tupindex\"\n> variable in that function.\n>\n\nSorry, I didn't get what you mean.\n\nIn 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\n\n- tupindex = 0;\n- while (tupindex < vacrelstats->num_dead_tuples)\n+ segindex = 0;\n+ tottuples = 0;\n+ for (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; \ntupindex = 0, segindex++)\n {\n\nvariable is still there, it was just moved to the loop.\n\n-- \nAnastasia Lubennikova\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 28 Dec 2016 15:37:04 +0300","msg_from":"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"27.12.2016 20:14, Claudio Freire:\n> On Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\n> <a.lubennikova@postgrespro.ru> wrote:\n>> Program terminated with signal SIGSEGV, Segmentation fault.\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n>> 1417 tblk =\n>> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n>> (gdb) bt\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n>> #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\n>> vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\001')\n>> at vacuumlazy.c:1337\n>> #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\n>> params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\n>> #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\n>> params=0x7ffe0f866310) at vacuum.c:1418\n> Those line numbers don't match my code.\n>\n> Which commit are you based on?\n>\n> My tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\n\nHm, my branch is based on 71f996d22125eb6cfdbee6094f44370aa8dec610 as well.\nI merely applied patches \n0001-Vacuum-prefetch-buffers-on-backward-scan-v3.patch\nand 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\nthen ran configure and make as usual.\nAm I doing something wrong?\n\nAnyway, I found the problem that had caused segfault.\n\nfor (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; \ntupindex = 0, segindex++)\n{\n DeadTuplesSegment *seg = \n&(vacrelstats->dead_tuples.dead_tuples[segindex]);\n int num_dead_tuples = seg->num_dead_tuples;\n\n while (tupindex < num_dead_tuples)\n ...\n\nYou rely on the value of tupindex here, while during the very first pass \nthe 'tupindex' variable\nmay contain any garbage. And it happend that on my system there was \nnegative value\nas I found inspecting core dump:\n\n(gdb) info locals\nnum_dead_tuples = 5\ntottuples = 0\ntupindex = -1819017215\n\nWhich leads to failure in the next line\n tblk = ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n\nThe solution is to move this assignment inside the cycle.\n\nI've read the second patch.\n\n1. What is the reason to inline vac_cmp_itemptr() ?\n\n2. +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage, (128<<20) / \nsizeof(ItemPointerData))\nWhat does 128<<20 mean? Why not 1<<27? I'd ask you to replace it with \nnamed constant,\nor at least add a comment.\n\nI'll share my results of performance testing it in a few days.\n\n-- \nAnastasia Lubennikova\nPostgres Professional:http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n\n\n\n\n\n 27.12.2016 20:14, Claudio Freire:\n\nOn Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n\n\nProgram terminated with signal SIGSEGV, Segmentation fault.\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n1417 tblk =\nItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n(gdb) bt\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n#1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\nvacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\001')\n at vacuumlazy.c:1337\n#2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\nparams=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\n#3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\nparams=0x7ffe0f866310) at vacuum.c:1418\n\n\n\nThose line numbers don't match my code.\n\nWhich commit are you based on?\n\nMy tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\n\n\n\n Hm, my branch is based on 71f996d22125eb6cfdbee6094f44370aa8dec610\n as well.\n I merely applied patches\n 0001-Vacuum-prefetch-buffers-on-backward-scan-v3.patch\n and 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\n then ran configure and make as usual.\n Am I doing something wrong?\n\n Anyway, I found the problem that had caused segfault.\n\n for (segindex = 0; segindex <=\n vacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\n {\n DeadTuplesSegment *seg =\n &(vacrelstats->dead_tuples.dead_tuples[segindex]);\n int num_dead_tuples = seg->num_dead_tuples;\n\n while (tupindex < num_dead_tuples)\n ...\n\n You rely on the value of tupindex here, while during the very first\n pass the 'tupindex' variable\n may contain any garbage. And it happend that on my system there was\n negative value\n as I found inspecting core dump:\n\n (gdb) info locals \n num_dead_tuples = 5\n tottuples = 0\n tupindex = -1819017215\n\n Which leads to failure in the next line\n tblk =\n ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n\n The solution is to move this assignment inside the cycle.\n\n I've read the second patch. \n\n 1. What is the reason to inline vac_cmp_itemptr() ?\n\n 2. +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage,\n (128<<20) / sizeof(ItemPointerData))\n What does 128<<20 mean? Why not 1<<27? I'd ask you to\n replace it with named constant,\n or at least add a comment.\n\n I'll share my results of performance testing it in a few days.\n-- \nAnastasia Lubennikova\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company","msg_date":"Wed, 28 Dec 2016 16:26:54 +0300","msg_from":"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Dec 28, 2016 at 10:26 AM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n> 27.12.2016 20:14, Claudio Freire:\n>\n> On Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\n> <a.lubennikova@postgrespro.ru> wrote:\n>\n> Program terminated with signal SIGSEGV, Segmentation fault.\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n> 1417 tblk =\n> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n> (gdb) bt\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\n> #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\n> vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\001')\n> at vacuumlazy.c:1337\n> #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\n> params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\n> #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\n> params=0x7ffe0f866310) at vacuum.c:1418\n>\n> Those line numbers don't match my code.\n>\n> Which commit are you based on?\n>\n> My tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\n>\n>\n> Hm, my branch is based on 71f996d22125eb6cfdbee6094f44370aa8dec610 as well.\n> I merely applied patches\n> 0001-Vacuum-prefetch-buffers-on-backward-scan-v3.patch\n> and 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\n> then ran configure and make as usual.\n> Am I doing something wrong?\n\nDoesn't sound wrong. Maybe it's my tree the unclean one. I'll have to\ndo a clean checkout to verify.\n\n> Anyway, I found the problem that had caused segfault.\n>\n> for (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; tupindex =\n> 0, segindex++)\n> {\n> DeadTuplesSegment *seg =\n> &(vacrelstats->dead_tuples.dead_tuples[segindex]);\n> int num_dead_tuples = seg->num_dead_tuples;\n>\n> while (tupindex < num_dead_tuples)\n> ...\n>\n> You rely on the value of tupindex here, while during the very first pass the\n> 'tupindex' variable\n> may contain any garbage. And it happend that on my system there was negative\n> value\n> as I found inspecting core dump:\n>\n> (gdb) info locals\n> num_dead_tuples = 5\n> tottuples = 0\n> tupindex = -1819017215\n>\n> Which leads to failure in the next line\n> tblk = ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n>\n> The solution is to move this assignment inside the cycle.\n\nGood catch. I read that line suspecting that very same thing but\nsomehow I was blind to it.\n\n> I've read the second patch.\n>\n> 1. What is the reason to inline vac_cmp_itemptr() ?\n\nPerformance, mostly. By inlining some transformations can be applied\nthat wouldn't be possible otherwise. During the binary search, this\nmatters performance-wise.\n\n> 2. +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage, (128<<20) /\n> sizeof(ItemPointerData))\n> What does 128<<20 mean? Why not 1<<27? I'd ask you to replace it with named\n> constant,\n> or at least add a comment.\n\nI tought it was more readable like that, since 1<<20 is known to be\n\"MB\", that reads as \"128 MB\".\n\nI guess I can add a comment saying so.\n\n> I'll share my results of performance testing it in a few days.\n\nThanks\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 28 Dec 2016 15:41:20 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Dec 28, 2016 at 3:41 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> Anyway, I found the problem that had caused segfault.\n>>\n>> for (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; tupindex =\n>> 0, segindex++)\n>> {\n>> DeadTuplesSegment *seg =\n>> &(vacrelstats->dead_tuples.dead_tuples[segindex]);\n>> int num_dead_tuples = seg->num_dead_tuples;\n>>\n>> while (tupindex < num_dead_tuples)\n>> ...\n>>\n>> You rely on the value of tupindex here, while during the very first pass the\n>> 'tupindex' variable\n>> may contain any garbage. And it happend that on my system there was negative\n>> value\n>> as I found inspecting core dump:\n>>\n>> (gdb) info locals\n>> num_dead_tuples = 5\n>> tottuples = 0\n>> tupindex = -1819017215\n>>\n>> Which leads to failure in the next line\n>> tblk = ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\n>>\n>> The solution is to move this assignment inside the cycle.\n>\n> Good catch. I read that line suspecting that very same thing but\n> somehow I was blind to it.\n\nAttached v4 patches with the requested fixes.\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 28 Dec 2016 17:43:21 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"28.12.2016 23:43, Claudio Freire:\n> Attached v4 patches with the requested fixes.\n\nSorry for being late, but the tests took a lot of time.\n\ncreate table t1 as select i, md5(random()::text) from generate_series(0,400000000) as i;\ncreate index md5_idx ON t1(md5);\nupdate t1 set md5 = md5((random() * (100 + 500))::text);\nvacuum;\n\nPatched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\nwhile for old version it took three passes (1GB+1GB+0.9GB).\nVacuum duration results:\n\nvanilla:\nLOG: duration: 4359006.327 ms statement: vacuum verbose t1;\npatched:\nLOG: duration: 3076827.378 ms statement: vacuum verbose t1;\n\nWe can see 30% vacuum speedup. I should note that this case can be \nconsidered\nas favorable to vanilla vacuum: the table is not that big, it has just \none index\nand disk used is a fast fusionIO. We can expect even more gain on slower \ndisks.\n\nThank you again for the patch. Hope to see it in 10.0.\n\n-- \nAnastasia Lubennikova\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n\n\n\n\n\n 28.12.2016 23:43, Claudio Freire:\n\nAttached v4 patches with the requested fixes.\n\n\n\n Sorry for being late, but the tests took a lot of time.\ncreate table t1 as select i, md5(random()::text) from generate_series(0,400000000) as i;\ncreate index md5_idx ON t1(md5);\nupdate t1 set md5 = md5((random() * (100 + 500))::text);\nvacuum;\n\n Patched vacuum used 2.9Gb of memory and vacuumed the index in one\n pass,\n while for old version it took three passes (1GB+1GB+0.9GB).\n Vacuum duration results:\nvanilla:\nLOG: duration: 4359006.327 ms statement: vacuum verbose t1;\npatched:\nLOG: duration: 3076827.378 ms statement: vacuum verbose t1;\n\n\n We can see 30% vacuum speedup. I should note that this case can be\n considered\n as favorable to vanilla vacuum: the table is not that big, it has\n just one index\n and disk used is a fast fusionIO. We can expect even more gain on\n slower disks.\n\n Thank you again for the patch. Hope to see it in 10.0.\n-- \nAnastasia Lubennikova\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company","msg_date":"Thu, 19 Jan 2017 12:33:57 +0300","msg_from":"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\n<a.lubennikova@postgrespro.ru> wrote:\n> 28.12.2016 23:43, Claudio Freire:\n>\n> Attached v4 patches with the requested fixes.\n>\n>\n> Sorry for being late, but the tests took a lot of time.\n\nI know. Takes me several days to run my test scripts once.\n\n> create table t1 as select i, md5(random()::text) from\n> generate_series(0,400000000) as i;\n> create index md5_idx ON t1(md5);\n> update t1 set md5 = md5((random() * (100 + 500))::text);\n> vacuum;\n>\n> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\n> while for old version it took three passes (1GB+1GB+0.9GB).\n> Vacuum duration results:\n>\n> vanilla:\n> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\n> patched:\n> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\n>\n> We can see 30% vacuum speedup. I should note that this case can be\n> considered\n> as favorable to vanilla vacuum: the table is not that big, it has just one\n> index\n> and disk used is a fast fusionIO. We can expect even more gain on slower\n> disks.\n>\n> Thank you again for the patch. Hope to see it in 10.0.\n\nCool. Thanks for the review and the tests.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 19 Jan 2017 08:31:54 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jan 19, 2017 at 8:31 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\n> <a.lubennikova@postgrespro.ru> wrote:\n>> 28.12.2016 23:43, Claudio Freire:\n>>\n>> Attached v4 patches with the requested fixes.\n>>\n>>\n>> Sorry for being late, but the tests took a lot of time.\n>\n> I know. Takes me several days to run my test scripts once.\n>\n>> create table t1 as select i, md5(random()::text) from\n>> generate_series(0,400000000) as i;\n>> create index md5_idx ON t1(md5);\n>> update t1 set md5 = md5((random() * (100 + 500))::text);\n>> vacuum;\n>>\n>> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\n>> while for old version it took three passes (1GB+1GB+0.9GB).\n>> Vacuum duration results:\n>>\n>> vanilla:\n>> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\n>> patched:\n>> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\n>>\n>> We can see 30% vacuum speedup. I should note that this case can be\n>> considered\n>> as favorable to vanilla vacuum: the table is not that big, it has just one\n>> index\n>> and disk used is a fast fusionIO. We can expect even more gain on slower\n>> disks.\n>>\n>> Thank you again for the patch. Hope to see it in 10.0.\n>\n> Cool. Thanks for the review and the tests.\n>\n\nI encountered a bug with following scenario.\n1. Create table and disable autovacuum on that table.\n2. Make about 200000 dead tuples on the table.\n3. SET maintenance_work_mem TO 1024\n4. VACUUM\n\n@@ -729,7 +759,7 @@ lazy_scan_heap(Relation onerel, int options,\nLVRelStats *vacrelstats,\n * not to reset latestRemovedXid since we want\nthat value to be\n * valid.\n */\n- vacrelstats->num_dead_tuples = 0;\n+ lazy_clear_dead_tuples(vacrelstats);\n vacrelstats->num_index_scans++;\n\n /* Report that we are once again scanning the heap */\n\nI think that we should do vacrelstats->dead_tuples.num_entries = 0 as\nwell in lazy_clear_dead_tuples(). Once the amount of dead tuples\nreached to maintenance_work_mem, lazy_scan_heap can never finish.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 20 Jan 2017 18:24:58 +0900","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"You posted two patches with this preamble:\n\nClaudio Freire wrote:\n\n> Attached is the raw output of the test, the script used to create it,\n> and just in case the patch set used. I believe it's the same as the\n> last one I posted, just rebased.\n\nThere was no discussion whatsoever of the \"prefetch\" patch in this\nthread; and as far as I can see, nobody even mentioned such an idea in\nthe thread. This prefetch patch appeared out of the blue and there was\nno discussion about it that I can see. Now I was about to push it after\nsome minor tweaks, and went to search where was its justification, only\nto see that there was none. Did anybody run tests with this patch?\n\nI attach it now one more time. My version is based on the latest\nClaudio posted at\nhttps://postgr.es/m/CAGTBQpa464RugxYwxLTtDi=Syv9GnGFcJK8uZb2fR6NDDqULaw@mail.gmail.com\nI don't know if there are differences to the version first posted.\nI only changed the magic number 32 to a #define, and added a\nCHECK_FOR_INTERRUPTS in the prefetching loop.\n\nFWIW, I think this patch is completely separate from the maint_work_mem\npatch and should have had its own thread and its own commitfest entry.\nI intend to get a look at the other patch next week, after pushing this\none.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 20 Jan 2017 18:25:18 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Alvaro Herrera wrote:\n\n> There was no discussion whatsoever of the \"prefetch\" patch in this\n> thread; and as far as I can see, nobody even mentioned such an idea in\n> the thread. This prefetch patch appeared out of the blue and there was\n> no discussion about it that I can see. Now I was about to push it after\n> some minor tweaks, and went to search where was its justification, only\n> to see that there was none. Did anybody run tests with this patch?\n> \n> I attach it now one more time. My version is based on the latest\n> Claudio posted at\n> https://postgr.es/m/CAGTBQpa464RugxYwxLTtDi=Syv9GnGFcJK8uZb2fR6NDDqULaw@mail.gmail.com\n> I don't know if there are differences to the version first posted.\n> I only changed the magic number 32 to a #define, and added a\n> CHECK_FOR_INTERRUPTS in the prefetching loop.\n\nAh, I found the justification here:\nhttps://www.postgresql.org/message-id/flat/CAGTBQpa464RugxYwxLTtDi%3DSyv9GnGFcJK8uZb2fR6NDDqULaw%40mail.gmail.com#CAGTBQpbayY-t5-ySW19yQs1dBqvV6dm8dmdpTv_FWXmDC0A0cQ%40mail.gmail.com\napparently the truncate scan is 4x-6x faster with this prefetching.\nNice!\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 20 Jan 2017 18:34:14 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"I pushed this patch after rewriting it rather completely. I added\ntracing notices to inspect the blocks it was prefetching and observed\nthat the original coding was failing to prefetch the final streak of\nblocks in the table, which is an important oversight considering that it\nmay very well be that those are the only blocks to read at all.\n\nI timed vacuuming a 4000-block table in my laptop (single SSD disk;\ndropped FS caches after deleting all rows in table, so that vacuum has\nto read all blocks from disk); it changes from 387ms without patch to\n155ms with patch. I didn't measure how much it takes to run the other\nsteps in the vacuum, but it's clear that the speedup for the truncation\nphase is considerable.\n\n�Thanks, Claudio!\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 23 Jan 2017 13:06:01 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"I think this patch no longer applies because of conflicts with the one I\njust pushed. Please rebase.\n\nThanks\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 23 Jan 2017 13:07:44 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Jan 20, 2017 at 6:24 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> On Thu, Jan 19, 2017 at 8:31 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\n>> <a.lubennikova@postgrespro.ru> wrote:\n>>> 28.12.2016 23:43, Claudio Freire:\n>>>\n>>> Attached v4 patches with the requested fixes.\n>>>\n>>>\n>>> Sorry for being late, but the tests took a lot of time.\n>>\n>> I know. Takes me several days to run my test scripts once.\n>>\n>>> create table t1 as select i, md5(random()::text) from\n>>> generate_series(0,400000000) as i;\n>>> create index md5_idx ON t1(md5);\n>>> update t1 set md5 = md5((random() * (100 + 500))::text);\n>>> vacuum;\n>>>\n>>> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\n>>> while for old version it took three passes (1GB+1GB+0.9GB).\n>>> Vacuum duration results:\n>>>\n>>> vanilla:\n>>> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\n>>> patched:\n>>> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\n>>>\n>>> We can see 30% vacuum speedup. I should note that this case can be\n>>> considered\n>>> as favorable to vanilla vacuum: the table is not that big, it has just one\n>>> index\n>>> and disk used is a fast fusionIO. We can expect even more gain on slower\n>>> disks.\n>>>\n>>> Thank you again for the patch. Hope to see it in 10.0.\n>>\n>> Cool. Thanks for the review and the tests.\n>>\n>\n> I encountered a bug with following scenario.\n> 1. Create table and disable autovacuum on that table.\n> 2. Make about 200000 dead tuples on the table.\n> 3. SET maintenance_work_mem TO 1024\n> 4. VACUUM\n>\n> @@ -729,7 +759,7 @@ lazy_scan_heap(Relation onerel, int options,\n> LVRelStats *vacrelstats,\n> * not to reset latestRemovedXid since we want\n> that value to be\n> * valid.\n> */\n> - vacrelstats->num_dead_tuples = 0;\n> + lazy_clear_dead_tuples(vacrelstats);\n> vacrelstats->num_index_scans++;\n>\n> /* Report that we are once again scanning the heap */\n>\n> I think that we should do vacrelstats->dead_tuples.num_entries = 0 as\n> well in lazy_clear_dead_tuples(). Once the amount of dead tuples\n> reached to maintenance_work_mem, lazy_scan_heap can never finish.\n\nThat's right.\n\nI added a test for it in the attached patch set, which uncovered\nanother bug in lazy_clear_dead_tuples, and took the opportunity to\nrebase.\n\nOn Mon, Jan 23, 2017 at 1:06 PM, Alvaro Herrera\n<alvherre@2ndquadrant.com> wrote:\n> I pushed this patch after rewriting it rather completely. I added\n> tracing notices to inspect the blocks it was prefetching and observed\n> that the original coding was failing to prefetch the final streak of\n> blocks in the table, which is an important oversight considering that it\n> may very well be that those are the only blocks to read at all.\n>\n> I timed vacuuming a 4000-block table in my laptop (single SSD disk;\n> dropped FS caches after deleting all rows in table, so that vacuum has\n> to read all blocks from disk); it changes from 387ms without patch to\n> 155ms with patch. I didn't measure how much it takes to run the other\n> steps in the vacuum, but it's clear that the speedup for the truncation\n> phase is considerable.\n>\n> ĄThanks, Claudio!\n\nCool.\n\nThough it wasn't the first time this idea has been floating around, I\ncan't take all the credit.\n\n\nOn Fri, Jan 20, 2017 at 6:25 PM, Alvaro Herrera\n<alvherre@2ndquadrant.com> wrote:\n> FWIW, I think this patch is completely separate from the maint_work_mem\n> patch and should have had its own thread and its own commitfest entry.\n> I intend to get a look at the other patch next week, after pushing this\n> one.\n\nThat's because it did have it, and was left in limbo due to lack of\ntesting on SSDs. I just had to adopt it here because otherwise tests\ntook way too long.\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 23 Jan 2017 13:49:03 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Jan 24, 2017 at 1:49 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Fri, Jan 20, 2017 at 6:24 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>> On Thu, Jan 19, 2017 at 8:31 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\n>>> <a.lubennikova@postgrespro.ru> wrote:\n>>>> 28.12.2016 23:43, Claudio Freire:\n>>>>\n>>>> Attached v4 patches with the requested fixes.\n>>>>\n>>>>\n>>>> Sorry for being late, but the tests took a lot of time.\n>>>\n>>> I know. Takes me several days to run my test scripts once.\n>>>\n>>>> create table t1 as select i, md5(random()::text) from\n>>>> generate_series(0,400000000) as i;\n>>>> create index md5_idx ON t1(md5);\n>>>> update t1 set md5 = md5((random() * (100 + 500))::text);\n>>>> vacuum;\n>>>>\n>>>> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\n>>>> while for old version it took three passes (1GB+1GB+0.9GB).\n>>>> Vacuum duration results:\n>>>>\n>>>> vanilla:\n>>>> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\n>>>> patched:\n>>>> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\n>>>>\n>>>> We can see 30% vacuum speedup. I should note that this case can be\n>>>> considered\n>>>> as favorable to vanilla vacuum: the table is not that big, it has just one\n>>>> index\n>>>> and disk used is a fast fusionIO. We can expect even more gain on slower\n>>>> disks.\n>>>>\n>>>> Thank you again for the patch. Hope to see it in 10.0.\n>>>\n>>> Cool. Thanks for the review and the tests.\n>>>\n>>\n>> I encountered a bug with following scenario.\n>> 1. Create table and disable autovacuum on that table.\n>> 2. Make about 200000 dead tuples on the table.\n>> 3. SET maintenance_work_mem TO 1024\n>> 4. VACUUM\n>>\n>> @@ -729,7 +759,7 @@ lazy_scan_heap(Relation onerel, int options,\n>> LVRelStats *vacrelstats,\n>> * not to reset latestRemovedXid since we want\n>> that value to be\n>> * valid.\n>> */\n>> - vacrelstats->num_dead_tuples = 0;\n>> + lazy_clear_dead_tuples(vacrelstats);\n>> vacrelstats->num_index_scans++;\n>>\n>> /* Report that we are once again scanning the heap */\n>>\n>> I think that we should do vacrelstats->dead_tuples.num_entries = 0 as\n>> well in lazy_clear_dead_tuples(). Once the amount of dead tuples\n>> reached to maintenance_work_mem, lazy_scan_heap can never finish.\n>\n> That's right.\n>\n> I added a test for it in the attached patch set, which uncovered\n> another bug in lazy_clear_dead_tuples, and took the opportunity to\n> rebase.\n>\n> On Mon, Jan 23, 2017 at 1:06 PM, Alvaro Herrera\n> <alvherre@2ndquadrant.com> wrote:\n>> I pushed this patch after rewriting it rather completely. I added\n>> tracing notices to inspect the blocks it was prefetching and observed\n>> that the original coding was failing to prefetch the final streak of\n>> blocks in the table, which is an important oversight considering that it\n>> may very well be that those are the only blocks to read at all.\n>>\n>> I timed vacuuming a 4000-block table in my laptop (single SSD disk;\n>> dropped FS caches after deleting all rows in table, so that vacuum has\n>> to read all blocks from disk); it changes from 387ms without patch to\n>> 155ms with patch. I didn't measure how much it takes to run the other\n>> steps in the vacuum, but it's clear that the speedup for the truncation\n>> phase is considerable.\n>>\n>> ĄThanks, Claudio!\n>\n> Cool.\n>\n> Though it wasn't the first time this idea has been floating around, I\n> can't take all the credit.\n>\n>\n> On Fri, Jan 20, 2017 at 6:25 PM, Alvaro Herrera\n> <alvherre@2ndquadrant.com> wrote:\n>> FWIW, I think this patch is completely separate from the maint_work_mem\n>> patch and should have had its own thread and its own commitfest entry.\n>> I intend to get a look at the other patch next week, after pushing this\n>> one.\n>\n> That's because it did have it, and was left in limbo due to lack of\n> testing on SSDs. I just had to adopt it here because otherwise tests\n> took way too long.\n\nThank you for updating the patch!\n\n+ /*\n+ * Quickly rule out by lower bound (should happen a lot) Upper bound was\n+ * already checked by segment search\n+ */\n+ if (vac_cmp_itemptr((void *) itemptr, (void *) rseg->dead_tuples) < 0)\n+ return false;\n\nI think that if the above result is 0, we can return true as itemptr\nmatched lower bound item pointer in rseg->dead_tuples.\n\n +typedef struct DeadTuplesSegment\n+{\n+ int num_dead_tuples; /* # of\nentries in the segment */\n+ int max_dead_tuples; /* # of\nentries allocated in the segment */\n+ ItemPointerData last_dead_tuple; /* Copy of the last\ndead tuple (unset\n+\n * until the segment is fully\n+\n * populated) */\n+ unsigned short padding;\n+ ItemPointer dead_tuples; /* Array of dead tuples */\n+} DeadTuplesSegment;\n+\n+typedef struct DeadTuplesMultiArray\n+{\n+ int num_entries; /* current # of entries */\n+ int max_entries; /* total # of slots\nthat can be allocated in\n+ * array */\n+ int num_segs; /* number of\ndead tuple segments allocated */\n+ int last_seg; /* last dead\ntuple segment with data (or 0) */\n+ DeadTuplesSegment *dead_tuples; /* array of num_segs segments */\n+} DeadTuplesMultiArray;\n\nIt's a matter of personal preference but some same dead_tuples\nvariables having different meaning confused me.\nIf we want to access first dead tuple location of first segment, we\nneed to do 'vacrelstats->dead_tuples.dead_tuples.dead_tuples'. For\nexample, 'vacrelstats->dead_tuples.dt_segment.dt_array' is better to\nme.\n\n\n+ nseg->num_dead_tuples = 0;\n+ nseg->max_dead_tuples = 0;\n+ nseg->dead_tuples = NULL;\n+ vacrelstats->dead_tuples.num_segs++;\n+ }\n+ seg = DeadTuplesCurrentSegment(vacrelstats);\n+ }\n+ vacrelstats->dead_tuples.last_seg++;\n+ seg = DeadTuplesCurrentSegment(vacrelstats);\n\nBecause seg is always set later I think the first line starting with\n\"seg = ...\" is not necessary. Thought?\n\n-- \nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 26 Jan 2017 01:54:08 +0900","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Jan 25, 2017 at 1:54 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> Thank you for updating the patch!\n>\n> + /*\n> + * Quickly rule out by lower bound (should happen a lot) Upper bound was\n> + * already checked by segment search\n> + */\n> + if (vac_cmp_itemptr((void *) itemptr, (void *) rseg->dead_tuples) < 0)\n> + return false;\n>\n> I think that if the above result is 0, we can return true as itemptr\n> matched lower bound item pointer in rseg->dead_tuples.\n\nThat's right. Possibly not a great speedup but... why not?\n\n>\n> +typedef struct DeadTuplesSegment\n> +{\n> + int num_dead_tuples; /* # of\n> entries in the segment */\n> + int max_dead_tuples; /* # of\n> entries allocated in the segment */\n> + ItemPointerData last_dead_tuple; /* Copy of the last\n> dead tuple (unset\n> +\n> * until the segment is fully\n> +\n> * populated) */\n> + unsigned short padding;\n> + ItemPointer dead_tuples; /* Array of dead tuples */\n> +} DeadTuplesSegment;\n> +\n> +typedef struct DeadTuplesMultiArray\n> +{\n> + int num_entries; /* current # of entries */\n> + int max_entries; /* total # of slots\n> that can be allocated in\n> + * array */\n> + int num_segs; /* number of\n> dead tuple segments allocated */\n> + int last_seg; /* last dead\n> tuple segment with data (or 0) */\n> + DeadTuplesSegment *dead_tuples; /* array of num_segs segments */\n> +} DeadTuplesMultiArray;\n>\n> It's a matter of personal preference but some same dead_tuples\n> variables having different meaning confused me.\n> If we want to access first dead tuple location of first segment, we\n> need to do 'vacrelstats->dead_tuples.dead_tuples.dead_tuples'. For\n> example, 'vacrelstats->dead_tuples.dt_segment.dt_array' is better to\n> me.\n\nYes, I can see how that could be confusing.\n\nI went for vacrelstats->dead_tuples.dt_segments[i].dt_tids[j]\n\n> + nseg->num_dead_tuples = 0;\n> + nseg->max_dead_tuples = 0;\n> + nseg->dead_tuples = NULL;\n> + vacrelstats->dead_tuples.num_segs++;\n> + }\n> + seg = DeadTuplesCurrentSegment(vacrelstats);\n> + }\n> + vacrelstats->dead_tuples.last_seg++;\n> + seg = DeadTuplesCurrentSegment(vacrelstats);\n>\n> Because seg is always set later I think the first line starting with\n> \"seg = ...\" is not necessary. Thought?\n\nThat's correct.\n\nAttached a v6 with those changes (and rebased).\n\nMake check still passes.\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 25 Jan 2017 17:11:13 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jan 26, 2017 at 5:11 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Jan 25, 2017 at 1:54 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>> Thank you for updating the patch!\n>>\n>> + /*\n>> + * Quickly rule out by lower bound (should happen a lot) Upper bound was\n>> + * already checked by segment search\n>> + */\n>> + if (vac_cmp_itemptr((void *) itemptr, (void *) rseg->dead_tuples) < 0)\n>> + return false;\n>>\n>> I think that if the above result is 0, we can return true as itemptr\n>> matched lower bound item pointer in rseg->dead_tuples.\n>\n> That's right. Possibly not a great speedup but... why not?\n>\n>>\n>> +typedef struct DeadTuplesSegment\n>> +{\n>> + int num_dead_tuples; /* # of\n>> entries in the segment */\n>> + int max_dead_tuples; /* # of\n>> entries allocated in the segment */\n>> + ItemPointerData last_dead_tuple; /* Copy of the last\n>> dead tuple (unset\n>> +\n>> * until the segment is fully\n>> +\n>> * populated) */\n>> + unsigned short padding;\n>> + ItemPointer dead_tuples; /* Array of dead tuples */\n>> +} DeadTuplesSegment;\n>> +\n>> +typedef struct DeadTuplesMultiArray\n>> +{\n>> + int num_entries; /* current # of entries */\n>> + int max_entries; /* total # of slots\n>> that can be allocated in\n>> + * array */\n>> + int num_segs; /* number of\n>> dead tuple segments allocated */\n>> + int last_seg; /* last dead\n>> tuple segment with data (or 0) */\n>> + DeadTuplesSegment *dead_tuples; /* array of num_segs segments */\n>> +} DeadTuplesMultiArray;\n>>\n>> It's a matter of personal preference but some same dead_tuples\n>> variables having different meaning confused me.\n>> If we want to access first dead tuple location of first segment, we\n>> need to do 'vacrelstats->dead_tuples.dead_tuples.dead_tuples'. For\n>> example, 'vacrelstats->dead_tuples.dt_segment.dt_array' is better to\n>> me.\n>\n> Yes, I can see how that could be confusing.\n>\n> I went for vacrelstats->dead_tuples.dt_segments[i].dt_tids[j]\n\nThank you for updating.\nLooks good to me.\n\n>> + nseg->num_dead_tuples = 0;\n>> + nseg->max_dead_tuples = 0;\n>> + nseg->dead_tuples = NULL;\n>> + vacrelstats->dead_tuples.num_segs++;\n>> + }\n>> + seg = DeadTuplesCurrentSegment(vacrelstats);\n>> + }\n>> + vacrelstats->dead_tuples.last_seg++;\n>> + seg = DeadTuplesCurrentSegment(vacrelstats);\n>>\n>> Because seg is always set later I think the first line starting with\n>> \"seg = ...\" is not necessary. Thought?\n>\n> That's correct.\n>\n> Attached a v6 with those changes (and rebased).\n>\n> Make check still passes.\n\nHere is review comment of v6 patch.\n\n----\n * We are willing to use at most maintenance_work_mem (or perhaps\n * autovacuum_work_mem) memory space to keep track of dead tuples. We\n * initially allocate an array of TIDs of that size, with an upper limit that\n * depends on table size (this limit ensures we don't allocate a huge area\n * uselessly for vacuuming small tables). If the array threatens to overflow,\n\nI think that we need to update the above paragraph comment at top of\nvacuumlazy.c file.\n\n----\n+ numtuples = Max(numtuples,\nMaxHeapTuplesPerPage);\n+ numtuples = Min(numtuples, INT_MAX / 2);\n+ numtuples = Min(numtuples, 2 *\npseg->max_dead_tuples);\n+ numtuples = Min(numtuples,\nMaxAllocSize / sizeof(ItemPointerData));\n+ seg->dt_tids = (ItemPointer)\npalloc(sizeof(ItemPointerData) * numtuples);\n\nWhy numtuples is limited to \"INT_MAX / 2\" but not INT_MAX?\n\n----\n@@ -1376,35 +1411,43 @@ lazy_vacuum_heap(Relation onerel, LVRelStats\n*vacrelstats)\n pg_rusage_init(&ru0);\n npages = 0;\n\n- tupindex = 0;\n- while (tupindex < vacrelstats->num_dead_tuples)\n+ segindex = 0;\n+ tottuples = 0;\n+ for (segindex = tupindex = 0; segindex <=\nvacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\n {\n- BlockNumber tblk;\n- Buffer buf;\n- Page page;\n- Size freespace;\n\nThis is a minute thing but tupindex can be define inside of for loop.\n\n----\n@@ -1129,10 +1159,13 @@ lazy_scan_heap(Relation onerel, int options,\nLVRelStats *vacrelstats,\n * instead of doing a second scan.\n */\n if (nindexes == 0 &&\n- vacrelstats->num_dead_tuples > 0)\n+ vacrelstats->dead_tuples.num_entries > 0)\n {\n /* Remove tuples from heap */\n- lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);\n+ Assert(vacrelstats->dead_tuples.last_seg == 0); /*\nShould not need more\n+ *\nthan one segment per\n+ * page */\n\nI'm not sure we need to add Assert() here but it seems to me that the\ncomment and code is not properly correspond and the comment for\nAssert() should be wrote above of Assert() line.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 30 Jan 2017 17:51:52 +0900","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Jan 30, 2017 at 5:51 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> ----\n> * We are willing to use at most maintenance_work_mem (or perhaps\n> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n> * initially allocate an array of TIDs of that size, with an upper limit that\n> * depends on table size (this limit ensures we don't allocate a huge area\n> * uselessly for vacuuming small tables). If the array threatens to overflow,\n>\n> I think that we need to update the above paragraph comment at top of\n> vacuumlazy.c file.\n\nIndeed, I missed that one. Fixing.\n\n>\n> ----\n> + numtuples = Max(numtuples,\n> MaxHeapTuplesPerPage);\n> + numtuples = Min(numtuples, INT_MAX / 2);\n> + numtuples = Min(numtuples, 2 *\n> pseg->max_dead_tuples);\n> + numtuples = Min(numtuples,\n> MaxAllocSize / sizeof(ItemPointerData));\n> + seg->dt_tids = (ItemPointer)\n> palloc(sizeof(ItemPointerData) * numtuples);\n>\n> Why numtuples is limited to \"INT_MAX / 2\" but not INT_MAX?\n\nI forgot to mention this one in the OP.\n\nGoogling around, I found out some implemetations of bsearch break with\narray sizes beyond INT_MAX/2 [1] (they'd overflow when computing the\nmidpoint).\n\nBefore this patch, this bsearch call had no way of reaching that size.\nAn initial version of the patch (the one that allocated a big array\nwith huge allocation) could reach that point, though, so I reduced the\nlimit to play it safe. This latest version is back to the starting\npoint, since it cannot allocate segments bigger than 1GB, but I opted\nto keep playing it safe and leave the reduced limit just in case.\n\n> ----\n> @@ -1376,35 +1411,43 @@ lazy_vacuum_heap(Relation onerel, LVRelStats\n> *vacrelstats)\n> pg_rusage_init(&ru0);\n> npages = 0;\n>\n> - tupindex = 0;\n> - while (tupindex < vacrelstats->num_dead_tuples)\n> + segindex = 0;\n> + tottuples = 0;\n> + for (segindex = tupindex = 0; segindex <=\n> vacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\n> {\n> - BlockNumber tblk;\n> - Buffer buf;\n> - Page page;\n> - Size freespace;\n>\n> This is a minute thing but tupindex can be define inside of for loop.\n\nRight, changing.\n\n>\n> ----\n> @@ -1129,10 +1159,13 @@ lazy_scan_heap(Relation onerel, int options,\n> LVRelStats *vacrelstats,\n> * instead of doing a second scan.\n> */\n> if (nindexes == 0 &&\n> - vacrelstats->num_dead_tuples > 0)\n> + vacrelstats->dead_tuples.num_entries > 0)\n> {\n> /* Remove tuples from heap */\n> - lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);\n> + Assert(vacrelstats->dead_tuples.last_seg == 0); /*\n> Should not need more\n> + *\n> than one segment per\n> + * page */\n>\n> I'm not sure we need to add Assert() here but it seems to me that the\n> comment and code is not properly correspond and the comment for\n> Assert() should be wrote above of Assert() line.\n\nWell, that assert is the one that found the second bug in\nlazy_clear_dead_tuples, so clearly it's not without merit.\n\nI'll rearrange the comments as you ask though.\n\n\nUpdated and rebased v7 attached.\n\n\n[1] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=776671\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 30 Jan 2017 23:05:28 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Jan 31, 2017 at 11:05 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> Updated and rebased v7 attached.\n\nMoved to CF 2017-03.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 1 Feb 2017 14:22:22 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Jan 31, 2017 at 3:05 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Mon, Jan 30, 2017 at 5:51 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>> ----\n>> * We are willing to use at most maintenance_work_mem (or perhaps\n>> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n>> * initially allocate an array of TIDs of that size, with an upper limit that\n>> * depends on table size (this limit ensures we don't allocate a huge area\n>> * uselessly for vacuuming small tables). If the array threatens to overflow,\n>>\n>> I think that we need to update the above paragraph comment at top of\n>> vacuumlazy.c file.\n>\n> Indeed, I missed that one. Fixing.\n>\n>>\n>> ----\n>> + numtuples = Max(numtuples,\n>> MaxHeapTuplesPerPage);\n>> + numtuples = Min(numtuples, INT_MAX / 2);\n>> + numtuples = Min(numtuples, 2 *\n>> pseg->max_dead_tuples);\n>> + numtuples = Min(numtuples,\n>> MaxAllocSize / sizeof(ItemPointerData));\n>> + seg->dt_tids = (ItemPointer)\n>> palloc(sizeof(ItemPointerData) * numtuples);\n>>\n>> Why numtuples is limited to \"INT_MAX / 2\" but not INT_MAX?\n>\n> I forgot to mention this one in the OP.\n>\n> Googling around, I found out some implemetations of bsearch break with\n> array sizes beyond INT_MAX/2 [1] (they'd overflow when computing the\n> midpoint).\n>\n> Before this patch, this bsearch call had no way of reaching that size.\n> An initial version of the patch (the one that allocated a big array\n> with huge allocation) could reach that point, though, so I reduced the\n> limit to play it safe. This latest version is back to the starting\n> point, since it cannot allocate segments bigger than 1GB, but I opted\n> to keep playing it safe and leave the reduced limit just in case.\n>\n\nThanks, I understood.\n\n>> ----\n>> @@ -1376,35 +1411,43 @@ lazy_vacuum_heap(Relation onerel, LVRelStats\n>> *vacrelstats)\n>> pg_rusage_init(&ru0);\n>> npages = 0;\n>>\n>> - tupindex = 0;\n>> - while (tupindex < vacrelstats->num_dead_tuples)\n>> + segindex = 0;\n>> + tottuples = 0;\n>> + for (segindex = tupindex = 0; segindex <=\n>> vacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\n>> {\n>> - BlockNumber tblk;\n>> - Buffer buf;\n>> - Page page;\n>> - Size freespace;\n>>\n>> This is a minute thing but tupindex can be define inside of for loop.\n>\n> Right, changing.\n>\n>>\n>> ----\n>> @@ -1129,10 +1159,13 @@ lazy_scan_heap(Relation onerel, int options,\n>> LVRelStats *vacrelstats,\n>> * instead of doing a second scan.\n>> */\n>> if (nindexes == 0 &&\n>> - vacrelstats->num_dead_tuples > 0)\n>> + vacrelstats->dead_tuples.num_entries > 0)\n>> {\n>> /* Remove tuples from heap */\n>> - lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);\n>> + Assert(vacrelstats->dead_tuples.last_seg == 0); /*\n>> Should not need more\n>> + *\n>> than one segment per\n>> + * page */\n>>\n>> I'm not sure we need to add Assert() here but it seems to me that the\n>> comment and code is not properly correspond and the comment for\n>> Assert() should be wrote above of Assert() line.\n>\n> Well, that assert is the one that found the second bug in\n> lazy_clear_dead_tuples, so clearly it's not without merit.\n>\n> I'll rearrange the comments as you ask though.\n>\n>\n> Updated and rebased v7 attached.\n>\n>\n> [1] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=776671\n\nThank you for updating the patch.\n\nWhole patch looks good to me except for the following one comment.\nThis is the final comment from me.\n\n/*\n * lazy_tid_reaped() -- is a particular tid deletable?\n *\n * This has the right signature to be an IndexBulkDeleteCallback.\n *\n * Assumes dead_tuples array is in sorted order.\n */\nstatic bool\nlazy_tid_reaped(ItemPointer itemptr, void *state)\n{\n LVRelStats *vacrelstats = (LVRelStats *) state;\n\nYou might want to update the comment of lazy_tid_reaped() as well.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 1 Feb 2017 21:47:16 +0100","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> Thank you for updating the patch.\n>\n> Whole patch looks good to me except for the following one comment.\n> This is the final comment from me.\n>\n> /*\n> * lazy_tid_reaped() -- is a particular tid deletable?\n> *\n> * This has the right signature to be an IndexBulkDeleteCallback.\n> *\n> * Assumes dead_tuples array is in sorted order.\n> */\n> static bool\n> lazy_tid_reaped(ItemPointer itemptr, void *state)\n> {\n> LVRelStats *vacrelstats = (LVRelStats *) state;\n>\n> You might want to update the comment of lazy_tid_reaped() as well.\n\nI don't see the mismatch with reality there (if you consider\n\"dead_tples array\" in the proper context, that is, the multiarray).\n\nWhat in particular do you find out of sync there?\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 1 Feb 2017 18:02:07 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>> Thank you for updating the patch.\n>>\n>> Whole patch looks good to me except for the following one comment.\n>> This is the final comment from me.\n>>\n>> /*\n>> * lazy_tid_reaped() -- is a particular tid deletable?\n>> *\n>> * This has the right signature to be an IndexBulkDeleteCallback.\n>> *\n>> * Assumes dead_tuples array is in sorted order.\n>> */\n>> static bool\n>> lazy_tid_reaped(ItemPointer itemptr, void *state)\n>> {\n>> LVRelStats *vacrelstats = (LVRelStats *) state;\n>>\n>> You might want to update the comment of lazy_tid_reaped() as well.\n>\n> I don't see the mismatch with reality there (if you consider\n> \"dead_tples array\" in the proper context, that is, the multiarray).\n>\n> What in particular do you find out of sync there?\n\nThe current lazy_tid_reaped just find a tid from a tid array using\nbsearch but in your patch lazy_tid_reaped handles multiple tid arrays\nand processing method become complicated. So I thought it's better to\nadd the description of this function.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 1 Feb 2017 22:13:34 +0100","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 1, 2017 at 6:13 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>>> Thank you for updating the patch.\n>>>\n>>> Whole patch looks good to me except for the following one comment.\n>>> This is the final comment from me.\n>>>\n>>> /*\n>>> * lazy_tid_reaped() -- is a particular tid deletable?\n>>> *\n>>> * This has the right signature to be an IndexBulkDeleteCallback.\n>>> *\n>>> * Assumes dead_tuples array is in sorted order.\n>>> */\n>>> static bool\n>>> lazy_tid_reaped(ItemPointer itemptr, void *state)\n>>> {\n>>> LVRelStats *vacrelstats = (LVRelStats *) state;\n>>>\n>>> You might want to update the comment of lazy_tid_reaped() as well.\n>>\n>> I don't see the mismatch with reality there (if you consider\n>> \"dead_tples array\" in the proper context, that is, the multiarray).\n>>\n>> What in particular do you find out of sync there?\n>\n> The current lazy_tid_reaped just find a tid from a tid array using\n> bsearch but in your patch lazy_tid_reaped handles multiple tid arrays\n> and processing method become complicated. So I thought it's better to\n> add the description of this function.\n\nAlright, updated with some more remarks that seemed relevant\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 1 Feb 2017 19:55:16 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 1, 2017 at 11:55 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Feb 1, 2017 at 6:13 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>> On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>>>> Thank you for updating the patch.\n>>>>\n>>>> Whole patch looks good to me except for the following one comment.\n>>>> This is the final comment from me.\n>>>>\n>>>> /*\n>>>> * lazy_tid_reaped() -- is a particular tid deletable?\n>>>> *\n>>>> * This has the right signature to be an IndexBulkDeleteCallback.\n>>>> *\n>>>> * Assumes dead_tuples array is in sorted order.\n>>>> */\n>>>> static bool\n>>>> lazy_tid_reaped(ItemPointer itemptr, void *state)\n>>>> {\n>>>> LVRelStats *vacrelstats = (LVRelStats *) state;\n>>>>\n>>>> You might want to update the comment of lazy_tid_reaped() as well.\n>>>\n>>> I don't see the mismatch with reality there (if you consider\n>>> \"dead_tples array\" in the proper context, that is, the multiarray).\n>>>\n>>> What in particular do you find out of sync there?\n>>\n>> The current lazy_tid_reaped just find a tid from a tid array using\n>> bsearch but in your patch lazy_tid_reaped handles multiple tid arrays\n>> and processing method become complicated. So I thought it's better to\n>> add the description of this function.\n>\n> Alright, updated with some more remarks that seemed relevant\n\nThank you for updating the patch.\n\nThe patch looks good to me. There is no review comment from me.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 4 Feb 2017 16:43:04 +0100","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 1, 2017 at 7:55 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Feb 1, 2017 at 6:13 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>> On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n>>>> Thank you for updating the patch.\n>>>>\n>>>> Whole patch looks good to me except for the following one comment.\n>>>> This is the final comment from me.\n>>>>\n>>>> /*\n>>>> * lazy_tid_reaped() -- is a particular tid deletable?\n>>>> *\n>>>> * This has the right signature to be an IndexBulkDeleteCallback.\n>>>> *\n>>>> * Assumes dead_tuples array is in sorted order.\n>>>> */\n>>>> static bool\n>>>> lazy_tid_reaped(ItemPointer itemptr, void *state)\n>>>> {\n>>>> LVRelStats *vacrelstats = (LVRelStats *) state;\n>>>>\n>>>> You might want to update the comment of lazy_tid_reaped() as well.\n>>>\n>>> I don't see the mismatch with reality there (if you consider\n>>> \"dead_tples array\" in the proper context, that is, the multiarray).\n>>>\n>>> What in particular do you find out of sync there?\n>>\n>> The current lazy_tid_reaped just find a tid from a tid array using\n>> bsearch but in your patch lazy_tid_reaped handles multiple tid arrays\n>> and processing method become complicated. So I thought it's better to\n>> add the description of this function.\n>\n> Alright, updated with some more remarks that seemed relevant\n\nI just realized I never updated the early free patch after the\nmultiarray version.\n\nSo attached is a patch that frees the multiarray as early as possible\n(just after finishing with index bulk deletes, right before doing\nindex cleanup and attempting truncation).\n\nThis should make the possibly big amount of memory available to other\nprocesses for the duration of those tasks, which could be a long time\nin some cases.\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 28 Mar 2017 22:46:12 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Hi,\n\nI've *not* read the history of this thread. So I really might be\nmissing some context.\n\n\n> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\n> From: Claudio Freire <klaussfreire@gmail.com>\n> Date: Mon, 12 Sep 2016 23:36:42 -0300\n> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\n> \n> Turn the dead_tuples array into a structure composed of several\n> exponentially bigger arrays, to enable usage of more than 1GB\n> of work mem during vacuum and thus reduce the number of full\n> index scans necessary to remove all dead tids when the memory is\n> available.\n\n> * We are willing to use at most maintenance_work_mem (or perhaps\n> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n> - * initially allocate an array of TIDs of that size, with an upper limit that\n> + * initially allocate an array of TIDs of 128MB, or an upper limit that\n> * depends on table size (this limit ensures we don't allocate a huge area\n> - * uselessly for vacuuming small tables). If the array threatens to overflow,\n> - * we suspend the heap scan phase and perform a pass of index cleanup and page\n> - * compaction, then resume the heap scan with an empty TID array.\n> + * uselessly for vacuuming small tables). Additional arrays of increasingly\n> + * large sizes are allocated as they become necessary.\n> + *\n> + * The TID array is thus represented as a list of multiple segments of\n> + * varying size, beginning with the initial size of up to 128MB, and growing\n> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\n> + * is used up.\n\nWhen the chunk size is 128MB, I'm a bit unconvinced that using\nexponential growth is worth it. The allocator overhead can't be\nmeaningful in comparison to collecting 128MB dead tuples, the potential\nwaste is pretty big, and it increases memory fragmentation.\n\n\n> + * Lookup in that structure proceeds sequentially in the list of segments,\n> + * and with a binary search within each segment. Since segment's size grows\n> + * exponentially, this retains O(N log N) lookup complexity.\n\nN log N is a horrible lookup complexity. That's the complexity of\n*sorting* an entire array. I think you might be trying to argue that\nit's log(N) * log(N)? Once log(n) for the exponentially growing size of\nsegments, one for the binary search?\n\nAfaics you could quite easily make it O(2 log(N)) by simply also doing\nbinary search over the segments. Might not be worth it due to the small\nconstant involved normally.\n\n\n> + * If the array threatens to overflow, we suspend the heap scan phase and\n> + * perform a pass of index cleanup and page compaction, then resume the heap\n> + * scan with an array of logically empty but already preallocated TID segments\n> + * to be refilled with more dead tuple TIDs.\n\nHm, it's not really the array that overflows, it's m_w_m that'd be\nexceeded, right?\n\n\n> /*\n> + * Minimum (starting) size of the dead_tuples array segments. Will allocate\n> + * space for 128MB worth of tid pointers in the first segment, further segments\n> + * will grow in size exponentially. Don't make it too small or the segment list\n> + * will grow bigger than the sweetspot for search efficiency on big vacuums.\n> + */\n> +#define LAZY_MIN_TUPLES\t\tMax(MaxHeapTuplesPerPage, (128<<20) / sizeof(ItemPointerData))\n\nThat's not really the minimum, no? s/MIN/INIT/?\n\n\n> +typedef struct DeadTuplesSegment\n> +{\n> +\tint\t\t\tnum_dead_tuples;\t/* # of entries in the segment */\n> +\tint\t\t\tmax_dead_tuples;\t/* # of entries allocated in the segment */\n> +\tItemPointerData last_dead_tuple;\t/* Copy of the last dead tuple (unset\n> +\t\t\t\t\t\t\t\t\t\t * until the segment is fully\n> +\t\t\t\t\t\t\t\t\t\t * populated) */\n> +\tunsigned short padding;\n> +\tItemPointer dt_tids;\t/* Array of dead tuples */\n> +}\tDeadTuplesSegment;\n\nWhenever padding is needed, it should have an explanatory comment. It's\ncertainly not obvious to me wh it's neede here.\n\n\n> @@ -1598,6 +1657,11 @@ lazy_vacuum_index(Relation indrel,\n> \tivinfo.num_heap_tuples = vacrelstats->old_rel_tuples;\n> \tivinfo.strategy = vac_strategy;\n> \n> +\t/* Finalize the current segment by setting its upper bound dead tuple */\n> +\tseg = DeadTuplesCurrentSegment(vacrelstats);\n> +\tif (seg->num_dead_tuples > 0)\n> +\t\tseg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\n\nWhy don't we just maintain this here, for all of the segments? Seems a\nbit easier.\n\n\n> @@ -1973,7 +2037,8 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)\n> static void\n> lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\n> {\n> -\tlong\t\tmaxtuples;\n> +\tlong\t\tmaxtuples,\n> +\t\t\t\tmintuples;\n> \tint\t\t\tvac_work_mem = IsAutoVacuumWorkerProcess() &&\n> \tautovacuum_work_mem != -1 ?\n> \tautovacuum_work_mem : maintenance_work_mem;\n> @@ -1982,7 +2047,6 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\n> \t{\n> \t\tmaxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\n> \t\tmaxtuples = Min(maxtuples, INT_MAX);\n> -\t\tmaxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\n> \n> \t\t/* curious coding here to ensure the multiplication can't overflow */\n> \t\tif ((BlockNumber) (maxtuples / LAZY_ALLOC_TUPLES) > relblocks)\n> @@ -1996,10 +2060,18 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\n> \t\tmaxtuples = MaxHeapTuplesPerPage;\n> \t}\n> \n> -\tvacrelstats->num_dead_tuples = 0;\n> -\tvacrelstats->max_dead_tuples = (int) maxtuples;\n> -\tvacrelstats->dead_tuples = (ItemPointer)\n> -\t\tpalloc(maxtuples * sizeof(ItemPointerData));\n> +\tmintuples = Min(LAZY_MIN_TUPLES, maxtuples);\n> +\n> +\tvacrelstats->dead_tuples.num_entries = 0;\n> +\tvacrelstats->dead_tuples.max_entries = (int) maxtuples;\n> +\tvacrelstats->dead_tuples.num_segs = 1;\n> +\tvacrelstats->dead_tuples.last_seg = 0;\n> +\tvacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *)\n> +\t\tpalloc(sizeof(DeadTuplesSegment));\n> +\tvacrelstats->dead_tuples.dt_segments[0].dt_tids = (ItemPointer)\n> +\t\tpalloc(mintuples * sizeof(ItemPointerData));\n> +\tvacrelstats->dead_tuples.dt_segments[0].max_dead_tuples = mintuples;\n> +\tvacrelstats->dead_tuples.dt_segments[0].num_dead_tuples = 0;\n> }\n\nHm. Why don't we delay allocating dt_segments[0] till we actually need\nit? It's not uncommon for vacuums not to be able to find any dead\ntuples, and it'd not change code in lazy_record_dead_tuple() much.\n\n\n> @@ -2014,31 +2086,147 @@ lazy_record_dead_tuple(LVRelStats *vacrelstats,\n> \t * could if we are given a really small maintenance_work_mem. In that\n> \t * case, just forget the last few tuples (we'll get 'em next time).\n> \t */\n> -\tif (vacrelstats->num_dead_tuples < vacrelstats->max_dead_tuples)\n> +\tif (vacrelstats->dead_tuples.num_entries < vacrelstats->dead_tuples.max_entries)\n> \t{\n> -\t\tvacrelstats->dead_tuples[vacrelstats->num_dead_tuples] = *itemptr;\n> -\t\tvacrelstats->num_dead_tuples++;\n> +\t\tDeadTuplesSegment *seg = DeadTuplesCurrentSegment(vacrelstats);\n> +\n> +\t\tif (seg->num_dead_tuples >= seg->max_dead_tuples)\n> +\t\t{\n> +\t\t\t/*\n> +\t\t\t * The segment is overflowing, so we must allocate a new segment.\n> +\t\t\t * We could have a preallocated segment descriptor already, in\n> +\t\t\t * which case we just reinitialize it, or we may need to repalloc\n> +\t\t\t * the vacrelstats->dead_tuples array. In that case, seg will no\n> +\t\t\t * longer be valid, so we must be careful about that. In any case,\n> +\t\t\t * we must update the last_dead_tuple copy in the overflowing\n> +\t\t\t * segment descriptor.\n> +\t\t\t */\n> +\t\t\tAssert(seg->num_dead_tuples == seg->max_dead_tuples);\n> +\t\t\tseg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\n> +\t\t\tif (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\n> +\t\t\t{\n> +\t\t\t\tint\t\t\tnew_num_segs = vacrelstats->dead_tuples.num_segs * 2;\n> +\n> +\t\t\t\tvacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\n> +\t\t\t\t\t\t\t (void *) vacrelstats->dead_tuples.dt_segments,\n> +\t\t\t\t\t\t\t\t new_num_segs * sizeof(DeadTuplesSegment));\n\nMight be worth breaking this into some sub-statements, it's quite hard\nto read.\n\n\n> +\t\t\t\twhile (vacrelstats->dead_tuples.num_segs < new_num_segs)\n> +\t\t\t\t{\n> +\t\t\t\t\t/* Initialize as \"unallocated\" */\n> +\t\t\t\t\tDeadTuplesSegment *nseg = &(vacrelstats->dead_tuples.dt_segments[\n> +\t\t\t\t\t\t\t\t\t\t vacrelstats->dead_tuples.num_segs]);\n\ndito.\n\n\n> +/*\n> *\tlazy_tid_reaped() -- is a particular tid deletable?\n> *\n> *\t\tThis has the right signature to be an IndexBulkDeleteCallback.\n> *\n> - *\t\tAssumes dead_tuples array is in sorted order.\n> + *\t\tAssumes the dead_tuples multiarray is in sorted order, both\n> + *\t\tthe segment list and each segment itself, and that all segments'\n> + *\t\tlast_dead_tuple fields up to date\n> */\n> static bool\n> lazy_tid_reaped(ItemPointer itemptr, void *state)\n\nHave you done performance evaluation about potential performance\nregressions in big indexes here? IIRC this can be quite frequently\ncalled?\n\n\nI think this is reasonably close to commit, but unfortunately not quite\nthere yet. I.e. I personally won't polish this up & commit in the next\ncouple hours, but if somebody else wants to take that on...\n\nGreetings,\n\nAndres Freund\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 13:05:09 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\n> Hi,\n>\n> I've *not* read the history of this thread. So I really might be\n> missing some context.\n>\n>\n>> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\n>> From: Claudio Freire <klaussfreire@gmail.com>\n>> Date: Mon, 12 Sep 2016 23:36:42 -0300\n>> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\n>>\n>> Turn the dead_tuples array into a structure composed of several\n>> exponentially bigger arrays, to enable usage of more than 1GB\n>> of work mem during vacuum and thus reduce the number of full\n>> index scans necessary to remove all dead tids when the memory is\n>> available.\n>\n>> * We are willing to use at most maintenance_work_mem (or perhaps\n>> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n>> - * initially allocate an array of TIDs of that size, with an upper limit that\n>> + * initially allocate an array of TIDs of 128MB, or an upper limit that\n>> * depends on table size (this limit ensures we don't allocate a huge area\n>> - * uselessly for vacuuming small tables). If the array threatens to overflow,\n>> - * we suspend the heap scan phase and perform a pass of index cleanup and page\n>> - * compaction, then resume the heap scan with an empty TID array.\n>> + * uselessly for vacuuming small tables). Additional arrays of increasingly\n>> + * large sizes are allocated as they become necessary.\n>> + *\n>> + * The TID array is thus represented as a list of multiple segments of\n>> + * varying size, beginning with the initial size of up to 128MB, and growing\n>> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\n>> + * is used up.\n>\n> When the chunk size is 128MB, I'm a bit unconvinced that using\n> exponential growth is worth it. The allocator overhead can't be\n> meaningful in comparison to collecting 128MB dead tuples, the potential\n> waste is pretty big, and it increases memory fragmentation.\n\nThe exponential strategy is mainly to improve lookup time (ie: to\navoid large segment lists).\n\n>> + * Lookup in that structure proceeds sequentially in the list of segments,\n>> + * and with a binary search within each segment. Since segment's size grows\n>> + * exponentially, this retains O(N log N) lookup complexity.\n>\n> N log N is a horrible lookup complexity. That's the complexity of\n> *sorting* an entire array. I think you might be trying to argue that\n> it's log(N) * log(N)? Once log(n) for the exponentially growing size of\n> segments, one for the binary search?\n>\n> Afaics you could quite easily make it O(2 log(N)) by simply also doing\n> binary search over the segments. Might not be worth it due to the small\n> constant involved normally.\n\nIt's a typo, yes, I meant O(log N) (which is equivalent to O(2 log N))\n\n>> + * If the array threatens to overflow, we suspend the heap scan phase and\n>> + * perform a pass of index cleanup and page compaction, then resume the heap\n>> + * scan with an array of logically empty but already preallocated TID segments\n>> + * to be refilled with more dead tuple TIDs.\n>\n> Hm, it's not really the array that overflows, it's m_w_m that'd be\n> exceeded, right?\n\nYes, will rephrase. Although that's how the original comment expressed\nthe same concept.\n\n>> /*\n>> + * Minimum (starting) size of the dead_tuples array segments. Will allocate\n>> + * space for 128MB worth of tid pointers in the first segment, further segments\n>> + * will grow in size exponentially. Don't make it too small or the segment list\n>> + * will grow bigger than the sweetspot for search efficiency on big vacuums.\n>> + */\n>> +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage, (128<<20) / sizeof(ItemPointerData))\n>\n> That's not really the minimum, no? s/MIN/INIT/?\n\nOk\n\n>> +typedef struct DeadTuplesSegment\n>> +{\n>> + int num_dead_tuples; /* # of entries in the segment */\n>> + int max_dead_tuples; /* # of entries allocated in the segment */\n>> + ItemPointerData last_dead_tuple; /* Copy of the last dead tuple (unset\n>> + * until the segment is fully\n>> + * populated) */\n>> + unsigned short padding;\n>> + ItemPointer dt_tids; /* Array of dead tuples */\n>> +} DeadTuplesSegment;\n>\n> Whenever padding is needed, it should have an explanatory comment. It's\n> certainly not obvious to me wh it's neede here.\n\nOk\n\n>> @@ -1598,6 +1657,11 @@ lazy_vacuum_index(Relation indrel,\n>> ivinfo.num_heap_tuples = vacrelstats->old_rel_tuples;\n>> ivinfo.strategy = vac_strategy;\n>>\n>> + /* Finalize the current segment by setting its upper bound dead tuple */\n>> + seg = DeadTuplesCurrentSegment(vacrelstats);\n>> + if (seg->num_dead_tuples > 0)\n>> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\n>\n> Why don't we just maintain this here, for all of the segments? Seems a\n> bit easier.\n\nOriginally, I just wanted to maintain the validity of last_dead_tuple\nas an invariant at all times. But it may be like you say, that it's\nsimpler to just maintain the invariant of all segments at finalization\ntime. I'll explore that possibility.\n\n>> @@ -1973,7 +2037,8 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)\n>> static void\n>> lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\n>> {\n>> - long maxtuples;\n>> + long maxtuples,\n>> + mintuples;\n>> int vac_work_mem = IsAutoVacuumWorkerProcess() &&\n>> autovacuum_work_mem != -1 ?\n>> autovacuum_work_mem : maintenance_work_mem;\n>> @@ -1982,7 +2047,6 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\n>> {\n>> maxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\n>> maxtuples = Min(maxtuples, INT_MAX);\n>> - maxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\n>>\n>> /* curious coding here to ensure the multiplication can't overflow */\n>> if ((BlockNumber) (maxtuples / LAZY_ALLOC_TUPLES) > relblocks)\n>> @@ -1996,10 +2060,18 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\n>> maxtuples = MaxHeapTuplesPerPage;\n>> }\n>>\n>> - vacrelstats->num_dead_tuples = 0;\n>> - vacrelstats->max_dead_tuples = (int) maxtuples;\n>> - vacrelstats->dead_tuples = (ItemPointer)\n>> - palloc(maxtuples * sizeof(ItemPointerData));\n>> + mintuples = Min(LAZY_MIN_TUPLES, maxtuples);\n>> +\n>> + vacrelstats->dead_tuples.num_entries = 0;\n>> + vacrelstats->dead_tuples.max_entries = (int) maxtuples;\n>> + vacrelstats->dead_tuples.num_segs = 1;\n>> + vacrelstats->dead_tuples.last_seg = 0;\n>> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *)\n>> + palloc(sizeof(DeadTuplesSegment));\n>> + vacrelstats->dead_tuples.dt_segments[0].dt_tids = (ItemPointer)\n>> + palloc(mintuples * sizeof(ItemPointerData));\n>> + vacrelstats->dead_tuples.dt_segments[0].max_dead_tuples = mintuples;\n>> + vacrelstats->dead_tuples.dt_segments[0].num_dead_tuples = 0;\n>> }\n>\n> Hm. Why don't we delay allocating dt_segments[0] till we actually need\n> it? It's not uncommon for vacuums not to be able to find any dead\n> tuples, and it'd not change code in lazy_record_dead_tuple() much.\n\nI avoided that because that would make dt_segments[last_seg] invalid\nfor the case of a just-initialized multiarray.\n\nSome places in the code use a macro that references\ndt_segments[last_seg] (mostly for indexless tables), and having to\ncheck num_segs and do lazy initialization would have complicated the\ncode considerably.\n\nNonetheless, I'll re-check how viable doing that would be.\n\n>> @@ -2014,31 +2086,147 @@ lazy_record_dead_tuple(LVRelStats *vacrelstats,\n>> * could if we are given a really small maintenance_work_mem. In that\n>> * case, just forget the last few tuples (we'll get 'em next time).\n>> */\n>> - if (vacrelstats->num_dead_tuples < vacrelstats->max_dead_tuples)\n>> + if (vacrelstats->dead_tuples.num_entries < vacrelstats->dead_tuples.max_entries)\n>> {\n>> - vacrelstats->dead_tuples[vacrelstats->num_dead_tuples] = *itemptr;\n>> - vacrelstats->num_dead_tuples++;\n>> + DeadTuplesSegment *seg = DeadTuplesCurrentSegment(vacrelstats);\n>> +\n>> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\n>> + {\n>> + /*\n>> + * The segment is overflowing, so we must allocate a new segment.\n>> + * We could have a preallocated segment descriptor already, in\n>> + * which case we just reinitialize it, or we may need to repalloc\n>> + * the vacrelstats->dead_tuples array. In that case, seg will no\n>> + * longer be valid, so we must be careful about that. In any case,\n>> + * we must update the last_dead_tuple copy in the overflowing\n>> + * segment descriptor.\n>> + */\n>> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\n>> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\n>> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\n>> + {\n>> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\n>> +\n>> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\n>> + (void *) vacrelstats->dead_tuples.dt_segments,\n>> + new_num_segs * sizeof(DeadTuplesSegment));\n>\n> Might be worth breaking this into some sub-statements, it's quite hard\n> to read.\n\nBreaking what precisely? The comment?\n\n>> + while (vacrelstats->dead_tuples.num_segs < new_num_segs)\n>> + {\n>> + /* Initialize as \"unallocated\" */\n>> + DeadTuplesSegment *nseg = &(vacrelstats->dead_tuples.dt_segments[\n>> + vacrelstats->dead_tuples.num_segs]);\n>\n> dito.\n\nI don't really get what you're asking here.\n\n>> +/*\n>> * lazy_tid_reaped() -- is a particular tid deletable?\n>> *\n>> * This has the right signature to be an IndexBulkDeleteCallback.\n>> *\n>> - * Assumes dead_tuples array is in sorted order.\n>> + * Assumes the dead_tuples multiarray is in sorted order, both\n>> + * the segment list and each segment itself, and that all segments'\n>> + * last_dead_tuple fields up to date\n>> */\n>> static bool\n>> lazy_tid_reaped(ItemPointer itemptr, void *state)\n>\n> Have you done performance evaluation about potential performance\n> regressions in big indexes here? IIRC this can be quite frequently\n> called?\n\nYes, the benchmarks are upthread. The earlier runs were run on my\nlaptop and made little sense, so I'd ignore them as inaccurate. The\nlatest run[1] with a pgbench scale of 4000 gave an improvement in CPU\ntime (ie: faster) of about 20%. Anastasia did another one[2] and saw\nimprovements as well, roughly 30%, though it's not measuring CPU time\nbut rather elapsed time.\n\nEven small scales (100) saw an improvement as well, although possibly\nbelow the noise floor. Tests are very slow so I haven't run enough to\nmeasure variance and statistical significance.\n\nI blame the improvement not only on better cache locality (the initial\nsearch on the segment list usually fits on L1) but also on less\noverall work due to needing less index scans, and the fact that\noverall lookup complexity remains O(log N) due to the exponential\nsegment growth strategy.\n\n[1] https://www.postgresql.org/message-id/CAGTBQpa6NFGO_6g_y_7zQx8L9GcHDSQKYdo1tGuh791z6PYgEg%40mail.gmail.com\n[2] https://www.postgresql.org/message-id/13bee467-bdcf-d3b9-c0ee-e2792fd46839%40postgrespro.ru\n\n>\n>\n> I think this is reasonably close to commit, but unfortunately not quite\n> there yet. I.e. I personally won't polish this up & commit in the next\n> couple hours, but if somebody else wants to take that on...\n>\n> Greetings,\n>\n> Andres Freund\n\nI'll post an updated patch with the requested changes shortly.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 19:43:39 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 7, 2017 at 7:43 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> + * Lookup in that structure proceeds sequentially in the list of segments,\n>>> + * and with a binary search within each segment. Since segment's size grows\n>>> + * exponentially, this retains O(N log N) lookup complexity.\n>>\n>> N log N is a horrible lookup complexity. That's the complexity of\n>> *sorting* an entire array. I think you might be trying to argue that\n>> it's log(N) * log(N)? Once log(n) for the exponentially growing size of\n>> segments, one for the binary search?\n>>\n>> Afaics you could quite easily make it O(2 log(N)) by simply also doing\n>> binary search over the segments. Might not be worth it due to the small\n>> constant involved normally.\n>\n> It's a typo, yes, I meant O(log N) (which is equivalent to O(2 log N))\n\n\nTo clarify, lookup over the segments is linear, so it's O(M) with M\nthe number of segments, then the binary search is O(log N) with N the\nnumber of dead tuples.\n\nSo lookup is O(M + log N), but M < log N because of the segment's\nexponential growth, therefore the lookup is O(2 log N)\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 19:46:06 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Hi,\n\n\nOn 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\n> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\n> > Hi,\n> >\n> > I've *not* read the history of this thread. So I really might be\n> > missing some context.\n> >\n> >\n> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\n> >> From: Claudio Freire <klaussfreire@gmail.com>\n> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\n> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\n> >>\n> >> Turn the dead_tuples array into a structure composed of several\n> >> exponentially bigger arrays, to enable usage of more than 1GB\n> >> of work mem during vacuum and thus reduce the number of full\n> >> index scans necessary to remove all dead tids when the memory is\n> >> available.\n> >\n> >> * We are willing to use at most maintenance_work_mem (or perhaps\n> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n> >> - * initially allocate an array of TIDs of that size, with an upper limit that\n> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\n> >> * depends on table size (this limit ensures we don't allocate a huge area\n> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\n> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\n> >> - * compaction, then resume the heap scan with an empty TID array.\n> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\n> >> + * large sizes are allocated as they become necessary.\n> >> + *\n> >> + * The TID array is thus represented as a list of multiple segments of\n> >> + * varying size, beginning with the initial size of up to 128MB, and growing\n> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\n> >> + * is used up.\n> >\n> > When the chunk size is 128MB, I'm a bit unconvinced that using\n> > exponential growth is worth it. The allocator overhead can't be\n> > meaningful in comparison to collecting 128MB dead tuples, the potential\n> > waste is pretty big, and it increases memory fragmentation.\n> \n> The exponential strategy is mainly to improve lookup time (ie: to\n> avoid large segment lists).\n\nWell, if we were to do binary search on the segment list, that'd not be\nnecessary.\n\n> >> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\n> >> + {\n> >> + /*\n> >> + * The segment is overflowing, so we must allocate a new segment.\n> >> + * We could have a preallocated segment descriptor already, in\n> >> + * which case we just reinitialize it, or we may need to repalloc\n> >> + * the vacrelstats->dead_tuples array. In that case, seg will no\n> >> + * longer be valid, so we must be careful about that. In any case,\n> >> + * we must update the last_dead_tuple copy in the overflowing\n> >> + * segment descriptor.\n> >> + */\n> >> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\n> >> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\n> >> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\n> >> + {\n> >> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\n> >> +\n> >> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\n> >> + (void *) vacrelstats->dead_tuples.dt_segments,\n> >> + new_num_segs * sizeof(DeadTuplesSegment));\n> >\n> > Might be worth breaking this into some sub-statements, it's quite hard\n> > to read.\n> \n> Breaking what precisely? The comment?\n\nNo, the three-line statement computing the new value of\ndead_tuples.dt_segments. I'd at least assign dead_tuples to a local\nvariable, to cut the length of the statement down.\n\n\n> >> + while (vacrelstats->dead_tuples.num_segs < new_num_segs)\n> >> + {\n> >> + /* Initialize as \"unallocated\" */\n> >> + DeadTuplesSegment *nseg = &(vacrelstats->dead_tuples.dt_segments[\n> >> + vacrelstats->dead_tuples.num_segs]);\n> >\n> > dito.\n> \n> I don't really get what you're asking here.\n\nTrying to simplify/shorten the statement.\n\n\n> >> +/*\n> >> * lazy_tid_reaped() -- is a particular tid deletable?\n> >> *\n> >> * This has the right signature to be an IndexBulkDeleteCallback.\n> >> *\n> >> - * Assumes dead_tuples array is in sorted order.\n> >> + * Assumes the dead_tuples multiarray is in sorted order, both\n> >> + * the segment list and each segment itself, and that all segments'\n> >> + * last_dead_tuple fields up to date\n> >> */\n> >> static bool\n> >> lazy_tid_reaped(ItemPointer itemptr, void *state)\n> >\n> > Have you done performance evaluation about potential performance\n> > regressions in big indexes here? IIRC this can be quite frequently\n> > called?\n> \n> Yes, the benchmarks are upthread. The earlier runs were run on my\n> laptop and made little sense, so I'd ignore them as inaccurate. The\n> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\n> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\n> improvements as well, roughly 30%, though it's not measuring CPU time\n> but rather elapsed time.\n\nI'd be more concerned about cases that'd already fit into memory, not ones\nwhere we avoid doing another scan - and I think you mostly measured that?\n\n- Andres\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 17:56:29 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 7, 2017 at 9:56 PM, Andres Freund <andres@anarazel.de> wrote:\n> Hi,\n>\n>\n> On 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\n>> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\n>> > Hi,\n>> >\n>> > I've *not* read the history of this thread. So I really might be\n>> > missing some context.\n>> >\n>> >\n>> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\n>> >> From: Claudio Freire <klaussfreire@gmail.com>\n>> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\n>> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\n>> >>\n>> >> Turn the dead_tuples array into a structure composed of several\n>> >> exponentially bigger arrays, to enable usage of more than 1GB\n>> >> of work mem during vacuum and thus reduce the number of full\n>> >> index scans necessary to remove all dead tids when the memory is\n>> >> available.\n>> >\n>> >> * We are willing to use at most maintenance_work_mem (or perhaps\n>> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n>> >> - * initially allocate an array of TIDs of that size, with an upper limit that\n>> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\n>> >> * depends on table size (this limit ensures we don't allocate a huge area\n>> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\n>> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\n>> >> - * compaction, then resume the heap scan with an empty TID array.\n>> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\n>> >> + * large sizes are allocated as they become necessary.\n>> >> + *\n>> >> + * The TID array is thus represented as a list of multiple segments of\n>> >> + * varying size, beginning with the initial size of up to 128MB, and growing\n>> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\n>> >> + * is used up.\n>> >\n>> > When the chunk size is 128MB, I'm a bit unconvinced that using\n>> > exponential growth is worth it. The allocator overhead can't be\n>> > meaningful in comparison to collecting 128MB dead tuples, the potential\n>> > waste is pretty big, and it increases memory fragmentation.\n>>\n>> The exponential strategy is mainly to improve lookup time (ie: to\n>> avoid large segment lists).\n>\n> Well, if we were to do binary search on the segment list, that'd not be\n> necessary.\n\nTrue, but the initial lookup might be slower in the end, since the\narray would be bigger and cache locality worse.\n\nWhy do you say exponential growth fragments memory? AFAIK, all those\nallocations are well beyond the point where malloc starts mmaping\nmemory, so each of those segments should be a mmap segment,\nindependently freeable.\n\n>> >> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\n>> >> + {\n>> >> + /*\n>> >> + * The segment is overflowing, so we must allocate a new segment.\n>> >> + * We could have a preallocated segment descriptor already, in\n>> >> + * which case we just reinitialize it, or we may need to repalloc\n>> >> + * the vacrelstats->dead_tuples array. In that case, seg will no\n>> >> + * longer be valid, so we must be careful about that. In any case,\n>> >> + * we must update the last_dead_tuple copy in the overflowing\n>> >> + * segment descriptor.\n>> >> + */\n>> >> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\n>> >> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\n>> >> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\n>> >> + {\n>> >> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\n>> >> +\n>> >> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\n>> >> + (void *) vacrelstats->dead_tuples.dt_segments,\n>> >> + new_num_segs * sizeof(DeadTuplesSegment));\n>> >\n>> > Might be worth breaking this into some sub-statements, it's quite hard\n>> > to read.\n>>\n>> Breaking what precisely? The comment?\n>\n> No, the three-line statement computing the new value of\n> dead_tuples.dt_segments. I'd at least assign dead_tuples to a local\n> variable, to cut the length of the statement down.\n\nAh, alright. Will try to do that.\n\n>> >> +/*\n>> >> * lazy_tid_reaped() -- is a particular tid deletable?\n>> >> *\n>> >> * This has the right signature to be an IndexBulkDeleteCallback.\n>> >> *\n>> >> - * Assumes dead_tuples array is in sorted order.\n>> >> + * Assumes the dead_tuples multiarray is in sorted order, both\n>> >> + * the segment list and each segment itself, and that all segments'\n>> >> + * last_dead_tuple fields up to date\n>> >> */\n>> >> static bool\n>> >> lazy_tid_reaped(ItemPointer itemptr, void *state)\n>> >\n>> > Have you done performance evaluation about potential performance\n>> > regressions in big indexes here? IIRC this can be quite frequently\n>> > called?\n>>\n>> Yes, the benchmarks are upthread. The earlier runs were run on my\n>> laptop and made little sense, so I'd ignore them as inaccurate. The\n>> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\n>> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\n>> improvements as well, roughly 30%, though it's not measuring CPU time\n>> but rather elapsed time.\n>\n> I'd be more concerned about cases that'd already fit into memory, not ones\n> where we avoid doing another scan - and I think you mostly measured that?\n>\n> - Andres\n\nWell, scale 400 is pretty much as big as you can get with the old 1GB\nlimit, and also suffered no significant regression. Although, true, id\ndidn't significantly improve either.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 22:06:13 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 2017-04-07 22:06:13 -0300, Claudio Freire wrote:\n> On Fri, Apr 7, 2017 at 9:56 PM, Andres Freund <andres@anarazel.de> wrote:\n> > Hi,\n> >\n> >\n> > On 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\n> >> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\n> >> > Hi,\n> >> >\n> >> > I've *not* read the history of this thread. So I really might be\n> >> > missing some context.\n> >> >\n> >> >\n> >> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\n> >> >> From: Claudio Freire <klaussfreire@gmail.com>\n> >> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\n> >> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\n> >> >>\n> >> >> Turn the dead_tuples array into a structure composed of several\n> >> >> exponentially bigger arrays, to enable usage of more than 1GB\n> >> >> of work mem during vacuum and thus reduce the number of full\n> >> >> index scans necessary to remove all dead tids when the memory is\n> >> >> available.\n> >> >\n> >> >> * We are willing to use at most maintenance_work_mem (or perhaps\n> >> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n> >> >> - * initially allocate an array of TIDs of that size, with an upper limit that\n> >> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\n> >> >> * depends on table size (this limit ensures we don't allocate a huge area\n> >> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\n> >> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\n> >> >> - * compaction, then resume the heap scan with an empty TID array.\n> >> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\n> >> >> + * large sizes are allocated as they become necessary.\n> >> >> + *\n> >> >> + * The TID array is thus represented as a list of multiple segments of\n> >> >> + * varying size, beginning with the initial size of up to 128MB, and growing\n> >> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\n> >> >> + * is used up.\n> >> >\n> >> > When the chunk size is 128MB, I'm a bit unconvinced that using\n> >> > exponential growth is worth it. The allocator overhead can't be\n> >> > meaningful in comparison to collecting 128MB dead tuples, the potential\n> >> > waste is pretty big, and it increases memory fragmentation.\n> >>\n> >> The exponential strategy is mainly to improve lookup time (ie: to\n> >> avoid large segment lists).\n> >\n> > Well, if we were to do binary search on the segment list, that'd not be\n> > necessary.\n> \n> True, but the initial lookup might be slower in the end, since the\n> array would be bigger and cache locality worse.\n> \n> Why do you say exponential growth fragments memory? AFAIK, all those\n> allocations are well beyond the point where malloc starts mmaping\n> memory, so each of those segments should be a mmap segment,\n> independently freeable.\n\nNot all platforms have that, and even on platforms with it, frequent,\nunevenly sized, very large allocations can lead to enough fragmentation\nthat further allocations are harder and fragment / enlarge the\npagetable.\n\n\n> >> Yes, the benchmarks are upthread. The earlier runs were run on my\n> >> laptop and made little sense, so I'd ignore them as inaccurate. The\n> >> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\n> >> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\n> >> improvements as well, roughly 30%, though it's not measuring CPU time\n> >> but rather elapsed time.\n> >\n> > I'd be more concerned about cases that'd already fit into memory, not ones\n> > where we avoid doing another scan - and I think you mostly measured that?\n> >\n> > - Andres\n> \n> Well, scale 400 is pretty much as big as you can get with the old 1GB\n> limit, and also suffered no significant regression. Although, true, id\n> didn't significantly improve either.\n\nAren't more interesting cases those where not that many dead tuples are\nfound, but the indexes are pretty large? IIRC the index vacuum scans\nstill visit every leaf index tuple, no?\n\nGreetings,\n\nAndres Freund\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 18:12:52 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 7, 2017 at 10:12 PM, Andres Freund <andres@anarazel.de> wrote:\n> On 2017-04-07 22:06:13 -0300, Claudio Freire wrote:\n>> On Fri, Apr 7, 2017 at 9:56 PM, Andres Freund <andres@anarazel.de> wrote:\n>> > Hi,\n>> >\n>> >\n>> > On 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\n>> >> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\n>> >> > Hi,\n>> >> >\n>> >> > I've *not* read the history of this thread. So I really might be\n>> >> > missing some context.\n>> >> >\n>> >> >\n>> >> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\n>> >> >> From: Claudio Freire <klaussfreire@gmail.com>\n>> >> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\n>> >> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\n>> >> >>\n>> >> >> Turn the dead_tuples array into a structure composed of several\n>> >> >> exponentially bigger arrays, to enable usage of more than 1GB\n>> >> >> of work mem during vacuum and thus reduce the number of full\n>> >> >> index scans necessary to remove all dead tids when the memory is\n>> >> >> available.\n>> >> >\n>> >> >> * We are willing to use at most maintenance_work_mem (or perhaps\n>> >> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\n>> >> >> - * initially allocate an array of TIDs of that size, with an upper limit that\n>> >> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\n>> >> >> * depends on table size (this limit ensures we don't allocate a huge area\n>> >> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\n>> >> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\n>> >> >> - * compaction, then resume the heap scan with an empty TID array.\n>> >> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\n>> >> >> + * large sizes are allocated as they become necessary.\n>> >> >> + *\n>> >> >> + * The TID array is thus represented as a list of multiple segments of\n>> >> >> + * varying size, beginning with the initial size of up to 128MB, and growing\n>> >> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\n>> >> >> + * is used up.\n>> >> >\n>> >> > When the chunk size is 128MB, I'm a bit unconvinced that using\n>> >> > exponential growth is worth it. The allocator overhead can't be\n>> >> > meaningful in comparison to collecting 128MB dead tuples, the potential\n>> >> > waste is pretty big, and it increases memory fragmentation.\n>> >>\n>> >> The exponential strategy is mainly to improve lookup time (ie: to\n>> >> avoid large segment lists).\n>> >\n>> > Well, if we were to do binary search on the segment list, that'd not be\n>> > necessary.\n>>\n>> True, but the initial lookup might be slower in the end, since the\n>> array would be bigger and cache locality worse.\n>>\n>> Why do you say exponential growth fragments memory? AFAIK, all those\n>> allocations are well beyond the point where malloc starts mmaping\n>> memory, so each of those segments should be a mmap segment,\n>> independently freeable.\n>\n> Not all platforms have that, and even on platforms with it, frequent,\n> unevenly sized, very large allocations can lead to enough fragmentation\n> that further allocations are harder and fragment / enlarge the\n> pagetable.\n\nI wouldn't call this frequent. You can get at most slightly more than\na dozen such allocations given the current limits.\nAnd allocation sizes are quite regular - you get 128M or multiples of\n128M, so each free block can be reused for N smaller allocations if\nneeded. I don't think it has much potential to fragment memory.\n\nThis isn't significantly different from tuplesort or any other code\nthat can do big allocations, and the differences favor less\nfragmentation than those, so I don't see why this would need special\ntreatment.\n\nMy point being that it's not been simple getting to a point where this\nbeats even in CPU time the original single binary search.\nIf we're to scrap this implementation and go for a double binary\nsearch, I'd like to have a clear measurable benefit to chase from\ndoing so. Fragmentation is hard to measure, and I cannot get CPU-bound\nvacuums on the test hardware I have to test lookup performance at big\nscales.\n\n>> >> Yes, the benchmarks are upthread. The earlier runs were run on my\n>> >> laptop and made little sense, so I'd ignore them as inaccurate. The\n>> >> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\n>> >> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\n>> >> improvements as well, roughly 30%, though it's not measuring CPU time\n>> >> but rather elapsed time.\n>> >\n>> > I'd be more concerned about cases that'd already fit into memory, not ones\n>> > where we avoid doing another scan - and I think you mostly measured that?\n>> >\n>> > - Andres\n>>\n>> Well, scale 400 is pretty much as big as you can get with the old 1GB\n>> limit, and also suffered no significant regression. Although, true, id\n>> didn't significantly improve either.\n>\n> Aren't more interesting cases those where not that many dead tuples are\n> found, but the indexes are pretty large? IIRC the index vacuum scans\n> still visit every leaf index tuple, no?\n\nIndeed they do, and that's what motivated this patch. But I'd need\nTB-sized tables to set up something like that. I don't have the\nhardware or time available to do that (vacuum on bloated TB-sized\ntables can take days in my experience). Scale 4000 is as big as I can\nget without running out of space for the tests in my test hardware.\n\nIf anybody else has the ability, I'd be thankful if they did test it\nunder those conditions, but I cannot. I think Anastasia's test is\ncloser to such a test, that's probably why it shows a bigger\nimprovement in total elapsed time.\n\nOur production database could possibly be used, but it can take about\na week to clone it, upgrade it (it's 9.5 currently), and run the\nrelevant vacuum.\n\nI did perform tests against the same pgbench databases referenced in\nthe post I linked earlier, but deleting only a fraction of the rows,\nor on uncorrelated indexes. The benchmarks weren't very interesting,\nand results were consistent with the linked benchmark (slight CPU time\nimprovement, just less impactful), so I didn't post them.\n\nI think all those tests show that, if there's a workload that\nregresses, it's a rare one, running on very powerful I/O hardware (to\nmake vacuum CPU-bound). And even if that were to happen, considering a\nsingle (or fewer) index scan, even if slower, will cause less WAL\ntraffic that has to be archived/streamed, it would still most likely\nbe a win overall.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 22:51:21 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 7, 2017 at 10:06 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> >> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\n>>> >> + {\n>>> >> + /*\n>>> >> + * The segment is overflowing, so we must allocate a new segment.\n>>> >> + * We could have a preallocated segment descriptor already, in\n>>> >> + * which case we just reinitialize it, or we may need to repalloc\n>>> >> + * the vacrelstats->dead_tuples array. In that case, seg will no\n>>> >> + * longer be valid, so we must be careful about that. In any case,\n>>> >> + * we must update the last_dead_tuple copy in the overflowing\n>>> >> + * segment descriptor.\n>>> >> + */\n>>> >> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\n>>> >> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\n>>> >> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\n>>> >> + {\n>>> >> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\n>>> >> +\n>>> >> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\n>>> >> + (void *) vacrelstats->dead_tuples.dt_segments,\n>>> >> + new_num_segs * sizeof(DeadTuplesSegment));\n>>> >\n>>> > Might be worth breaking this into some sub-statements, it's quite hard\n>>> > to read.\n>>>\n>>> Breaking what precisely? The comment?\n>>\n>> No, the three-line statement computing the new value of\n>> dead_tuples.dt_segments. I'd at least assign dead_tuples to a local\n>> variable, to cut the length of the statement down.\n>\n> Ah, alright. Will try to do that.\n\nAttached is an updated patch set with the requested changes.\n\nSegment allocation still follows the exponential strategy, and segment\nlookup is still linear.\n\nI rebased the early free patch (patch 3) to apply on top of the v9\npatch 2 (it needed some changes). I recognize the early free patch\ndidn't get nearly as much scrutiny, so I'm fine with commiting only 2\nif that one's ready to go but 3 isn't.\n\nIf it's decided to go for fixed 128M segments and a binary search of\nsegments, I don't think I can get that ready and tested before the\ncommitfest ends.\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 7 Apr 2017 23:19:42 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 4/7/17 10:19 PM, Claudio Freire wrote:\n> \n> I rebased the early free patch (patch 3) to apply on top of the v9\n> patch 2 (it needed some changes). I recognize the early free patch\n> didn't get nearly as much scrutiny, so I'm fine with commiting only 2\n> if that one's ready to go but 3 isn't.\n> \n> If it's decided to go for fixed 128M segments and a binary search of\n> segments, I don't think I can get that ready and tested before the\n> commitfest ends.\n\nThis submission has been moved to CF 2017-07.\n\n-- \n-David\ndavid@pgmasters.net\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 8 Apr 2017 10:10:18 -0400","msg_from":"David Steele <david@pgmasters.net>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 7, 2017 at 9:12 PM, Andres Freund <andres@anarazel.de> wrote:\n>> Why do you say exponential growth fragments memory? AFAIK, all those\n>> allocations are well beyond the point where malloc starts mmaping\n>> memory, so each of those segments should be a mmap segment,\n>> independently freeable.\n>\n> Not all platforms have that, and even on platforms with it, frequent,\n> unevenly sized, very large allocations can lead to enough fragmentation\n> that further allocations are harder and fragment / enlarge the\n> pagetable.\n\nSuch a thing is completely outside my personal experience. I've never\nheard of a case where a 64-bit platform fails to allocate memory\nbecause something (what?) is fragmented. Page table memory usage is a\nconcern at some level, but probably less so for autovacuum workers\nthan for most backends, because autovacuum workers (where most\nvacuuming is done) exit after one pass through pg_class. Although I\nthink our memory footprint is a topic that could use more energy, I\ndon't really see any reason to think that pagetable bloat caused my\nunevenly sized allocations in short-lived processes is the place to\nstart worrying.\n\nThat having been said, IIRC, I did propose quite a ways upthread that\nwe use a fixed chunk size, just because it would use less actual\nmemory, never mind the size of the page table. I mean, if you\nallocate in chunks of 64MB, which I think is what I proposed, you'll\nnever waste more than 64MB. If you allocate in\nexponentially-increasing chunk sizes starting at 128MB, you could\neasily waste much more. Let's imagine a 1TB table where 20% of the\ntuples are dead due to some large bulk operation (a bulk load failed,\nor a bulk delete succeeded, or a bulk update happened). Back of the\nenvelope calculation:\n\n1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\nmaintenance_work_mem\n\nSo we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\nenough so we'll allocate another 8GB, for a total of 16256MB, but more\nthan three-quarters of that last allocation ends up being wasted.\nI've been told on this list before that doubling is the one true way\nof increasing the size of an allocated chunk of memory, but I'm still\na bit unconvinced.\n\nOn the other hand, if we did allocate fixed chunks of, say, 64MB, we\ncould end up with an awful lot of them. For example, in the example\nabove, 9216MB/64MB = 144 chunks. Is that number of mappings going to\nmake the VM system unhappy on any of the platforms we care about? Is\nthat a bigger or smaller problem than what you (Andres) are worrying\nabout? I don't know.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 11 Apr 2017 14:53:14 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\n> maintenance_work_mem\n>\n> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\n> enough so we'll allocate another 8GB, for a total of 16256MB, but more\n> than three-quarters of that last allocation ends up being wasted.\n> I've been told on this list before that doubling is the one true way\n> of increasing the size of an allocated chunk of memory, but I'm still\n> a bit unconvinced.\n\nThere you're wrong. The allocation is capped to 1GB, so wastage has an\nupper bound of 1GB.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 11 Apr 2017 15:59:56 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Apr 11, 2017 at 3:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\n>> maintenance_work_mem\n>>\n>> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\n>> enough so we'll allocate another 8GB, for a total of 16256MB, but more\n>> than three-quarters of that last allocation ends up being wasted.\n>> I've been told on this list before that doubling is the one true way\n>> of increasing the size of an allocated chunk of memory, but I'm still\n>> a bit unconvinced.\n>\n> There you're wrong. The allocation is capped to 1GB, so wastage has an\n> upper bound of 1GB.\n\nAnd total m_w_m for vacuum is still capped to 12GB (as big you can get\nwith 32-bit integer indices).\n\nSo you can get at most 15 segments (a binary search is thus not worth\nit), and overallocate by at most 1GB (the maximum segment size).\n\nAt least that's my rationale.\n\nRemoving the 12GB limit requires a bit of care (there are some 32-bit\ncounters still around I believe).\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 11 Apr 2017 16:04:44 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Apr 11, 2017 at 2:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\n>> maintenance_work_mem\n>>\n>> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\n>> enough so we'll allocate another 8GB, for a total of 16256MB, but more\n>> than three-quarters of that last allocation ends up being wasted.\n>> I've been told on this list before that doubling is the one true way\n>> of increasing the size of an allocated chunk of memory, but I'm still\n>> a bit unconvinced.\n>\n> There you're wrong. The allocation is capped to 1GB, so wastage has an\n> upper bound of 1GB.\n\nAh, OK. Sorry, didn't really look at the code. I stand corrected,\nbut then it seems a bit strange to me that the largest and smallest\nallocations are only 8x different. I still don't really understand\nwhat that buys us. What would we lose if we just made 'em all 128MB?\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 11 Apr 2017 15:17:09 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Apr 11, 2017 at 4:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> On Tue, Apr 11, 2017 at 2:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\n>>> maintenance_work_mem\n>>>\n>>> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\n>>> enough so we'll allocate another 8GB, for a total of 16256MB, but more\n>>> than three-quarters of that last allocation ends up being wasted.\n>>> I've been told on this list before that doubling is the one true way\n>>> of increasing the size of an allocated chunk of memory, but I'm still\n>>> a bit unconvinced.\n>>\n>> There you're wrong. The allocation is capped to 1GB, so wastage has an\n>> upper bound of 1GB.\n>\n> Ah, OK. Sorry, didn't really look at the code. I stand corrected,\n> but then it seems a bit strange to me that the largest and smallest\n> allocations are only 8x different. I still don't really understand\n> what that buys us.\n\nBasically, attacking the problem (that, I think, you mentioned) of\nvery small systems in which overallocation for small vacuums was an\nissue.\n\nThe \"slow start\" behavior of starting with smaller segments tries to\nimprove the situation for small vacuums, not big ones.\n\nBy starting at 128M and growing up to 1GB, overallocation is bound to\nthe range 128M-1GB and is proportional to the amount of dead tuples,\nnot table size, as it was before. Starting at 128M helps the initial\nsegment search, but I could readily go for starting at 64M, I don't\nthink it would make a huge difference. Removing exponential growth,\nhowever, would.\n\nAs the patch stands, small systems (say 32-bit systems) without\novercommit and with slowly-changing data can now set high m_w_m\nwithout running into overallocation issues with autovacuum reserving\ntoo much virtual space, as it will reserve memory only proportional to\nthe amount of dead tuples. Previously, it would reserve all of m_w_m\nregardless of whether it was needed or not, with the only exception\nbeing really small tables, so m_w_m=1GB was unworkable in those cases.\nNow it should be fine.\n\n> What would we lose if we just made 'em all 128MB?\n\nTBH, not that much. We'd need 8x compares to find the segment, that\nforces a switch to binary search of the segments, which is less\ncache-friendly. So it's more complex code, less cache locality. I'm\njust not sure what's the benefit given current limits.\n\nThe only aim of this multiarray approach was making *virtual address\nspace reservations* proportional to the amount of actual memory\nneeded, as opposed to configured limits. It doesn't need to be a tight\nfit, because calling palloc on its own doesn't actually use that\nmemory, at least on big allocations like these - the OS will not map\nthe memory pages until they're first touched. That's true in most\nmodern systems, and many ancient ones too.\n\nIn essence, the patch as it is proposed, doesn't *need* a binary\nsearch, because the segment list can only grow up to 15 segments at\nits biggest, and that's a size small enough that linear search will\noutperform (or at least perform as well as) binary search. Reducing\nthe initial segment size wouldn't change that. If the 12GB limit is\nlifted, or the maximum segment size reduced (from 1GB to 128MB for\nexample), however, that would change.\n\nI'd be more in favor of lifting the 12GB limit than of reducing the\nmaximum segment size, for the reasons above. Raising the 12GB limit\nhas concrete and readily apparent benefits, whereas using bigger (or\nsmaller) segments is far more debatable. Yes, that will need a binary\nsearch. But, I was hoping that could be a second (or third) patch, to\nkeep things simple, and benefits measurable.\n\nAlso, the plan as discussed in this very long thread, was to\neventually try to turn segments into bitmaps if dead tuple density was\nbig enough. That benefits considerably from big segments, since lookup\non a bitmap is O(1) - the bigger the segments, the faster the lookup,\nas the search on the segment list would be dominant.\n\nSo... what shall we do?\n\nAt this point, I've given all my arguments for the current design. If\nthe more senior developers don't agree, I'll be happy to try your way.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 11 Apr 2017 17:38:51 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Apr 11, 2017 at 4:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> In essence, the patch as it is proposed, doesn't *need* a binary\n> search, because the segment list can only grow up to 15 segments at\n> its biggest, and that's a size small enough that linear search will\n> outperform (or at least perform as well as) binary search. Reducing\n> the initial segment size wouldn't change that. If the 12GB limit is\n> lifted, or the maximum segment size reduced (from 1GB to 128MB for\n> example), however, that would change.\n>\n> I'd be more in favor of lifting the 12GB limit than of reducing the\n> maximum segment size, for the reasons above. Raising the 12GB limit\n> has concrete and readily apparent benefits, whereas using bigger (or\n> smaller) segments is far more debatable. Yes, that will need a binary\n> search. But, I was hoping that could be a second (or third) patch, to\n> keep things simple, and benefits measurable.\n\nTo me, it seems a bit short-sighted to say, OK, let's use a linear\nsearch because there's this 12GB limit so we can limit ourselves to 15\nsegments. Because somebody will want to remove that 12GB limit, and\nthen we'll have to revisit the whole thing anyway. I think, anyway.\n\nWhat's not clear to me is how sensitive the performance of vacuum is\nto the number of cycles used here. For a large index, the number of\nsearches will presumably be quite large, so it does seem worth\nworrying about performance. But if we just always used a binary\nsearch, would that lose enough performance with small numbers of\nsegments that anyone would care? If so, maybe we need to use linear\nsearch for small numbers of segments and switch to binary search with\nlarger numbers of segments.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 12 Apr 2017 15:35:28 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Apr 12, 2017 at 4:35 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> On Tue, Apr 11, 2017 at 4:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> In essence, the patch as it is proposed, doesn't *need* a binary\n>> search, because the segment list can only grow up to 15 segments at\n>> its biggest, and that's a size small enough that linear search will\n>> outperform (or at least perform as well as) binary search. Reducing\n>> the initial segment size wouldn't change that. If the 12GB limit is\n>> lifted, or the maximum segment size reduced (from 1GB to 128MB for\n>> example), however, that would change.\n>>\n>> I'd be more in favor of lifting the 12GB limit than of reducing the\n>> maximum segment size, for the reasons above. Raising the 12GB limit\n>> has concrete and readily apparent benefits, whereas using bigger (or\n>> smaller) segments is far more debatable. Yes, that will need a binary\n>> search. But, I was hoping that could be a second (or third) patch, to\n>> keep things simple, and benefits measurable.\n>\n> To me, it seems a bit short-sighted to say, OK, let's use a linear\n> search because there's this 12GB limit so we can limit ourselves to 15\n> segments. Because somebody will want to remove that 12GB limit, and\n> then we'll have to revisit the whole thing anyway. I think, anyway.\n\nOk, attached an updated patch that implements the binary search\n\n> What's not clear to me is how sensitive the performance of vacuum is\n> to the number of cycles used here. For a large index, the number of\n> searches will presumably be quite large, so it does seem worth\n> worrying about performance. But if we just always used a binary\n> search, would that lose enough performance with small numbers of\n> segments that anyone would care? If so, maybe we need to use linear\n> search for small numbers of segments and switch to binary search with\n> larger numbers of segments.\n\nI just went and tested.\n\nI implemented the hybrid binary search attached, and ran a few tests\nwith and without the sequential code enabled, at small scales.\n\nThe difference is statistically significant, but small (less than 3%).\nWith proper optimization of the binary search, however, the difference\nflips:\n\nclaudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\nfullbinary.s100.times\nvacuum_bench_s100.1.shufp80.log:CPU: user: 6.20 s, system: 1.42 s,\nelapsed: 18.34 s.\nvacuum_bench_s100.2.shufp80.log:CPU: user: 6.44 s, system: 1.40 s,\nelapsed: 19.75 s.\nvacuum_bench_s100.3.shufp80.log:CPU: user: 6.28 s, system: 1.41 s,\nelapsed: 18.48 s.\nvacuum_bench_s100.4.shufp80.log:CPU: user: 6.39 s, system: 1.51 s,\nelapsed: 20.60 s.\nvacuum_bench_s100.5.shufp80.log:CPU: user: 6.26 s, system: 1.42 s,\nelapsed: 19.16 s.\n\nclaudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\nhybridbinary.s100.times\nvacuum_bench_s100.1.shufp80.log:CPU: user: 6.49 s, system: 1.39 s,\nelapsed: 19.15 s.\nvacuum_bench_s100.2.shufp80.log:CPU: user: 6.36 s, system: 1.33 s,\nelapsed: 18.40 s.\nvacuum_bench_s100.3.shufp80.log:CPU: user: 6.36 s, system: 1.31 s,\nelapsed: 18.87 s.\nvacuum_bench_s100.4.shufp80.log:CPU: user: 6.59 s, system: 1.35 s,\nelapsed: 26.43 s.\nvacuum_bench_s100.5.shufp80.log:CPU: user: 6.54 s, system: 1.28 s,\nelapsed: 20.02 s.\n\nThat's after inlining the compare on both the linear and sequential\ncode, and it seems it lets the compiler optimize the binary search to\nthe point where it outperforms the sequential search.\n\nThat's not the case when the compare isn't inlined.\n\nThat seems in line with [1], that show the impact of various\noptimizations on both algorithms. It's clearly a close enough race\nthat optimizations play a huge role.\n\nSince we're not likely to go and implement SSE2-optimized versions, I\nbelieve I'll leave the binary search only. That's the attached patch\nset.\n\nI'm running the full test suite, but that takes a very long while.\nI'll post the results when they're done.\n\n[1] https://schani.wordpress.com/2010/04/30/linear-vs-binary-search/\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 20 Apr 2017 18:24:13 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Apr 20, 2017 at 5:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> What's not clear to me is how sensitive the performance of vacuum is\n>> to the number of cycles used here. For a large index, the number of\n>> searches will presumably be quite large, so it does seem worth\n>> worrying about performance. But if we just always used a binary\n>> search, would that lose enough performance with small numbers of\n>> segments that anyone would care? If so, maybe we need to use linear\n>> search for small numbers of segments and switch to binary search with\n>> larger numbers of segments.\n>\n> I just went and tested.\n\nThanks!\n\n> That's after inlining the compare on both the linear and sequential\n> code, and it seems it lets the compiler optimize the binary search to\n> the point where it outperforms the sequential search.\n>\n> That's not the case when the compare isn't inlined.\n>\n> That seems in line with [1], that show the impact of various\n> optimizations on both algorithms. It's clearly a close enough race\n> that optimizations play a huge role.\n>\n> Since we're not likely to go and implement SSE2-optimized versions, I\n> believe I'll leave the binary search only. That's the attached patch\n> set.\n\nThat sounds reasonable based on your test results. I guess part of\nwhat I was wondering is whether a vacuum on a table large enough to\nrequire multiple gigabytes of work_mem isn't likely to be I/O-bound\nanyway. If so, a few cycles one way or the other other isn't likely\nto matter much. If not, where exactly are all of those CPU cycles\ngoing?\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 23 Apr 2017 11:41:08 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Sun, Apr 23, 2017 at 12:41 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> That's after inlining the compare on both the linear and sequential\n>> code, and it seems it lets the compiler optimize the binary search to\n>> the point where it outperforms the sequential search.\n>>\n>> That's not the case when the compare isn't inlined.\n>>\n>> That seems in line with [1], that show the impact of various\n>> optimizations on both algorithms. It's clearly a close enough race\n>> that optimizations play a huge role.\n>>\n>> Since we're not likely to go and implement SSE2-optimized versions, I\n>> believe I'll leave the binary search only. That's the attached patch\n>> set.\n>\n> That sounds reasonable based on your test results. I guess part of\n> what I was wondering is whether a vacuum on a table large enough to\n> require multiple gigabytes of work_mem isn't likely to be I/O-bound\n> anyway. If so, a few cycles one way or the other other isn't likely\n> to matter much. If not, where exactly are all of those CPU cycles\n> going?\n\nI haven't been able to produce a table large enough to get a CPU-bound\nvacuum, so such a case is likely to require huge storage and a very\npowerful I/O system. Mine can only get about 100MB/s tops, and at that\nspeed, vacuum is I/O bound even for multi-GB work_mem. That's why I've\nbeen using the reported CPU time as benchmark.\n\nBTW, I left the benchmark script running all weekend at the office,\nand when I got back a power outage had aborted it. In a few days I'll\nbe out on vacation, so I'm not sure I'll get the benchmark results\nanytime soon. But this patch moved to 11.0 I guess there's no rush.\n\nJust FTR, in case I leave before the script is done, the script got to\nscale 400 before the outage:\n\nINFO: vacuuming \"public.pgbench_accounts\"\nINFO: scanned index \"pgbench_accounts_pkey\" to remove 40000000 row versions\nDETAIL: CPU: user: 5.94 s, system: 1.26 s, elapsed: 26.77 s.\nINFO: \"pgbench_accounts\": removed 40000000 row versions in 655739 pages\nDETAIL: CPU: user: 3.36 s, system: 2.57 s, elapsed: 61.67 s.\nINFO: index \"pgbench_accounts_pkey\" now contains 0 row versions in 109679 pages\nDETAIL: 40000000 index row versions were removed.\n109289 index pages have been deleted, 0 are currently reusable.\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.06 s.\nINFO: \"pgbench_accounts\": found 38925546 removable, 0 nonremovable\nrow versions in 655738 out of 655738 pages\nDETAIL: 0 dead row versions cannot be removed yet, oldest xmin: 1098\nThere were 0 unused item pointers.\nSkipped 0 pages due to buffer pins, 0 frozen pages.\n0 pages are entirely empty.\nCPU: user: 15.34 s, system: 6.95 s, elapsed: 126.21 s.\nINFO: \"pgbench_accounts\": truncated 655738 to 0 pages\nDETAIL: CPU: user: 0.22 s, system: 2.10 s, elapsed: 8.10 s.\n\nIn summary:\n\nbinsrch v10:\n\ns100: CPU: user: 3.02 s, system: 1.51 s, elapsed: 16.43 s.\ns400: CPU: user: 15.34 s, system: 6.95 s, elapsed: 126.21 s.\n\nThe old results:\n\nOld Patched (sequential search):\n\ns100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\ns400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\ns4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\n\nUnpatched:\n\ns100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\ns400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\ns4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\n\nI wouldn't fret over the slight slowdown vs the old patch, it could be\nnoise (the script only completed a single run at scale 400).\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 24 Apr 2017 16:57:24 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Apr 24, 2017 at 3:57 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> I wouldn't fret over the slight slowdown vs the old patch, it could be\n> noise (the script only completed a single run at scale 400).\n\nYeah, seems fine.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 25 Apr 2017 11:20:49 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 21, 2017 at 6:24 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Apr 12, 2017 at 4:35 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> On Tue, Apr 11, 2017 at 4:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> In essence, the patch as it is proposed, doesn't *need* a binary\n>>> search, because the segment list can only grow up to 15 segments at\n>>> its biggest, and that's a size small enough that linear search will\n>>> outperform (or at least perform as well as) binary search. Reducing\n>>> the initial segment size wouldn't change that. If the 12GB limit is\n>>> lifted, or the maximum segment size reduced (from 1GB to 128MB for\n>>> example), however, that would change.\n>>>\n>>> I'd be more in favor of lifting the 12GB limit than of reducing the\n>>> maximum segment size, for the reasons above. Raising the 12GB limit\n>>> has concrete and readily apparent benefits, whereas using bigger (or\n>>> smaller) segments is far more debatable. Yes, that will need a binary\n>>> search. But, I was hoping that could be a second (or third) patch, to\n>>> keep things simple, and benefits measurable.\n>>\n>> To me, it seems a bit short-sighted to say, OK, let's use a linear\n>> search because there's this 12GB limit so we can limit ourselves to 15\n>> segments. Because somebody will want to remove that 12GB limit, and\n>> then we'll have to revisit the whole thing anyway. I think, anyway.\n>\n> Ok, attached an updated patch that implements the binary search\n>\n>> What's not clear to me is how sensitive the performance of vacuum is\n>> to the number of cycles used here. For a large index, the number of\n>> searches will presumably be quite large, so it does seem worth\n>> worrying about performance. But if we just always used a binary\n>> search, would that lose enough performance with small numbers of\n>> segments that anyone would care? If so, maybe we need to use linear\n>> search for small numbers of segments and switch to binary search with\n>> larger numbers of segments.\n>\n> I just went and tested.\n>\n> I implemented the hybrid binary search attached, and ran a few tests\n> with and without the sequential code enabled, at small scales.\n>\n> The difference is statistically significant, but small (less than 3%).\n> With proper optimization of the binary search, however, the difference\n> flips:\n>\n> claudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\n> fullbinary.s100.times\n> vacuum_bench_s100.1.shufp80.log:CPU: user: 6.20 s, system: 1.42 s,\n> elapsed: 18.34 s.\n> vacuum_bench_s100.2.shufp80.log:CPU: user: 6.44 s, system: 1.40 s,\n> elapsed: 19.75 s.\n> vacuum_bench_s100.3.shufp80.log:CPU: user: 6.28 s, system: 1.41 s,\n> elapsed: 18.48 s.\n> vacuum_bench_s100.4.shufp80.log:CPU: user: 6.39 s, system: 1.51 s,\n> elapsed: 20.60 s.\n> vacuum_bench_s100.5.shufp80.log:CPU: user: 6.26 s, system: 1.42 s,\n> elapsed: 19.16 s.\n>\n> claudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\n> hybridbinary.s100.times\n> vacuum_bench_s100.1.shufp80.log:CPU: user: 6.49 s, system: 1.39 s,\n> elapsed: 19.15 s.\n> vacuum_bench_s100.2.shufp80.log:CPU: user: 6.36 s, system: 1.33 s,\n> elapsed: 18.40 s.\n> vacuum_bench_s100.3.shufp80.log:CPU: user: 6.36 s, system: 1.31 s,\n> elapsed: 18.87 s.\n> vacuum_bench_s100.4.shufp80.log:CPU: user: 6.59 s, system: 1.35 s,\n> elapsed: 26.43 s.\n> vacuum_bench_s100.5.shufp80.log:CPU: user: 6.54 s, system: 1.28 s,\n> elapsed: 20.02 s.\n>\n> That's after inlining the compare on both the linear and sequential\n> code, and it seems it lets the compiler optimize the binary search to\n> the point where it outperforms the sequential search.\n>\n> That's not the case when the compare isn't inlined.\n>\n> That seems in line with [1], that show the impact of various\n> optimizations on both algorithms. It's clearly a close enough race\n> that optimizations play a huge role.\n>\n> Since we're not likely to go and implement SSE2-optimized versions, I\n> believe I'll leave the binary search only. That's the attached patch\n> set.\n>\n> I'm running the full test suite, but that takes a very long while.\n> I'll post the results when they're done.\n>\n> [1] https://schani.wordpress.com/2010/04/30/linear-vs-binary-search/\n\nThank you for updating the patch.\n\nI've read this patch again and here are some review comments.\n\n+ * Lookup in that structure proceeds sequentially in the list of segments,\n+ * and with a binary search within each segment. Since segment's size grows\n+ * exponentially, this retains O(log N) lookup complexity (2 log N to be\n+ * precise).\n\nIIUC we now do binary search even over the list of segments.\n\n-----\n\nWe often fetch a particular dead tuple segment. How about providing a\nmacro for easier understanding?\nFor example,\n\n #define GetDeadTuplsSegment(lvrelstats, seg) \\\n (&(lvrelstats)->dead_tuples.dt_segments[(seg)])\n\n-----\n\n+ if (vacrelstats->dead_tuples.num_segs == 0)\n+ return;\n+\n\n+ /* If uninitialized, we have no tuples to delete from the indexes */\n+ if (vacrelstats->dead_tuples.num_segs == 0)\n+ {\n+ return;\n+ }\n\n+ if (vacrelstats->dead_tuples.num_segs == 0)\n+ return false;\n+\n\nAs I listed, there is code to check if dead tuple is initialized\nalready in some places where doing actual vacuum.\nI guess that it should not happen that we attempt to vacuum a\ntable/index page while not having any dead tuple. Is it better to have\nAssert or ereport instead?\n\n-----\n\n@@ -1915,2 +2002,2 @@ count_nondeletable_pages(Relation onerel,\nLVRelStats *vacrelstats)\n- BlockNumber prefetchStart;\n- BlockNumber pblkno;\n+ BlockNumber prefetchStart;\n+ BlockNumber pblkno;\n\nI think that it's a unnecessary change.\n\n-----\n\n+ /* Search for the segment likely to contain the item pointer */\n+ iseg = vac_itemptr_binsrch(\n+ (void *) itemptr,\n+ (void *)\n&(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\n+ vacrelstats->dead_tuples.last_seg + 1,\n+ sizeof(DeadTuplesSegment));\n+\n\nI think that we can change the above to;\n\n+ /* Search for the segment likely to contain the item pointer */\n+ iseg = vac_itemptr_binsrch(\n+ (void *) itemptr,\n+ (void *) &(seg->last_dead_tuple),\n+ vacrelstats->dead_tuples.last_seg + 1,\n+ sizeof(DeadTuplesSegment));\n\nWe set \"seg = vacrelstats->dead_tuples.dt_segments\" just before this.\n\nRegards,\n\n--\nMasahiko Sawada\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\nNTT Open Source Software Center\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 27 Apr 2017 16:25:11 +0900","msg_from":"Masahiko Sawada <sawada.mshk@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Sorry for the delay, I had extended vacations that kept me away from\nmy test rigs, and afterward testing too, liteally, a few weeks.\n\nI built a more thoroguh test script that produced some interesting\nresults. Will attach the results.\n\nFor now, to the review comments:\n\nOn Thu, Apr 27, 2017 at 4:25 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> I've read this patch again and here are some review comments.\n>\n> + * Lookup in that structure proceeds sequentially in the list of segments,\n> + * and with a binary search within each segment. Since segment's size grows\n> + * exponentially, this retains O(log N) lookup complexity (2 log N to be\n> + * precise).\n>\n> IIUC we now do binary search even over the list of segments.\n\nRight\n\n>\n> -----\n>\n> We often fetch a particular dead tuple segment. How about providing a\n> macro for easier understanding?\n> For example,\n>\n> #define GetDeadTuplsSegment(lvrelstats, seg) \\\n> (&(lvrelstats)->dead_tuples.dt_segments[(seg)])\n>\n> -----\n>\n> + if (vacrelstats->dead_tuples.num_segs == 0)\n> + return;\n> +\n>\n> + /* If uninitialized, we have no tuples to delete from the indexes */\n> + if (vacrelstats->dead_tuples.num_segs == 0)\n> + {\n> + return;\n> + }\n>\n> + if (vacrelstats->dead_tuples.num_segs == 0)\n> + return false;\n> +\n\nOk\n\n> As I listed, there is code to check if dead tuple is initialized\n> already in some places where doing actual vacuum.\n> I guess that it should not happen that we attempt to vacuum a\n> table/index page while not having any dead tuple. Is it better to have\n> Assert or ereport instead?\n\nI'm not sure. Having a non-empty dead tuples array is not necessary to\nbe able to honor the contract in the docstring. Most of those functions\nclean up the heap/index of dead tuples given the array of dead tuples,\nwhich is a no-op for an empty array.\n\nThe code that calls those functions doesn't bother calling if the array\nis known empty, true, but there's no compelling reason to enforce that at the\ninterface. Doing so could cause subtle bugs rather than catch them\n(in the form of unexpected assertion failures, if some caller forgot to\ncheck the dead tuples array for emptiness).\n\nIf you're worried about the possibility that some bugs fails to record\ndead tuples in the array, and thus makes VACUUM silently ineffective,\nI instead added a test for that case. This should be a better approach,\nsince it's more likely to catch unexpected failure modes than an assert.\n\n> @@ -1915,2 +2002,2 @@ count_nondeletable_pages(Relation onerel,\n> LVRelStats *vacrelstats)\n> - BlockNumber prefetchStart;\n> - BlockNumber pblkno;\n> + BlockNumber prefetchStart;\n> + BlockNumber pblkno;\n>\n> I think that it's a unnecessary change.\n\nYep. But funnily that's how it's now in master.\n\n>\n> -----\n>\n> + /* Search for the segment likely to contain the item pointer */\n> + iseg = vac_itemptr_binsrch(\n> + (void *) itemptr,\n> + (void *)\n> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\n> + vacrelstats->dead_tuples.last_seg + 1,\n> + sizeof(DeadTuplesSegment));\n> +\n>\n> I think that we can change the above to;\n>\n> + /* Search for the segment likely to contain the item pointer */\n> + iseg = vac_itemptr_binsrch(\n> + (void *) itemptr,\n> + (void *) &(seg->last_dead_tuple),\n> + vacrelstats->dead_tuples.last_seg + 1,\n> + sizeof(DeadTuplesSegment));\n>\n> We set \"seg = vacrelstats->dead_tuples.dt_segments\" just before this.\n\nRight\n\nAttached is a current version of both patches, rebased since we're at it.\n\nI'm also attaching the output from the latest benchmark runs, in raw\n(tar.bz2) and digested (bench_report) forms, the script used to run\nthem (vacuumbench.sh) and to produce the reports\n(vacuum_bench_report.sh).\n\nThose are before the changes in the review. While I don't expect any\nchange, I'll re-run some of them just in case, and try to investigate\nthe slowdown. But that will take forever. Each run takes about a week\non my test rig, and I don't have enough hardware to parallelize the\ntests. I will run a test on a snapshot of a particularly troublesome\nproduction database we have, that should be interesting.\n\nThe benchmarks show a consistent improvement at scale 400, which may\nbe related to the search implementation being better somehow, and a\nslowdown at scale 4000 in some variants. I believe this is due to\nthose variants having highly clustered indexes. While the \"shuf\"\n(shuffled) variantes were intended to be the opposite of that, I\nsuspect I somehow failed to get the desired outcome, so I'll be\ndouble-checking that.\n\nIn any case the slowdown is only materialized when vacuuming with a\nlarge mwm setting, which is something that shouldn't happen\nunintentionally.\n\n\n\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 10 Jul 2017 20:04:42 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Resending without the .tar.bz2 that get blocked\n\n\nSorry for the delay, I had extended vacations that kept me away from\nmy test rigs, and afterward testing too, liteally, a few weeks.\n\nI built a more thoroguh test script that produced some interesting\nresults. Will attach the results.\n\nFor now, to the review comments:\n\nOn Thu, Apr 27, 2017 at 4:25 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\n> I've read this patch again and here are some review comments.\n>\n> + * Lookup in that structure proceeds sequentially in the list of segments,\n> + * and with a binary search within each segment. Since segment's size grows\n> + * exponentially, this retains O(log N) lookup complexity (2 log N to be\n> + * precise).\n>\n> IIUC we now do binary search even over the list of segments.\n\nRight\n\n>\n> -----\n>\n> We often fetch a particular dead tuple segment. How about providing a\n> macro for easier understanding?\n> For example,\n>\n> #define GetDeadTuplsSegment(lvrelstats, seg) \\\n> (&(lvrelstats)->dead_tuples.dt_segments[(seg)])\n>\n> -----\n>\n> + if (vacrelstats->dead_tuples.num_segs == 0)\n> + return;\n> +\n>\n> + /* If uninitialized, we have no tuples to delete from the indexes */\n> + if (vacrelstats->dead_tuples.num_segs == 0)\n> + {\n> + return;\n> + }\n>\n> + if (vacrelstats->dead_tuples.num_segs == 0)\n> + return false;\n> +\n\nOk\n\n> As I listed, there is code to check if dead tuple is initialized\n> already in some places where doing actual vacuum.\n> I guess that it should not happen that we attempt to vacuum a\n> table/index page while not having any dead tuple. Is it better to have\n> Assert or ereport instead?\n\nI'm not sure. Having a non-empty dead tuples array is not necessary to\nbe able to honor the contract in the docstring. Most of those functions\nclean up the heap/index of dead tuples given the array of dead tuples,\nwhich is a no-op for an empty array.\n\nThe code that calls those functions doesn't bother calling if the array\nis known empty, true, but there's no compelling reason to enforce that at the\ninterface. Doing so could cause subtle bugs rather than catch them\n(in the form of unexpected assertion failures, if some caller forgot to\ncheck the dead tuples array for emptiness).\n\nIf you're worried about the possibility that some bugs fails to record\ndead tuples in the array, and thus makes VACUUM silently ineffective,\nI instead added a test for that case. This should be a better approach,\nsince it's more likely to catch unexpected failure modes than an assert.\n\n> @@ -1915,2 +2002,2 @@ count_nondeletable_pages(Relation onerel,\n> LVRelStats *vacrelstats)\n> - BlockNumber prefetchStart;\n> - BlockNumber pblkno;\n> + BlockNumber prefetchStart;\n> + BlockNumber pblkno;\n>\n> I think that it's a unnecessary change.\n\nYep. But funnily that's how it's now in master.\n\n>\n> -----\n>\n> + /* Search for the segment likely to contain the item pointer */\n> + iseg = vac_itemptr_binsrch(\n> + (void *) itemptr,\n> + (void *)\n> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\n> + vacrelstats->dead_tuples.last_seg + 1,\n> + sizeof(DeadTuplesSegment));\n> +\n>\n> I think that we can change the above to;\n>\n> + /* Search for the segment likely to contain the item pointer */\n> + iseg = vac_itemptr_binsrch(\n> + (void *) itemptr,\n> + (void *) &(seg->last_dead_tuple),\n> + vacrelstats->dead_tuples.last_seg + 1,\n> + sizeof(DeadTuplesSegment));\n>\n> We set \"seg = vacrelstats->dead_tuples.dt_segments\" just before this.\n\nRight\n\nAttached is a current version of both patches, rebased since we're at it.\n\nI'm also attaching the output from the latest benchmark runs, in raw\n(tar.bz2) and digested (bench_report) forms, the script used to run\nthem (vacuumbench.sh) and to produce the reports\n(vacuum_bench_report.sh).\n\nThose are before the changes in the review. While I don't expect any\nchange, I'll re-run some of them just in case, and try to investigate\nthe slowdown. But that will take forever. Each run takes about a week\non my test rig, and I don't have enough hardware to parallelize the\ntests. I will run a test on a snapshot of a particularly troublesome\nproduction database we have, that should be interesting.\n\nThe benchmarks show a consistent improvement at scale 400, which may\nbe related to the search implementation being better somehow, and a\nslowdown at scale 4000 in some variants. I believe this is due to\nthose variants having highly clustered indexes. While the \"shuf\"\n(shuffled) variantes were intended to be the opposite of that, I\nsuspect I somehow failed to get the desired outcome, so I'll be\ndouble-checking that.\n\nIn any case the slowdown is only materialized when vacuuming with a\nlarge mwm setting, which is something that shouldn't happen\nunintentionally.\n\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 11 Jul 2017 13:51:03 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Fwd: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Thank you for the patch and benchmark results, I have a couple remarks.\nFirstly, padding in DeadTuplesSegment\n\ntypedef struct DeadTuplesSegment\n\n{\n\n ItemPointerData last_dead_tuple; /* Copy of the last dead tuple \n(unset\n\n * until the segment is fully\n\n * populated). Keep it first to \nsimplify\n\n * binary searches */\n\n unsigned short padding; /* Align dt_tids to 32-bits,\n\n * sizeof(ItemPointerData) is aligned to\n\n * short, so add a padding short, to \nmake the\n\n * size of DeadTuplesSegment a multiple of\n\n * 32-bits and align integer components \nfor\n\n * better performance during lookups \ninto the\n\n * multiarray */\n\n int num_dead_tuples; /* # of entries in the segment */\n\n int max_dead_tuples; /* # of entries allocated in the \nsegment */\n\n ItemPointer dt_tids; /* Array of dead tuples */\n\n} DeadTuplesSegment;\n\nIn the comments to ItemPointerData is written that it is 6 bytes long, \nbut can be padded to 8 bytes by some compilers, so if we add padding in \na current way, there is no guaranty that it will be done as it is \nexpected. The other way to do it with pg_attribute_alligned. But in my \nopinion, there is no need to do it manually, because the compiler will \ndo this optimization itself.\n\nOn 11.07.2017 19:51, Claudio Freire wrote:\n>> -----\n>>\n>> + /* Search for the segment likely to contain the item pointer */\n>> + iseg = vac_itemptr_binsrch(\n>> + (void *) itemptr,\n>> + (void *)\n>> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\n>> + vacrelstats->dead_tuples.last_seg + 1,\n>> + sizeof(DeadTuplesSegment));\n>> +\n>>\n>> I think that we can change the above to;\n>>\n>> + /* Search for the segment likely to contain the item pointer */\n>> + iseg = vac_itemptr_binsrch(\n>> + (void *) itemptr,\n>> + (void *) &(seg->last_dead_tuple),\n>> + vacrelstats->dead_tuples.last_seg + 1,\n>> + sizeof(DeadTuplesSegment));\n>>\n>> We set \"seg = vacrelstats->dead_tuples.dt_segments\" just before this.\n> Right\nIn my mind, if you change vacrelstats->dead_tuples.last_seg + 1 with \nGetNumDeadTuplesSegments(vacrelstats), it would be more meaningful.\nBesides, you can change the vac_itemptr_binsrch within the segment with \nstdlib bsearch, like:\n\n res = (ItemPointer) bsearch((void *) itemptr,\n\n (void *) seg->dt_tids,\n\n seg->num_dead_tuples,\n\n sizeof(ItemPointerData),\n\n vac_cmp_itemptr);\n\n return (res != NULL);\n\n> Those are before the changes in the review. While I don't expect any\n> change, I'll re-run some of them just in case, and try to investigate\n> the slowdown. But that will take forever. Each run takes about a week\n> on my test rig, and I don't have enough hardware to parallelize the\n> tests. I will run a test on a snapshot of a particularly troublesome\n> production database we have, that should be interesting.\nVery interesting, waiting for the results.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 12 Jul 2017 17:48:04 +0300","msg_from":"Alexey Chernyshov <a.chernyshov@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Jul 12, 2017 at 11:48 AM, Alexey Chernyshov\n<a.chernyshov@postgrespro.ru> wrote:\n> Thank you for the patch and benchmark results, I have a couple remarks.\n> Firstly, padding in DeadTuplesSegment\n>\n> typedef struct DeadTuplesSegment\n>\n> {\n>\n> ItemPointerData last_dead_tuple; /* Copy of the last dead tuple\n> (unset\n>\n> * until the segment is fully\n>\n> * populated). Keep it first to\n> simplify\n>\n> * binary searches */\n>\n> unsigned short padding; /* Align dt_tids to 32-bits,\n>\n> * sizeof(ItemPointerData) is aligned to\n>\n> * short, so add a padding short, to make\n> the\n>\n> * size of DeadTuplesSegment a multiple of\n>\n> * 32-bits and align integer components for\n>\n> * better performance during lookups into\n> the\n>\n> * multiarray */\n>\n> int num_dead_tuples; /* # of entries in the segment */\n>\n> int max_dead_tuples; /* # of entries allocated in the\n> segment */\n>\n> ItemPointer dt_tids; /* Array of dead tuples */\n>\n> } DeadTuplesSegment;\n>\n> In the comments to ItemPointerData is written that it is 6 bytes long, but\n> can be padded to 8 bytes by some compilers, so if we add padding in a\n> current way, there is no guaranty that it will be done as it is expected.\n> The other way to do it with pg_attribute_alligned. But in my opinion, there\n> is no need to do it manually, because the compiler will do this optimization\n> itself.\n\nI'll look into it. But my experience is that compilers won't align\nstruct size like this, only attributes, and this attribute is composed\nof 16-bit attributes so it doesn't get aligned by default.\n\n> On 11.07.2017 19:51, Claudio Freire wrote:\n>>>\n>>> -----\n>>>\n>>> + /* Search for the segment likely to contain the item pointer */\n>>> + iseg = vac_itemptr_binsrch(\n>>> + (void *) itemptr,\n>>> + (void *)\n>>> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\n>>> + vacrelstats->dead_tuples.last_seg + 1,\n>>> + sizeof(DeadTuplesSegment));\n>>> +\n>>>\n>>> I think that we can change the above to;\n>>>\n>>> + /* Search for the segment likely to contain the item pointer */\n>>> + iseg = vac_itemptr_binsrch(\n>>> + (void *) itemptr,\n>>> + (void *) &(seg->last_dead_tuple),\n>>> + vacrelstats->dead_tuples.last_seg + 1,\n>>> + sizeof(DeadTuplesSegment));\n>>>\n>>> We set \"seg = vacrelstats->dead_tuples.dt_segments\" just before this.\n>>\n>> Right\n>\n> In my mind, if you change vacrelstats->dead_tuples.last_seg + 1 with\n> GetNumDeadTuplesSegments(vacrelstats), it would be more meaningful.\n\nIt's not the same thing. The first run it might, but after a reset of\nthe multiarray, num segments is the allocated size, while last_seg is\nthe last one filled with data.\n\n> Besides, you can change the vac_itemptr_binsrch within the segment with\n> stdlib bsearch, like:\n>\n> res = (ItemPointer) bsearch((void *) itemptr,\n>\n> (void *) seg->dt_tids,\n>\n> seg->num_dead_tuples,\n>\n> sizeof(ItemPointerData),\n>\n> vac_cmp_itemptr);\n>\n> return (res != NULL);\n\nThe stdlib's bsearch is quite slower. The custom bsearch inlines the\ncomparison making it able to factor out of the loop quite a bit of\nlogic, and in general generate far more specialized assembly.\n\nFor the compiler to optimize the stdlib's bsearch call, whole-program\noptimization should be enabled, something that is unlikely. Even then,\nit may not be able to, due to aliasing rules.\n\nThis is what I came up to make the new approach's performance on par\nor better than the old one, in CPU cycles. In fact, benchmarks show\nthat time spent on the CPU is lower now, in large part, due to this.\n\nIt's not like it's the first custom binary search in postgres, also.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 12 Jul 2017 13:08:12 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Jul 12, 2017 at 1:08 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Jul 12, 2017 at 11:48 AM, Alexey Chernyshov\n> <a.chernyshov@postgrespro.ru> wrote:\n>> Thank you for the patch and benchmark results, I have a couple remarks.\n>> Firstly, padding in DeadTuplesSegment\n>>\n>> typedef struct DeadTuplesSegment\n>>\n>> {\n>>\n>> ItemPointerData last_dead_tuple; /* Copy of the last dead tuple\n>> (unset\n>>\n>> * until the segment is fully\n>>\n>> * populated). Keep it first to\n>> simplify\n>>\n>> * binary searches */\n>>\n>> unsigned short padding; /* Align dt_tids to 32-bits,\n>>\n>> * sizeof(ItemPointerData) is aligned to\n>>\n>> * short, so add a padding short, to make\n>> the\n>>\n>> * size of DeadTuplesSegment a multiple of\n>>\n>> * 32-bits and align integer components for\n>>\n>> * better performance during lookups into\n>> the\n>>\n>> * multiarray */\n>>\n>> int num_dead_tuples; /* # of entries in the segment */\n>>\n>> int max_dead_tuples; /* # of entries allocated in the\n>> segment */\n>>\n>> ItemPointer dt_tids; /* Array of dead tuples */\n>>\n>> } DeadTuplesSegment;\n>>\n>> In the comments to ItemPointerData is written that it is 6 bytes long, but\n>> can be padded to 8 bytes by some compilers, so if we add padding in a\n>> current way, there is no guaranty that it will be done as it is expected.\n>> The other way to do it with pg_attribute_alligned. But in my opinion, there\n>> is no need to do it manually, because the compiler will do this optimization\n>> itself.\n>\n> I'll look into it. But my experience is that compilers won't align\n> struct size like this, only attributes, and this attribute is composed\n> of 16-bit attributes so it doesn't get aligned by default.\n\nDoing sizeof(DeadTuplesSegment) suggests you were indeed right, at\nleast in GCC. I'll remove the padding.\n\nSeems I just got the wrong impression at some point.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 12 Jul 2017 13:29:21 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Jul 12, 2017 at 1:29 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Jul 12, 2017 at 1:08 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Wed, Jul 12, 2017 at 11:48 AM, Alexey Chernyshov\n>> <a.chernyshov@postgrespro.ru> wrote:\n>>> Thank you for the patch and benchmark results, I have a couple remarks.\n>>> Firstly, padding in DeadTuplesSegment\n>>>\n>>> typedef struct DeadTuplesSegment\n>>>\n>>> {\n>>>\n>>> ItemPointerData last_dead_tuple; /* Copy of the last dead tuple\n>>> (unset\n>>>\n>>> * until the segment is fully\n>>>\n>>> * populated). Keep it first to\n>>> simplify\n>>>\n>>> * binary searches */\n>>>\n>>> unsigned short padding; /* Align dt_tids to 32-bits,\n>>>\n>>> * sizeof(ItemPointerData) is aligned to\n>>>\n>>> * short, so add a padding short, to make\n>>> the\n>>>\n>>> * size of DeadTuplesSegment a multiple of\n>>>\n>>> * 32-bits and align integer components for\n>>>\n>>> * better performance during lookups into\n>>> the\n>>>\n>>> * multiarray */\n>>>\n>>> int num_dead_tuples; /* # of entries in the segment */\n>>>\n>>> int max_dead_tuples; /* # of entries allocated in the\n>>> segment */\n>>>\n>>> ItemPointer dt_tids; /* Array of dead tuples */\n>>>\n>>> } DeadTuplesSegment;\n>>>\n>>> In the comments to ItemPointerData is written that it is 6 bytes long, but\n>>> can be padded to 8 bytes by some compilers, so if we add padding in a\n>>> current way, there is no guaranty that it will be done as it is expected.\n>>> The other way to do it with pg_attribute_alligned. But in my opinion, there\n>>> is no need to do it manually, because the compiler will do this optimization\n>>> itself.\n>>\n>> I'll look into it. But my experience is that compilers won't align\n>> struct size like this, only attributes, and this attribute is composed\n>> of 16-bit attributes so it doesn't get aligned by default.\n>\n> Doing sizeof(DeadTuplesSegment) suggests you were indeed right, at\n> least in GCC. I'll remove the padding.\n>\n> Seems I just got the wrong impression at some point.\n\nUpdated versions of the patches attached.\n\nA few runs of the benchmark show no significant difference, as it\nshould (being all cosmetic changes).\n\nThe bigger benchmark will take longer.\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 13 Jul 2017 22:06:52 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> Indeed they do, and that's what motivated this patch. But I'd need\n> TB-sized tables to set up something like that. I don't have the\n> hardware or time available to do that (vacuum on bloated TB-sized\n> tables can take days in my experience). Scale 4000 is as big as I can\n> get without running out of space for the tests in my test hardware.\n>\n> If anybody else has the ability, I'd be thankful if they did test it\n> under those conditions, but I cannot. I think Anastasia's test is\n> closer to such a test, that's probably why it shows a bigger\n> improvement in total elapsed time.\n>\n> Our production database could possibly be used, but it can take about\n> a week to clone it, upgrade it (it's 9.5 currently), and run the\n> relevant vacuum.\n\nIt looks like I won't be able to do that test with a production\nsnapshot anytime soon.\n\nGetting approval for the budget required to do that looks like it's\ngoing to take far longer than I thought.\n\nRegardless of that, I think the patch can move forward. I'm still\nplanning to do the test at some point, but this patch shouldn't block\non it.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 18 Aug 2017 08:39:15 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"> On 18 Aug 2017, at 13:39, Claudio Freire <klaussfreire@gmail.com> wrote:\n> \n> On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> Indeed they do, and that's what motivated this patch. But I'd need\n>> TB-sized tables to set up something like that. I don't have the\n>> hardware or time available to do that (vacuum on bloated TB-sized\n>> tables can take days in my experience). Scale 4000 is as big as I can\n>> get without running out of space for the tests in my test hardware.\n>> \n>> If anybody else has the ability, I'd be thankful if they did test it\n>> under those conditions, but I cannot. I think Anastasia's test is\n>> closer to such a test, that's probably why it shows a bigger\n>> improvement in total elapsed time.\n>> \n>> Our production database could possibly be used, but it can take about\n>> a week to clone it, upgrade it (it's 9.5 currently), and run the\n>> relevant vacuum.\n> \n> It looks like I won't be able to do that test with a production\n> snapshot anytime soon.\n> \n> Getting approval for the budget required to do that looks like it's\n> going to take far longer than I thought.\n> \n> Regardless of that, I think the patch can move forward. I'm still\n> planning to do the test at some point, but this patch shouldn't block\n> on it.\n\nThis patch has been marked Ready for committer after review, but wasn’t\ncommitted in the current commitfest so it will be moved to the next. Since it\nno longer applies cleanly, it’s being reset to Waiting for author though.\n\ncheers ./daniel\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 2 Oct 2017 01:36:17 +0200","msg_from":"Daniel Gustafsson <daniel@yesql.se>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Sun, Oct 1, 2017 at 8:36 PM, Daniel Gustafsson <daniel@yesql.se> wrote:\n>> On 18 Aug 2017, at 13:39, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>\n>> On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> Indeed they do, and that's what motivated this patch. But I'd need\n>>> TB-sized tables to set up something like that. I don't have the\n>>> hardware or time available to do that (vacuum on bloated TB-sized\n>>> tables can take days in my experience). Scale 4000 is as big as I can\n>>> get without running out of space for the tests in my test hardware.\n>>>\n>>> If anybody else has the ability, I'd be thankful if they did test it\n>>> under those conditions, but I cannot. I think Anastasia's test is\n>>> closer to such a test, that's probably why it shows a bigger\n>>> improvement in total elapsed time.\n>>>\n>>> Our production database could possibly be used, but it can take about\n>>> a week to clone it, upgrade it (it's 9.5 currently), and run the\n>>> relevant vacuum.\n>>\n>> It looks like I won't be able to do that test with a production\n>> snapshot anytime soon.\n>>\n>> Getting approval for the budget required to do that looks like it's\n>> going to take far longer than I thought.\n>>\n>> Regardless of that, I think the patch can move forward. I'm still\n>> planning to do the test at some point, but this patch shouldn't block\n>> on it.\n>\n> This patch has been marked Ready for committer after review, but wasn’t\n> committed in the current commitfest so it will be moved to the next. Since it\n> no longer applies cleanly, it’s being reset to Waiting for author though.\n>\n> cheers ./daniel\n\nRebased version of the patches attached\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 2 Oct 2017 11:02:52 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Oct 2, 2017 at 11:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> Rebased version of the patches attached\n\nThe status of the patch is misleading:\nhttps://commitfest.postgresql.org/15/844/. This was marked as waiting\non author but a new version has been published. Let's be careful.\n\nThe last patches I am aware of, aka those from\nhttps://www.postgresql.org/message-id/CAGTBQpZHTf2JtShC=ijc9wzEipo3XOKWQhx+8WiP7ZjPC3FBEg@mail.gmail.com,\ndo not apply. I am moving the patch to the next commit fest with a\nwaiting on author status, as this should be reviewed, but those need a\nrebase.\n-- \nMichael\n\n","msg_date":"Wed, 29 Nov 2017 10:37:07 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Nov 28, 2017 at 10:37 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> On Mon, Oct 2, 2017 at 11:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> Rebased version of the patches attached\n>\n> The status of the patch is misleading:\n> https://commitfest.postgresql.org/15/844/. This was marked as waiting\n> on author but a new version has been published. Let's be careful.\n>\n> The last patches I am aware of, aka those from\n> https://www.postgresql.org/message-id/CAGTBQpZHTf2JtShC=ijc9wzEipo3XOKWQhx+8WiP7ZjPC3FBEg@mail.gmail.com,\n> do not apply. I am moving the patch to the next commit fest with a\n> waiting on author status, as this should be reviewed, but those need a\n> rebase.\n\nThey did apply at the time, but I think major work on vacuum was\npushed since then, and also I was traveling so out of reach.\n\nIt may take some time to rebase them again. Should I move to needs\nreview myself after that?\n\n","msg_date":"Mon, 4 Dec 2017 02:38:21 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> They did apply at the time, but I think major work on vacuum was\n> pushed since then, and also I was traveling so out of reach.\n>\n> It may take some time to rebase them again. Should I move to needs\n> review myself after that?\n\nSure, if you can get into this state, please feel free to update the\nstatus of the patch yourself.\n-- \nMichael\n\n","msg_date":"Mon, 4 Dec 2017 14:58:59 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Greetings,\n\n* Michael Paquier (michael.paquier@gmail.com) wrote:\n> On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> > They did apply at the time, but I think major work on vacuum was\n> > pushed since then, and also I was traveling so out of reach.\n> >\n> > It may take some time to rebase them again. Should I move to needs\n> > review myself after that?\n> \n> Sure, if you can get into this state, please feel free to update the\n> status of the patch yourself.\n\nWe're now over a month since this status update- Claudio, for this to\nhave a chance during this commitfest to be included (which, personally,\nI think would be great as it solves a pretty serious issue..), we really\nneed to have it be rebased and updated. Once that's done, as Michael\nsays, please change the patch status back to 'Needs Review'.\n\nThanks!\n\nStephen","msg_date":"Sat, 6 Jan 2018 17:35:59 -0500","msg_from":"Stephen Frost <sfrost@snowman.net>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Sat, Jan 6, 2018 at 7:35 PM, Stephen Frost <sfrost@snowman.net> wrote:\n\n> Greetings,\n>\n> * Michael Paquier (michael.paquier@gmail.com) wrote:\n> > On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com>\n> wrote:\n> > > They did apply at the time, but I think major work on vacuum was\n> > > pushed since then, and also I was traveling so out of reach.\n> > >\n> > > It may take some time to rebase them again. Should I move to needs\n> > > review myself after that?\n> >\n> > Sure, if you can get into this state, please feel free to update the\n> > status of the patch yourself.\n>\n> We're now over a month since this status update- Claudio, for this to\n> have a chance during this commitfest to be included (which, personally,\n> I think would be great as it solves a pretty serious issue..), we really\n> need to have it be rebased and updated. Once that's done, as Michael\n> says, please change the patch status back to 'Needs Review'.\n>\n\nSorry, had tons of other stuff that took priority.\n\nI'll get to rebase this patch now.\n\nOn Sat, Jan 6, 2018 at 7:35 PM, Stephen Frost <sfrost@snowman.net> wrote:Greetings,\n\n* Michael Paquier (michael.paquier@gmail.com) wrote:\n> On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> > They did apply at the time, but I think major work on vacuum was\n> > pushed since then, and also I was traveling so out of reach.\n> >\n> > It may take some time to rebase them again. Should I move to needs\n> > review myself after that?\n>\n> Sure, if you can get into this state, please feel free to update the\n> status of the patch yourself.\n\nWe're now over a month since this status update- Claudio, for this to\nhave a chance during this commitfest to be included (which, personally,\nI think would be great as it solves a pretty serious issue..), we really\nneed to have it be rebased and updated. Once that's done, as Michael\nsays, please change the patch status back to 'Needs Review'.Sorry, had tons of other stuff that took priority.I'll get to rebase this patch now.","msg_date":"Wed, 17 Jan 2018 17:02:37 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Jan 17, 2018 at 5:02 PM, Claudio Freire <klaussfreire@gmail.com>\nwrote:\n\n>\n>\n> On Sat, Jan 6, 2018 at 7:35 PM, Stephen Frost <sfrost@snowman.net> wrote:\n>\n>> Greetings,\n>>\n>> * Michael Paquier (michael.paquier@gmail.com) wrote:\n>> > On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com>\n>> wrote:\n>> > > They did apply at the time, but I think major work on vacuum was\n>> > > pushed since then, and also I was traveling so out of reach.\n>> > >\n>> > > It may take some time to rebase them again. Should I move to needs\n>> > > review myself after that?\n>> >\n>> > Sure, if you can get into this state, please feel free to update the\n>> > status of the patch yourself.\n>>\n>> We're now over a month since this status update- Claudio, for this to\n>> have a chance during this commitfest to be included (which, personally,\n>> I think would be great as it solves a pretty serious issue..), we really\n>> need to have it be rebased and updated. Once that's done, as Michael\n>> says, please change the patch status back to 'Needs Review'.\n>>\n>\n> Sorry, had tons of other stuff that took priority.\n>\n> I'll get to rebase this patch now.\n>\n>\n>\nHuh. That was simpler than I thought.\n\nAttached rebased versions.","msg_date":"Wed, 17 Jan 2018 17:17:29 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"The following review has been posted through the commitfest application:\nmake installcheck-world: tested, passed\nImplements feature: tested, passed\nSpec compliant: tested, passed\nDocumentation: tested, passed\n\nI can confirm that these patches don't break anything; the code is well\r\ndocumented, has some tests and doesn't do anything obviously wrong. However\r\nI would recommend someone who is more familiar with the VACUUM mechanism than I\r\ndo to recheck these patches.\n\nThe new status of this patch is: Ready for Committer\n","msg_date":"Mon, 22 Jan 2018 15:18:51 +0000","msg_from":"Aleksander Alekseev <a.alekseev@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jan 18, 2018 at 9:17 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> Huh. That was simpler than I thought.\n>\n> Attached rebased versions.\n\nHi Claudio,\n\nFYI the regression test seems to have some run-to-run variation.\nThough it usually succeeds, recently I have seen a couple of failures\nlike this:\n\n========= Contents of ./src/test/regress/regression.diffs\n*** /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/expected/vacuum.out\n2018-01-24 01:41:28.200454371 +0000\n--- /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/results/vacuum.out\n2018-01-24 01:51:07.970049937 +0000\n***************\n*** 128,134 ****\n SELECT pg_relation_size('vactst', 'main');\n pg_relation_size\n ------------------\n! 0\n (1 row)\n\n SELECT count(*) FROM vactst;\n--- 128,134 ----\n SELECT pg_relation_size('vactst', 'main');\n pg_relation_size\n ------------------\n! 8192\n (1 row)\n\n SELECT count(*) FROM vactst;\n======================================================================\n\n-- \nThomas Munro\nhttp://www.enterprisedb.com\n\n","msg_date":"Thu, 25 Jan 2018 20:11:22 +1300","msg_from":"Thomas Munro <thomas.munro@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jan 25, 2018 at 4:11 AM, Thomas Munro\n<thomas.munro@enterprisedb.com> wrote:\n> On Thu, Jan 18, 2018 at 9:17 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> Huh. That was simpler than I thought.\n>>\n>> Attached rebased versions.\n>\n> Hi Claudio,\n>\n> FYI the regression test seems to have some run-to-run variation.\n> Though it usually succeeds, recently I have seen a couple of failures\n> like this:\n>\n> ========= Contents of ./src/test/regress/regression.diffs\n> *** /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/expected/vacuum.out\n> 2018-01-24 01:41:28.200454371 +0000\n> --- /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/results/vacuum.out\n> 2018-01-24 01:51:07.970049937 +0000\n> ***************\n> *** 128,134 ****\n> SELECT pg_relation_size('vactst', 'main');\n> pg_relation_size\n> ------------------\n> ! 0\n> (1 row)\n>\n> SELECT count(*) FROM vactst;\n> --- 128,134 ----\n> SELECT pg_relation_size('vactst', 'main');\n> pg_relation_size\n> ------------------\n> ! 8192\n> (1 row)\n>\n> SELECT count(*) FROM vactst;\n> ======================================================================\n>\n> --\n> Thomas Munro\n> http://www.enterprisedb.com\n\nI'll look into it\n\nHowever, shouldn't an empty relation have an initial page anyway? In\nthat case shouldn't the correct value be 8192?\n\n","msg_date":"Thu, 25 Jan 2018 10:56:08 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Claudio Freire wrote:\n> On Thu, Jan 25, 2018 at 4:11 AM, Thomas Munro\n> <thomas.munro@enterprisedb.com> wrote:\n\n> > *** 128,134 ****\n> > SELECT pg_relation_size('vactst', 'main');\n> > pg_relation_size\n> > ------------------\n> > ! 0\n> > (1 row)\n> >\n> > SELECT count(*) FROM vactst;\n> > --- 128,134 ----\n> > SELECT pg_relation_size('vactst', 'main');\n> > pg_relation_size\n> > ------------------\n> > ! 8192\n> > (1 row)\n\n> However, shouldn't an empty relation have an initial page anyway? In\n> that case shouldn't the correct value be 8192?\n\nNo, it's legal for an empty table to have size 0 on disk.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Thu, 25 Jan 2018 11:41:38 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jan 25, 2018 at 10:56 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Thu, Jan 25, 2018 at 4:11 AM, Thomas Munro\n> <thomas.munro@enterprisedb.com> wrote:\n>> On Thu, Jan 18, 2018 at 9:17 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>> Huh. That was simpler than I thought.\n>>>\n>>> Attached rebased versions.\n>>\n>> Hi Claudio,\n>>\n>> FYI the regression test seems to have some run-to-run variation.\n>> Though it usually succeeds, recently I have seen a couple of failures\n>> like this:\n>>\n>> ========= Contents of ./src/test/regress/regression.diffs\n>> *** /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/expected/vacuum.out\n>> 2018-01-24 01:41:28.200454371 +0000\n>> --- /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/results/vacuum.out\n>> 2018-01-24 01:51:07.970049937 +0000\n>> ***************\n>> *** 128,134 ****\n>> SELECT pg_relation_size('vactst', 'main');\n>> pg_relation_size\n>> ------------------\n>> ! 0\n>> (1 row)\n>>\n>> SELECT count(*) FROM vactst;\n>> --- 128,134 ----\n>> SELECT pg_relation_size('vactst', 'main');\n>> pg_relation_size\n>> ------------------\n>> ! 8192\n>> (1 row)\n>>\n>> SELECT count(*) FROM vactst;\n>> ======================================================================\n>>\n>> --\n>> Thomas Munro\n>> http://www.enterprisedb.com\n>\n> I'll look into it\n\nI had the tests running in a loop all day long, and I cannot reproduce\nthat variance.\n\nCan you share your steps to reproduce it, including configure flags?\n\n","msg_date":"Thu, 25 Jan 2018 17:38:13 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Jan 26, 2018 at 9:38 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> I had the tests running in a loop all day long, and I cannot reproduce\n> that variance.\n>\n> Can you share your steps to reproduce it, including configure flags?\n\nHere are two build logs where it failed:\n\nhttps://travis-ci.org/postgresql-cfbot/postgresql/builds/332968819\nhttps://travis-ci.org/postgresql-cfbot/postgresql/builds/332592511\n\nHere's one where it succeeded:\n\nhttps://travis-ci.org/postgresql-cfbot/postgresql/builds/333139855\n\nThe full build script used is:\n\n./configure --enable-debug --enable-cassert --enable-coverage\n--enable-tap-tests --with-tcl --with-python --with-perl --with-ldap\n--with-icu && make -j4 all contrib docs && make -Otarget -j3\ncheck-world\n\nThis is a virtualised 4 core system. I wonder if \"make -Otarget -j3\ncheck-world\" creates enough load on it to produce some weird timing\neffect that you don't see on your development system.\n\n-- \nThomas Munro\nhttp://www.enterprisedb.com\n\n","msg_date":"Fri, 26 Jan 2018 10:21:14 +1300","msg_from":"Thomas Munro <thomas.munro@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jan 25, 2018 at 6:21 PM, Thomas Munro\n<thomas.munro@enterprisedb.com> wrote:\n> On Fri, Jan 26, 2018 at 9:38 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> I had the tests running in a loop all day long, and I cannot reproduce\n>> that variance.\n>>\n>> Can you share your steps to reproduce it, including configure flags?\n>\n> Here are two build logs where it failed:\n>\n> https://travis-ci.org/postgresql-cfbot/postgresql/builds/332968819\n> https://travis-ci.org/postgresql-cfbot/postgresql/builds/332592511\n>\n> Here's one where it succeeded:\n>\n> https://travis-ci.org/postgresql-cfbot/postgresql/builds/333139855\n>\n> The full build script used is:\n>\n> ./configure --enable-debug --enable-cassert --enable-coverage\n> --enable-tap-tests --with-tcl --with-python --with-perl --with-ldap\n> --with-icu && make -j4 all contrib docs && make -Otarget -j3\n> check-world\n>\n> This is a virtualised 4 core system. I wonder if \"make -Otarget -j3\n> check-world\" creates enough load on it to produce some weird timing\n> effect that you don't see on your development system.\n\nI can't reproduce it, not even with the same build script.\n\nIt's starting to look like a timing effect indeed.\n\nI get a similar effect if there's an active snapshot in another\nsession while vacuum runs. I don't know how the test suite ends up in\nthat situation, but it seems to be the case.\n\nHow do you suggest we go about fixing this? The test in question is\nimportant, I've caught actual bugs in the implementation with it,\nbecause it checks that vacuum effectively frees up space.\n\nI'm thinking this vacuum test could be put on its own parallel group\nperhaps? Since I can't reproduce it, I can't know whether that will\nfix it, but it seems sensible.\n\n","msg_date":"Fri, 2 Feb 2018 19:52:02 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Hello,\n\nAt Fri, 2 Feb 2018 19:52:02 -0300, Claudio Freire <klaussfreire@gmail.com> wrote in <CAGTBQpaiNQSNJC8y4w82UBTaPsvSqRRg++yEi5wre1MFE2iD8Q@mail.gmail.com>\n> On Thu, Jan 25, 2018 at 6:21 PM, Thomas Munro\n> <thomas.munro@enterprisedb.com> wrote:\n> > On Fri, Jan 26, 2018 at 9:38 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> >> I had the tests running in a loop all day long, and I cannot reproduce\n> >> that variance.\n> >>\n> >> Can you share your steps to reproduce it, including configure flags?\n> >\n> > Here are two build logs where it failed:\n> >\n> > https://travis-ci.org/postgresql-cfbot/postgresql/builds/332968819\n> > https://travis-ci.org/postgresql-cfbot/postgresql/builds/332592511\n> >\n> > Here's one where it succeeded:\n> >\n> > https://travis-ci.org/postgresql-cfbot/postgresql/builds/333139855\n> >\n> > The full build script used is:\n> >\n> > ./configure --enable-debug --enable-cassert --enable-coverage\n> > --enable-tap-tests --with-tcl --with-python --with-perl --with-ldap\n> > --with-icu && make -j4 all contrib docs && make -Otarget -j3\n> > check-world\n> >\n> > This is a virtualised 4 core system. I wonder if \"make -Otarget -j3\n> > check-world\" creates enough load on it to produce some weird timing\n> > effect that you don't see on your development system.\n> \n> I can't reproduce it, not even with the same build script.\n\nI had the same error by \"make -j3 check-world\" but only twice\nfrom many trials.\n\n> It's starting to look like a timing effect indeed.\n\nIt seems to be truncation skip, maybe caused by concurrent\nautovacuum. See lazy_truncate_heap() for details. Updates of\npg_stat_*_tables can be delayed so looking it also can fail. Even\nthough I haven't looked the patch closer, the \"SELECT\npg_relation_size()\" doesn't seem to give something meaningful\nanyway.\n\n> I get a similar effect if there's an active snapshot in another\n> session while vacuum runs. I don't know how the test suite ends up in\n> that situation, but it seems to be the case.\n> \n> How do you suggest we go about fixing this? The test in question is\n> important, I've caught actual bugs in the implementation with it,\n> because it checks that vacuum effectively frees up space.\n> \n> I'm thinking this vacuum test could be put on its own parallel group\n> perhaps? Since I can't reproduce it, I can't know whether that will\n> fix it, but it seems sensible.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n","msg_date":"Tue, 06 Feb 2018 16:35:42 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>> It's starting to look like a timing effect indeed.\n>\n> It seems to be truncation skip, maybe caused by concurrent\n> autovacuum.\n\nGood point, I'll also disable autovacuum on vactst.\n\n> See lazy_truncate_heap() for details. Updates of\n> pg_stat_*_tables can be delayed so looking it also can fail. Even\n> though I haven't looked the patch closer, the \"SELECT\n> pg_relation_size()\" doesn't seem to give something meaningful\n> anyway.\n\nMaybe then \"explain (analyze, buffers, costs off, timing off, summary\noff) select * from vactst\" then.\n\nThe point is to check that the relation's heap has 0 pages.\n\n","msg_date":"Tue, 6 Feb 2018 10:18:05 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Feb 6, 2018 at 10:18 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>>> It's starting to look like a timing effect indeed.\n>>\n>> It seems to be truncation skip, maybe caused by concurrent\n>> autovacuum.\n>\n> Good point, I'll also disable autovacuum on vactst.\n>\n>> See lazy_truncate_heap() for details. Updates of\n>> pg_stat_*_tables can be delayed so looking it also can fail. Even\n>> though I haven't looked the patch closer, the \"SELECT\n>> pg_relation_size()\" doesn't seem to give something meaningful\n>> anyway.\n>\n> Maybe then \"explain (analyze, buffers, costs off, timing off, summary\n> off) select * from vactst\" then.\n>\n> The point is to check that the relation's heap has 0 pages.\n\nAttached rebased patches with those changes mentioned above, namely:\n\n- vacuum test now creates vactst with autovacuum disabled for it\n- vacuum test on its own parallel group\n- use explain analyze instead of pg_relation_size to check the\nrelation is properly truncated","msg_date":"Tue, 6 Feb 2018 10:41:22 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Hello,\n\nAt Tue, 6 Feb 2018 10:41:22 -0300, Claudio Freire <klaussfreire@gmail.com> wrote in <CAGTBQpaufC0o8OikWd8=5biXcbYjT51mPLfmy22NUjX6kUED0A@mail.gmail.com>\n> On Tue, Feb 6, 2018 at 10:18 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> > On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\n> > <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> >>> It's starting to look like a timing effect indeed.\n> >>\n> >> It seems to be truncation skip, maybe caused by concurrent\n> >> autovacuum.\n> >\n> > Good point, I'll also disable autovacuum on vactst.\n> >\n> >> See lazy_truncate_heap() for details. Updates of\n> >> pg_stat_*_tables can be delayed so looking it also can fail. Even\n> >> though I haven't looked the patch closer, the \"SELECT\n> >> pg_relation_size()\" doesn't seem to give something meaningful\n> >> anyway.\n> >\n> > Maybe then \"explain (analyze, buffers, costs off, timing off, summary\n> > off) select * from vactst\" then.\n\nAh, sorry. I meant by the above that it gives unstable result\nwith autovacuum. So pg_relation_size() is usable after you turned\nof autovacuum on the table.\n\n> > The point is to check that the relation's heap has 0 pages.\n> \n> Attached rebased patches with those changes mentioned above, namely:\n> \n> - vacuum test now creates vactst with autovacuum disabled for it\n> - vacuum test on its own parallel group\n> - use explain analyze instead of pg_relation_size to check the\n> relation is properly truncated\n\nThe problematic test was in the 0001..v14 patch. The new\n0001..v15 is identical to v14 and instead 0003-v8 has additional\npart that edits the test and expects added by 0001 into the shape\nas above. It seems that you merged the fixup onto the wrong\ncommit.\n\nAnd may we assume it correct that 0002 is missing in this\npatchset?\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n","msg_date":"Wed, 07 Feb 2018 12:50:11 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 7, 2018 at 12:50 AM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> Hello,\n>\n> At Tue, 6 Feb 2018 10:41:22 -0300, Claudio Freire <klaussfreire@gmail.com> wrote in <CAGTBQpaufC0o8OikWd8=5biXcbYjT51mPLfmy22NUjX6kUED0A@mail.gmail.com>\n>> On Tue, Feb 6, 2018 at 10:18 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> > On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\n>> > <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>> >>> It's starting to look like a timing effect indeed.\n>> >>\n>> >> It seems to be truncation skip, maybe caused by concurrent\n>> >> autovacuum.\n>> >\n>> > Good point, I'll also disable autovacuum on vactst.\n>> >\n>> >> See lazy_truncate_heap() for details. Updates of\n>> >> pg_stat_*_tables can be delayed so looking it also can fail. Even\n>> >> though I haven't looked the patch closer, the \"SELECT\n>> >> pg_relation_size()\" doesn't seem to give something meaningful\n>> >> anyway.\n>> >\n>> > Maybe then \"explain (analyze, buffers, costs off, timing off, summary\n>> > off) select * from vactst\" then.\n>\n> Ah, sorry. I meant by the above that it gives unstable result\n> with autovacuum. So pg_relation_size() is usable after you turned\n> of autovacuum on the table.\n\nYou did mention stats could be delayed\n\n>> > The point is to check that the relation's heap has 0 pages.\n>>\n>> Attached rebased patches with those changes mentioned above, namely:\n>>\n>> - vacuum test now creates vactst with autovacuum disabled for it\n>> - vacuum test on its own parallel group\n>> - use explain analyze instead of pg_relation_size to check the\n>> relation is properly truncated\n>\n> The problematic test was in the 0001..v14 patch. The new\n> 0001..v15 is identical to v14 and instead 0003-v8 has additional\n> part that edits the test and expects added by 0001 into the shape\n> as above. It seems that you merged the fixup onto the wrong\n> commit.\n>\n> And may we assume it correct that 0002 is missing in this\n> patchset?\n\nSounds like I botched the rebase. Sorry about that.\n\nAttached are corrected versions (1-v16 and 3-v9)","msg_date":"Wed, 7 Feb 2018 11:36:54 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Claudio Freire wrote:\n\n> - vacuum test on its own parallel group\n\nHmm, this solution is not very friendly to the goal of reducing test\nruntime, particularly since the new test creates a nontrivial-sized\ntable. Maybe we can find a better alternative. Can we use some wait\nlogic instead? Maybe something like grab a snapshot of running VXIDs\nand loop waiting until they're all gone before doing the vacuum?\n\nAlso, I don't understand why pg_relation_size() is not a better solution\nto determining the table size compared to explain.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Wed, 7 Feb 2018 19:57:30 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 7, 2018 at 7:57 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n> Claudio Freire wrote:\n>\n>> - vacuum test on its own parallel group\n>\n> Hmm, this solution is not very friendly to the goal of reducing test\n> runtime, particularly since the new test creates a nontrivial-sized\n> table. Maybe we can find a better alternative. Can we use some wait\n> logic instead? Maybe something like grab a snapshot of running VXIDs\n> and loop waiting until they're all gone before doing the vacuum?\n\nI'm not sure there's any alternative. I did some tests and any active\nsnapshot on any other table, not necessarily on the one being\nvacuumed, distorted the test. And it makes sense, since that snapshot\nmakes those deleted tuples unvacuumable.\n\nWaiting as you say would be akin to what the patch does by putting\nvacuum on its own parallel group.\n\nI'm guessing all tests write something to the database, so all tests\nwill create a snapshot. Maybe if there were read-only tests, those\nmight be safe to include in vacuum's parallel group, but otherwise I\ndon't see any alternative.\n\n> Also, I don't understand why pg_relation_size() is not a better solution\n> to determining the table size compared to explain.\n\nI was told pg_relation_size can return stale information. I didn't\ncheck, I took that at face value.\n\n","msg_date":"Wed, 7 Feb 2018 20:45:50 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Claudio Freire wrote:\n> On Wed, Feb 7, 2018 at 7:57 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n> > Claudio Freire wrote:\n\n> > Hmm, this solution is not very friendly to the goal of reducing test\n> > runtime, particularly since the new test creates a nontrivial-sized\n> > table. Maybe we can find a better alternative. Can we use some wait\n> > logic instead? Maybe something like grab a snapshot of running VXIDs\n> > and loop waiting until they're all gone before doing the vacuum?\n> \n> I'm not sure there's any alternative. I did some tests and any active\n> snapshot on any other table, not necessarily on the one being\n> vacuumed, distorted the test. And it makes sense, since that snapshot\n> makes those deleted tuples unvacuumable.\n\nSure.\n\n> Waiting as you say would be akin to what the patch does by putting\n> vacuum on its own parallel group.\n\nI don't think it's the same. We don't need to wait until all the\nconcurrent tests are done -- we only need to wait until the transactions\nthat were current when the delete finished are done, which is very\ndifferent since each test runs tons of small transactions rather than\none single big transaction.\n\n> > Also, I don't understand why pg_relation_size() is not a better solution\n> > to determining the table size compared to explain.\n> \n> I was told pg_relation_size can return stale information. I didn't\n> check, I took that at face value.\n\nHmm, it uses stat() on the table files. I think those files would be\ntruncated at the time the transaction commits, so they shouldn't be\nstale. (I don't think the system waits for a checkpoint to flush a\ntruncation.) Maybe relying on that is not reliable or future-proof\nenough. Anyway this is a minor point -- the one above worries me most.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Wed, 7 Feb 2018 20:52:26 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n>> Waiting as you say would be akin to what the patch does by putting\n>> vacuum on its own parallel group.\n>\n> I don't think it's the same. We don't need to wait until all the\n> concurrent tests are done -- we only need to wait until the transactions\n> that were current when the delete finished are done, which is very\n> different since each test runs tons of small transactions rather than\n> one single big transaction.\n\nUm... maybe \"lock pg_class\" ?\n\nThat should conflict with basically any other running transaction and\nhave pretty much that effect.\n\nAttached is a version of patch 1 with that approach.","msg_date":"Wed, 7 Feb 2018 21:21:29 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Claudio Freire wrote:\n> On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n> >> Waiting as you say would be akin to what the patch does by putting\n> >> vacuum on its own parallel group.\n> >\n> > I don't think it's the same. We don't need to wait until all the\n> > concurrent tests are done -- we only need to wait until the transactions\n> > that were current when the delete finished are done, which is very\n> > different since each test runs tons of small transactions rather than\n> > one single big transaction.\n> \n> Um... maybe \"lock pg_class\" ?\n\nI was thinking in first doing \n SELECT array_agg(DISTINCT virtualtransaction) vxids\n FROM pg_locks \\gset\n\nand then in a DO block loop until\n\n SELECT DISTINCT virtualtransaction\n FROM pg_locks\nINTERSECT\n SELECT (unnest(:'vxids'::text[]));\n\nreturns empty; something along those lines.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Wed, 7 Feb 2018 23:29:34 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Wed, Feb 7, 2018 at 11:29 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n> Claudio Freire wrote:\n>> On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n>> >> Waiting as you say would be akin to what the patch does by putting\n>> >> vacuum on its own parallel group.\n>> >\n>> > I don't think it's the same. We don't need to wait until all the\n>> > concurrent tests are done -- we only need to wait until the transactions\n>> > that were current when the delete finished are done, which is very\n>> > different since each test runs tons of small transactions rather than\n>> > one single big transaction.\n>>\n>> Um... maybe \"lock pg_class\" ?\n>\n> I was thinking in first doing\n> SELECT array_agg(DISTINCT virtualtransaction) vxids\n> FROM pg_locks \\gset\n>\n> and then in a DO block loop until\n>\n> SELECT DISTINCT virtualtransaction\n> FROM pg_locks\n> INTERSECT\n> SELECT (unnest(:'vxids'::text[]));\n>\n> returns empty; something along those lines.\n\nIsn't it the same though?\n\nI can't think how a transaction wouldn't be holding at least an access\nshare on pg_class.\n\n","msg_date":"Thu, 8 Feb 2018 00:13:09 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Feb 8, 2018 at 12:13 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Wed, Feb 7, 2018 at 11:29 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n>> Claudio Freire wrote:\n>>> On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n>>> >> Waiting as you say would be akin to what the patch does by putting\n>>> >> vacuum on its own parallel group.\n>>> >\n>>> > I don't think it's the same. We don't need to wait until all the\n>>> > concurrent tests are done -- we only need to wait until the transactions\n>>> > that were current when the delete finished are done, which is very\n>>> > different since each test runs tons of small transactions rather than\n>>> > one single big transaction.\n>>>\n>>> Um... maybe \"lock pg_class\" ?\n>>\n>> I was thinking in first doing\n>> SELECT array_agg(DISTINCT virtualtransaction) vxids\n>> FROM pg_locks \\gset\n>>\n>> and then in a DO block loop until\n>>\n>> SELECT DISTINCT virtualtransaction\n>> FROM pg_locks\n>> INTERSECT\n>> SELECT (unnest(:'vxids'::text[]));\n>>\n>> returns empty; something along those lines.\n>\n> Isn't it the same though?\n>\n> I can't think how a transaction wouldn't be holding at least an access\n> share on pg_class.\n\nNever mind, I just saw the error of my ways.\n\nI don't like looping, though, seems overly cumbersome. What's worse?\nmaintaining that fragile weird loop that might break (by causing\nunexpected output), or a slight slowdown of the test suite? I don't\nknow how long it might take on slow machines, but in my machine, which\nisn't a great machine, while the vacuum test isn't fast indeed, it's\njust a tiny fraction of what a simple \"make check\" takes. So it's not\na huge slowdown in any case.\n\nI'll give it some thought, maybe there's a simpler way.\n\n","msg_date":"Thu, 8 Feb 2018 00:34:42 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Hello, I looked this a bit closer.\n\nIn upthread[1] Robert mentioned the exponentially increasing size\nof additional segments.\n\n>> Hmm, I had imagined making all of the segments the same size rather\n>> than having the size grow exponentially. The whole point of this is\n>> to save memory, and even in the worst case you don't end up with that\n>> many segments as long as you pick a reasonable base size (e.g. 64MB).\n>\n> Wastage is bound by a fraction of the total required RAM, that is,\n> it's proportional to the amount of required RAM, not the amount\n> allocated. So it should still be fine, and the exponential strategy\n> should improve lookup performance considerably.\n\nIt seems that you are getting him wrong. (Anyway I'm not sure\nwhat you meant by the above. not-yet-allocated memory won't be a\nwaste.) The conclusive number of dead tuples in a heap scan is\nundeteminable until the scan ends. If we had a new dead tuple\nrequired a, say 512MB new segment and the scan ends just after,\nthe wastage will be almost the whole of the segment.\n\nOn the other hand, I don't think the exponential strategy make\nthings considerably better. bsearch iterations in\nlazy_tid_reaped() are distributed between segment search and tid\nsearch. Intuitively more or less the increased segment size just\nmoves some iterations of the former to the latter.\n\nI made a calculation[2]. With maintemance_work_mem of 4096MB, the\nnumber of segments is 6 and expected number of bsearch iteration\nis about 20.8 for the exponential strategy. With 64MB fixed size\nsegments, we will have 64 segments (that is not so many) and the\nexpected iteration is 20.4. (I suppose the increase comes from\nthe imbalanced size among segments.) Addition to that, as Robert\nmentioned, the possible maximum memory wastage of the exponential\nstrategy is about 2GB and 64MB in fixed size strategy.\n\nSeeing these numbers, I don't tend to take the exponential\nstrategy.\n\n\n[1] https://www.postgresql.org/message-id/CAGTBQpbZX5S4QrnB6YP-2Nk+A9bxbaVktzKwsGvMeov3MTgdiQ@mail.gmail.com\n\n[2] See attached perl script. I hope it is correct.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n#! /usr/bin/perl\n\n$maxmem=1024 * 4;\n#=====\nprint \"exponential sized strategy\\n\";\n$ss = 64;\n$ts = 0;\n$sumiteritem = 0;\nfor ($i = 1 ; $ts < $maxmem ; $i++) {\n\t$ss = $ss * 2;\n\tif ($ts + $ss > $maxmem) {\n\t\t$ss = $maxmem - $ts;\n\t}\n\t$ts += $ss;\n\t$ntups = $ts*1024*1024 / 6;\n\t$ntupinseg = $ss*1024*1024 / 6;\n\t$npages = $ntups / 291;\n\t$tsize = $npages * 8192.0 / 1024 / 1024 / 1024;\n\t$sumiteritem += log($ntupinseg) * $ntupinseg; # weight by percentage in all tuples\n\tprintf(\"#%d : segsize=%dMB total=%dMB, (tuples = %ld, min tsize=%.1fGB), iterseg(%d)=%f, iteritem(%d) = %f, expected iter=%f\\n\",\n\t\t $i, $ss, $ts, $ntups, $tsize,\n\t\t $i, log($i), $ntupinseg, log($ntupinseg), log($i) + $sumiteritem/$ntups);\n}\n\nprint \"\\n\\nfixed sized strategy\\n\";\n$ss = 64;\n$ts = 0;\nfor ($i = 1 ; $ts < $maxmem ; $i++) {\n\t$ts += $ss;\n\t$ntups = $ts*1024*1024 / 6;\n\t$ntupinseg = $ss*1024*1024 / 6;\n\t$npages = $ntups / 300;\n\t$tsize = $npages * 8192.0 / 1024 / 1024 / 1024;\n\tprintf(\"#%d : segsize=%dMB total=%dMB, (tuples = %ld, min tsize=%.1fGB), interseg(%d)=%f, iteritem(%d) = %f, expected iter=%f\\n\",\n\t\t $i, $ss, $ts, $ntups, $tsize,\n\t\t$i, log($i), $ntupinseg, log($ntupinseg), log($i) + log($ntupinseg));\n}","msg_date":"Thu, 08 Feb 2018 14:44:35 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Feb 8, 2018 at 2:44 AM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> Hello, I looked this a bit closer.\n>\n> In upthread[1] Robert mentioned the exponentially increasing size\n> of additional segments.\n>\n>>> Hmm, I had imagined making all of the segments the same size rather\n>>> than having the size grow exponentially. The whole point of this is\n>>> to save memory, and even in the worst case you don't end up with that\n>>> many segments as long as you pick a reasonable base size (e.g. 64MB).\n>>\n>> Wastage is bound by a fraction of the total required RAM, that is,\n>> it's proportional to the amount of required RAM, not the amount\n>> allocated. So it should still be fine, and the exponential strategy\n>> should improve lookup performance considerably.\n>\n> It seems that you are getting him wrong. (Anyway I'm not sure\n> what you meant by the above. not-yet-allocated memory won't be a\n> waste.) The conclusive number of dead tuples in a heap scan is\n> undeteminable until the scan ends. If we had a new dead tuple\n> required a, say 512MB new segment and the scan ends just after,\n> the wastage will be almost the whole of the segment.\n\nAnd the segment size is bound by a fraction of total needed memory.\n\nWhen I said \"allocated\", I meant m_w_m. Wastage is not proportional to m_w_m.\n\n> On the other hand, I don't think the exponential strategy make\n> things considerably better. bsearch iterations in\n> lazy_tid_reaped() are distributed between segment search and tid\n> search. Intuitively more or less the increased segment size just\n> moves some iterations of the former to the latter.\n>\n> I made a calculation[2]. With maintemance_work_mem of 4096MB, the\n> number of segments is 6 and expected number of bsearch iteration\n> is about 20.8 for the exponential strategy. With 64MB fixed size\n> segments, we will have 64 segments (that is not so many) and the\n> expected iteration is 20.4. (I suppose the increase comes from\n> the imbalanced size among segments.) Addition to that, as Robert\n> mentioned, the possible maximum memory wastage of the exponential\n> strategy is about 2GB and 64MB in fixed size strategy.\n\nThat calculation has a slight bug in that it should be log2, and that\nsegment size is limited to 1GB at the top end.\n\nBut in any case, the biggest issue is that it's ignoring the effect of\ncache locality. The way in which the exponential strategy helps, is by\nkeeping the segment list small and comfortably fitting in fast cache\nmemory, while also keeping wastage at a minimum for small lists. 64MB\nsegments with 4G mwm would be about 2kb of segment list. It fits in\nL1, if there's nothing else contending for it, but it's already\nstarting to get big, and it would be expected settings larger than 4G\nmwm could be used.\n\nI guess I could tune the starting/ending sizes a bit.\n\nSay, with an upper limit of 256M (instead of 1G), and after fixing the\nother issues, we get:\n\nexponential sized strategy\n...\n#18 : segsize=64MB total=4096MB, (tuples = 715827882, min\ntsize=18.8GB), iterseg(18)=4.169925, iteritem(11184810) = 23.415037,\nexpected iter=29.491213\n\n\nfixed sized strategy\n...\n#64 : segsize=64MB total=4096MB, (tuples = 715827882, min\ntsize=18.2GB), interseg(64)=6.000000, iteritem(11184810) = 23.415037,\nexpected iter=29.415037\n\nAlmost identical, and we get all the benefits of cache locality with\nthe exponential strategy. The fixed strategy might fit in the L1, but\nit's less likely the bigger the mwm is.\n\nThe scaling factor could also be tuned I guess, but I'm wary of using\nanything other than a doubling strategy, since it might cause memory\nfragmentation.\n\n","msg_date":"Thu, 8 Feb 2018 04:08:20 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Claudio Freire wrote:\n\n> I don't like looping, though, seems overly cumbersome. What's worse?\n> maintaining that fragile weird loop that might break (by causing\n> unexpected output), or a slight slowdown of the test suite?\n>\n> I don't know how long it might take on slow machines, but in my\n> machine, which isn't a great machine, while the vacuum test isn't fast\n> indeed, it's just a tiny fraction of what a simple \"make check\" takes.\n> So it's not a huge slowdown in any case.\n\nWell, what about a machine running tests under valgrind, or the weird\ncache-clobbering infuriatingly slow code? Or buildfarm members running\non really slow hardware? These days, a few people have spent a lot of\ntime trying to reduce the total test time, and it'd be bad to lose back\nthe improvements for no good reason.\n\nI grant you that the looping I proposed is more complicated, but I don't\nsee any reason why it would break.\n\nAnother argument against the LOCK pg_class idea is that it causes an\nunnecessary contention point across the whole parallel test group --\nwith possible weird side effects. How about a deadlock?\n\nOther than the wait loop I proposed, I think we can make a couple of\nvery simple improvements to this test case to avoid a slowdown:\n\n1. the DELETE takes about 1/4th of the time and removes about the same\nnumber of rows as the one using the IN clause:\n delete from vactst where random() < 3.0 / 4;\n\n2. Use a new temp table rather than vactst. Everything is then faster.\n\n3. Figure out the minimum size for the table that triggers the behavior\n you want. Right now you use 400k tuples -- maybe 100k are sufficient?\n Don't know.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Thu, 8 Feb 2018 20:39:19 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Feb 8, 2018 at 8:39 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n> Claudio Freire wrote:\n>\n>> I don't like looping, though, seems overly cumbersome. What's worse?\n>> maintaining that fragile weird loop that might break (by causing\n>> unexpected output), or a slight slowdown of the test suite?\n>>\n>> I don't know how long it might take on slow machines, but in my\n>> machine, which isn't a great machine, while the vacuum test isn't fast\n>> indeed, it's just a tiny fraction of what a simple \"make check\" takes.\n>> So it's not a huge slowdown in any case.\n>\n> Well, what about a machine running tests under valgrind, or the weird\n> cache-clobbering infuriatingly slow code? Or buildfarm members running\n> on really slow hardware? These days, a few people have spent a lot of\n> time trying to reduce the total test time, and it'd be bad to lose back\n> the improvements for no good reason.\n\nIt's not for no good reason. The old tests were woefully inadequate.\n\nDuring the process of developing the patch, I got seriously broken\ncode that passed the tests nonetheless. The test as it was was very\nineffective at actually detecting issues.\n\nThis new test may be slow, but it's effective. That's a very good\nreason to make it slower, if you ask me.\n\n> I grant you that the looping I proposed is more complicated, but I don't\n> see any reason why it would break.\n>\n> Another argument against the LOCK pg_class idea is that it causes an\n> unnecessary contention point across the whole parallel test group --\n> with possible weird side effects. How about a deadlock?\n\nThe real issue with lock pg_class is that locks on pg_class are\nshort-lived, so I'm not waiting for whole transactions.\n\n> Other than the wait loop I proposed, I think we can make a couple of\n> very simple improvements to this test case to avoid a slowdown:\n>\n> 1. the DELETE takes about 1/4th of the time and removes about the same\n> number of rows as the one using the IN clause:\n> delete from vactst where random() < 3.0 / 4;\n\nI did try this at first, but it causes random output, so the test\nbreaks randomly.\n\n> 2. Use a new temp table rather than vactst. Everything is then faster.\n\nI might try that.\n\n> 3. Figure out the minimum size for the table that triggers the behavior\n> you want. Right now you use 400k tuples -- maybe 100k are sufficient?\n> Don't know.\n\nFor that test, I need enough *dead* tuples to cause several passes.\nEven small mwm settings require tons of tuples for this. In fact, I'm\nthinking that number might be too low for its purpose, even. I'll\nre-check, but I doubt it's too high. If anything, it's too low.\n\n","msg_date":"Fri, 9 Feb 2018 09:20:32 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Claudio Freire wrote:\n> On Thu, Feb 8, 2018 at 8:39 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n\n> During the process of developing the patch, I got seriously broken\n> code that passed the tests nonetheless. The test as it was was very\n> ineffective at actually detecting issues.\n> \n> This new test may be slow, but it's effective. That's a very good\n> reason to make it slower, if you ask me.\n\nOK, I don't disagree with improving the test, but if we can make it fast\n*and* effective, that's better than slow and effective.\n\n> > Another argument against the LOCK pg_class idea is that it causes an\n> > unnecessary contention point across the whole parallel test group --\n> > with possible weird side effects. How about a deadlock?\n> \n> The real issue with lock pg_class is that locks on pg_class are\n> short-lived, so I'm not waiting for whole transactions.\n\nDoh.\n\n> > Other than the wait loop I proposed, I think we can make a couple of\n> > very simple improvements to this test case to avoid a slowdown:\n> >\n> > 1. the DELETE takes about 1/4th of the time and removes about the same\n> > number of rows as the one using the IN clause:\n> > delete from vactst where random() < 3.0 / 4;\n> \n> I did try this at first, but it causes random output, so the test\n> breaks randomly.\n\nOK. Still, your query seqscans the table twice. Maybe it's possible to\nuse a CTID scan to avoid that, but I'm not sure how.\n\n> > 3. Figure out the minimum size for the table that triggers the behavior\n> > you want. Right now you use 400k tuples -- maybe 100k are sufficient?\n> > Don't know.\n> \n> For that test, I need enough *dead* tuples to cause several passes.\n> Even small mwm settings require tons of tuples for this. In fact, I'm\n> thinking that number might be too low for its purpose, even. I'll\n> re-check, but I doubt it's too high. If anything, it's too low.\n\nOK.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Fri, 9 Feb 2018 10:32:40 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Feb 9, 2018 at 10:32 AM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n> Claudio Freire wrote:\n>> On Thu, Feb 8, 2018 at 8:39 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n>\n>> During the process of developing the patch, I got seriously broken\n>> code that passed the tests nonetheless. The test as it was was very\n>> ineffective at actually detecting issues.\n>>\n>> This new test may be slow, but it's effective. That's a very good\n>> reason to make it slower, if you ask me.\n>\n> OK, I don't disagree with improving the test, but if we can make it fast\n> *and* effective, that's better than slow and effective.\n\nI'd love to have a test that uses multiple segments of dead tuples,\nbut for that, it needs to use more than 64MB of mwm. That amounts to,\nbasically, ~12M rows.\n\nIs there a \"slow test suite\" where such a test could be added that\nwon't bother regular \"make check\"?\n\nThat, or we turn the initial segment size into a GUC, but I don't\nthink it's a useful GUC outside of the test suite.\n\n>> > 3. Figure out the minimum size for the table that triggers the behavior\n>> > you want. Right now you use 400k tuples -- maybe 100k are sufficient?\n>> > Don't know.\n>>\n>> For that test, I need enough *dead* tuples to cause several passes.\n>> Even small mwm settings require tons of tuples for this. In fact, I'm\n>> thinking that number might be too low for its purpose, even. I'll\n>> re-check, but I doubt it's too high. If anything, it's too low.\n>\n> OK.\n\nTurns out that it was a tad oversized. 300k tuples seems enough.\n\nAttached is a new patch version that:\n\n- Uses an unlogged table to make the large mwm test faster\n- Uses a wait_barrier helper that waits for concurrent transactions\n to finish before vacuuming tables, to make sure deleted tuples\n actually are vacuumable\n- Tweaks the size of the large mwm test to be as small as possible\n- Optimizes the delete to avoid expensive operations yet attain\n the same end result","msg_date":"Fri, 9 Feb 2018 13:05:43 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Aug 18, 2017 at 8:39 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> Indeed they do, and that's what motivated this patch. But I'd need\n>> TB-sized tables to set up something like that. I don't have the\n>> hardware or time available to do that (vacuum on bloated TB-sized\n>> tables can take days in my experience). Scale 4000 is as big as I can\n>> get without running out of space for the tests in my test hardware.\n>>\n>> If anybody else has the ability, I'd be thankful if they did test it\n>> under those conditions, but I cannot. I think Anastasia's test is\n>> closer to such a test, that's probably why it shows a bigger\n>> improvement in total elapsed time.\n>>\n>> Our production database could possibly be used, but it can take about\n>> a week to clone it, upgrade it (it's 9.5 currently), and run the\n>> relevant vacuum.\n>\n> It looks like I won't be able to do that test with a production\n> snapshot anytime soon.\n>\n> Getting approval for the budget required to do that looks like it's\n> going to take far longer than I thought.\n\nI finally had a chance to test the patch in a production snapshot.\n\nActually, I tried to take out 2 birds with one stone, and I'm also\ntesting the FSM vacuum patch. It shouldn't significantly alter the\nnumbers anyway.\n\nSo, while the whole-db throttled vacuum (as is run in production) is\nstill ongoing, an interesting case already popped up.\n\nTL;DR, without the patch, this particular table took 16 1/2 hours more\nor less, to vacuum 313M dead tuples. With the patch, it took 6:10h to\nvacuum 323M dead tuples. That's quite a speedup. It even used\nsignificantly less CPU time as well.\n\nSince vacuum here is throttled (with cost-based delays), this also\nmeans it generated less I/O.\n\nWe have more extreme cases sometimes, so if I see something\ninteresting in what remains of the test, I'll post those results as\nwell.\n\nThe raw data:\n\nPatched\n\nINFO: vacuuming \"public.aggregated_tracks_hourly_full\"\nINFO: scanned index \"aggregated_tracks_hourly_full_pkey_null\" to\nremove 323778164 row versions\nDETAIL: CPU: user: 111.57 s, system: 31.28 s, elapsed: 2693.67 s\nINFO: scanned index \"ix_aggregated_tracks_hourly_full_action_null\" to\nremove 323778164 row versions\nDETAIL: CPU: user: 281.89 s, system: 36.32 s, elapsed: 2915.94 s\nINFO: scanned index \"ix_aggregated_tracks_hourly_full_nunq\" to remove\n323778164 row versions\nDETAIL: CPU: user: 313.35 s, system: 79.22 s, elapsed: 6400.87 s\nINFO: \"aggregated_tracks_hourly_full\": removed 323778164 row versions\nin 7070739 pages\nDETAIL: CPU: user: 583.48 s, system: 69.77 s, elapsed: 8048.00 s\nINFO: index \"aggregated_tracks_hourly_full_pkey_null\" now contains\n720807609 row versions in 10529903 pages\nDETAIL: 43184641 index row versions were removed.\n5288916 index pages have been deleted, 4696227 are currently reusable.\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.03 s.\nINFO: index \"ix_aggregated_tracks_hourly_full_action_null\" now\ncontains 720807609 row versions in 7635161 pages\nDETAIL: 202678522 index row versions were removed.\n4432789 index pages have been deleted, 3727966 are currently reusable.\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.01 s.\nINFO: index \"ix_aggregated_tracks_hourly_full_nunq\" now contains\n720807609 row versions in 15526885 pages\nDETAIL: 202678522 index row versions were removed.\n9052488 index pages have been deleted, 7390279 are currently reusable.\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.02 s.\nINFO: \"aggregated_tracks_hourly_full\": found 41131260 removable,\n209520861 nonremovable row versions in 7549244 out of 22391603 pages\nDETAIL: 0 dead row versions cannot be removed yet, oldest xmin: 245834316\nThere were 260553451 unused item pointers.\nSkipped 0 pages due to buffer pins, 0 frozen pages.\n0 pages are entirely empty.\nCPU: user: 1329.64 s, system: 244.22 s, elapsed: 22222.14 s.\n\n\nVanilla 9.5 (ie: what's in production right now, should be similar to master):\n\nINFO: vacuuming \"public.aggregated_tracks_hourly_full\"\nINFO: scanned index \"aggregated_tracks_hourly_full_pkey_null\" to\nremove 178956729 row versions\nDETAIL: CPU 65.51s/253.67u sec elapsed 3490.13 sec.\nINFO: scanned index \"ix_aggregated_tracks_hourly_full_action_null\" to\nremove 178956729 row versions\nDETAIL: CPU 63.26s/238.08u sec elapsed 3483.32 sec.\nINFO: scanned index \"ix_aggregated_tracks_hourly_full_nunq\" to remove\n178956729 row versions\nDETAIL: CPU 340.15s/445.52u sec elapsed 15898.48 sec.\nINFO: \"aggregated_tracks_hourly_full\": removed 178956729 row versions\nin 3121122 pages\nDETAIL: CPU 168.24s/159.20u sec elapsed 5678.51 sec.\nINFO: scanned index \"aggregated_tracks_hourly_full_pkey_null\" to\nremove 134424729 row versions\nDETAIL: CPU 50.66s/265.19u sec elapsed 3977.15 sec.\nINFO: scanned index \"ix_aggregated_tracks_hourly_full_action_null\" to\nremove 134424729 row versions\nDETAIL: CPU 99.68s/326.44u sec elapsed 6580.22 sec.\nINFO: scanned index \"ix_aggregated_tracks_hourly_full_nunq\" to remove\n134424729 row versions\nDETAIL: CPU 146.96s/358.86u sec elapsed 10464.69 sec.\nINFO: \"aggregated_tracks_hourly_full\": removed 134424729 row versions\nin 2072649 pages\nDETAIL: CPU 109.07s/37.12u sec elapsed 3601.39 sec.\nINFO: index \"aggregated_tracks_hourly_full_pkey_null\" now contains\n870543969 row versions in 10529903 pages\nDETAIL: 134424771 index row versions were removed.\n4358027 index pages have been deleted, 3662385 are currently reusable.\nCPU 0.02s/0.00u sec elapsed 2.42 sec.\nINFO: index \"ix_aggregated_tracks_hourly_full_action_null\" now\ncontains 870543969 row versions in 7635161 pages\nDETAIL: 134424771 index row versions were removed.\n3908583 index pages have been deleted, 3445049 are currently reusable.\nCPU 0.02s/0.00u sec elapsed 0.08 sec.\nINFO: index \"ix_aggregated_tracks_hourly_full_nunq\" now contains\n870543969 row versions in 15526885 pages\nDETAIL: 218955943 index row versions were removed.\n7710441 index pages have been deleted, 5928522 are currently reusable.\nCPU 0.02s/0.01u sec elapsed 0.19 sec.\nINFO: \"aggregated_tracks_hourly_full\": found 134159696 removable,\n90271560 nonremovable row versions in 6113375 out of 22391603 pages\nDETAIL: 287 dead row versions cannot be removed yet.\nThere were 126680434 unused item pointers.\nSkipped 0 pages due to buffer pins.\n0 pages are entirely empty.\nCPU 1191.42s/2223.19u sec elapsed 59885.50 sec.\n\n","msg_date":"Mon, 19 Feb 2018 18:50:40 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Feb 9, 2018 at 1:05 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> Turns out that it was a tad oversized. 300k tuples seems enough.\n>\n> Attached is a new patch version that:\n>\n> - Uses an unlogged table to make the large mwm test faster\n> - Uses a wait_barrier helper that waits for concurrent transactions\n> to finish before vacuuming tables, to make sure deleted tuples\n> actually are vacuumable\n> - Tweaks the size of the large mwm test to be as small as possible\n> - Optimizes the delete to avoid expensive operations yet attain\n> the same end result\n\nAttached rebased versions of the patches (they weren't applying to\ncurrent master)","msg_date":"Fri, 16 Mar 2018 18:46:06 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Hello everyone,\r\n\r\nI would like to let you know that unfortunately these patches don't apply anymore. Also personally I'm a bit confused by the last message that has 0001- and 0003- patches attached but not the 0002- one.","msg_date":"Tue, 27 Mar 2018 13:20:42 +0000","msg_from":"Aleksander Alekseev <a.alekseev@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"I didn't receive your comment, I just saw it. Nevertheless, I rebased the patches a while ago just because I noticed they didn't apply anymore in cputube, and they still seem to apply.\r\n\r\nPatch number 2 was committed a long while ago, that's why it's missing. It was a simple patch, it landed rewritten as commit 7e26e02eec90370dd222f35f00042f8188488ac4","msg_date":"Tue, 03 Apr 2018 14:06:30 +0000","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Apr 3, 2018 at 11:06 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> I didn't receive your comment, I just saw it. Nevertheless, I rebased the patches a while ago just because I noticed they didn't apply anymore in cputube, and they still seem to apply.\n\nSorry, that is false.\n\nThey appear green in cputube, so I was confident they did apply, but I\njust double-checked on a recent pull and they don't. I'll rebase them\nshortly.\n\n","msg_date":"Tue, 3 Apr 2018 11:09:42 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Tue, Apr 3, 2018 at 11:09 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Tue, Apr 3, 2018 at 11:06 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> I didn't receive your comment, I just saw it. Nevertheless, I rebased the patches a while ago just because I noticed they didn't apply anymore in cputube, and they still seem to apply.\n>\n> Sorry, that is false.\n>\n> They appear green in cputube, so I was confident they did apply, but I\n> just double-checked on a recent pull and they don't. I'll rebase them\n> shortly.\n\n\nOk, rebased patches attached","msg_date":"Tue, 3 Apr 2018 11:20:11 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 03/04/18 17:20, Claudio Freire wrote:\n> Ok, rebased patches attached\n\nThanks! I took a look at this.\n\nFirst, now that the data structure is more complicated, I think it's \ntime to abstract it, and move it out of vacuumlazy.c. The Tid Map needs \nto support the following operations:\n\n* Add TIDs, in order (in 1st phase of vacuum)\n* Random lookup, by TID (when scanning indexes)\n* Iterate through all TIDs, in order (2nd pass over heap)\n\nLet's add a new source file to hold the code for the tid map data \nstructure, with functions corresponding those operations.\n\nI took a stab at doing that, and I think it makes vacuumlazy.c nicer.\n\nSecondly, I'm not a big fan of the chosen data structure. I think the \nonly reason that the segmented \"multi-array\" was chosen is that each \n\"segment\" works is similar to the simple array that we used to have. \nAfter putting it behind the abstraction, it seems rather ad hoc. There \nare many standard textbook data structures that we could use instead, \nand would be easier to understand and reason about, I think.\n\nSo, I came up with the attached patch. I used a B-tree as the data \nstructure. Not sure it's the best one, I'm all ears for suggestions and \nbikeshedding on alternatives, but I'm pretty happy with that. I would \nexpect it to be pretty close to the simple array with binary search in \nperformance characteristics. It'd be pretty straightforward to optimize \nfurther, and e.g. use a bitmap of OffsetNumbers or some other more dense \ndata structure in the B-tree leaf pages, but I resisted doing that as \npart of this patch.\n\nI haven't done any performance testing of this (and not much testing in \ngeneral), but at least the abstraction seems better this way. \nPerformance testing would be good, too. In particular, I'd like to know \nhow this might affect the performance of lazy_tid_reaped(). That's a hot \nspot when vacuuming indexes, so we don't want to add any cycles there. \nWas there any ready-made test kits on that in this thread? I didn't see \nany at a quick glance, but it's a long thread..\n\n- Heikki","msg_date":"Thu, 5 Apr 2018 23:02:09 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Apr 5, 2018 at 5:02 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> On 03/04/18 17:20, Claudio Freire wrote:\n>>\n>> Ok, rebased patches attached\n>\n>\n> Thanks! I took a look at this.\n>\n> First, now that the data structure is more complicated, I think it's time to\n> abstract it, and move it out of vacuumlazy.c. The Tid Map needs to support\n> the following operations:\n>\n> * Add TIDs, in order (in 1st phase of vacuum)\n> * Random lookup, by TID (when scanning indexes)\n> * Iterate through all TIDs, in order (2nd pass over heap)\n>\n> Let's add a new source file to hold the code for the tid map data structure,\n> with functions corresponding those operations.\n>\n> I took a stab at doing that, and I think it makes vacuumlazy.c nicer.\n\nAbout the refactoring to split this into their own set of files and\nabstract away the underlying structure, I can totally get behind that.\n\nThe iteration interface, however, seems quite specific for the use\ncase of vacuumlazy, so it's not really a good abstraction. It also\ncopies stuff a lot, so it's quite heavyweight. I'd suggest trying to\ngo for a lighter weight interface with less overhead that is more\ngeneral at the same time.\n\nIf it was C++, I'd say build an iterator class.\n\nC would do it probably with macros, so you can have a macro to get to\nthe current element, another to advance to the next element, and\nanother to check whether you've reached the end.\n\nI can do that if we agree on the points below:\n\n> Secondly, I'm not a big fan of the chosen data structure. I think the only\n> reason that the segmented \"multi-array\" was chosen is that each \"segment\"\n> works is similar to the simple array that we used to have. After putting it\n> behind the abstraction, it seems rather ad hoc. There are many standard\n> textbook data structures that we could use instead, and would be easier to\n> understand and reason about, I think.\n>\n> So, I came up with the attached patch. I used a B-tree as the data\n> structure. Not sure it's the best one, I'm all ears for suggestions and\n> bikeshedding on alternatives, but I'm pretty happy with that. I would expect\n> it to be pretty close to the simple array with binary search in performance\n> characteristics. It'd be pretty straightforward to optimize further, and\n> e.g. use a bitmap of OffsetNumbers or some other more dense data structure\n> in the B-tree leaf pages, but I resisted doing that as part of this patch.\n\nAbout the B-tree, however, I don't think a B-tree is a good idea.\n\nTrees' main benefit is that they can be inserted to efficiently. When\nall your data is loaded sequentially, in-order, in-memory and\nimmutable; the tree is pointless, more costly to build, and harder to\nmaintain - in terms of code complexity.\n\nIn this use case, the only benefit of B-trees would be that they're\noptimized for disk access. If we planned to store this on-disk,\nperhaps I'd grant you that. But we don't plan to do that, and it's not\neven clear doing it would be efficient enough for the intended use.\n\nOn the other side, using B-trees incurs memory overhead due to the\nneed for internal nodes, can fragment memory because internal nodes\naren't the same size as leaf nodes, is easier to get wrong and\nintroduce bugs... I don't see a gain. If you propose its use, at least\nbenchmark it to show some gain.\n\nSo I don't think B-tree is a good idea, the sorted array already is\ngood enough, and if not, it's at least close to the earlier\nimplementation and less likely to introduce bugs.\n\nFurthermore, among the 200-ish messages this thread has accumulated,\nbetter ideas have been proposed, better because they do use less\nmemory and are faster (like using bitmaps when possible), but if we\ncan't push a simple refactoring first, there's no chance a bigger\nrewrite will fare better. Remember, in this use case, using less\nmemory far outweights any other consideration. Less memory directly\ntranslates to less iterations over the indexes, because more can be\ncrammed into m_w_m, which is a huge time saving. Far more than any\nmicro-optimization.\n\nAbout 2 years ago, I chose to try to push this simple algorithm first,\nthen try to improve on it with better data structures. Nobody\ncomplained at the time (I think, IIRC), and I don't think it fair to\ngo and revisit that now. It just delays getting a solution for this\nissue for the persuit of \"the perfect implementaiton\" that might never\narrive. Or even if it doesn, there's nothing stopping us from pushing\nanother patch in the future with that better implementation if we\nwish. Lets get something simple and proven first.\n\n> I haven't done any performance testing of this (and not much testing in\n> general), but at least the abstraction seems better this way. Performance\n> testing would be good, too. In particular, I'd like to know how this might\n> affect the performance of lazy_tid_reaped(). That's a hot spot when\n> vacuuming indexes, so we don't want to add any cycles there. Was there any\n> ready-made test kits on that in this thread? I didn't see any at a quick\n> glance, but it's a long thread..\n\nIf you dig old messages in the thread, I had attached the scripts I\nused for benchmarking this.\n\nI'm attaching again one version of them (I've been modifying it to\nsuit my purposes at each review round), you'll probably want to tweak\nit to build test cases good for your purpose here.","msg_date":"Thu, 5 Apr 2018 19:59:59 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 06/04/18 01:59, Claudio Freire wrote:\n> The iteration interface, however, seems quite specific for the use\n> case of vacuumlazy, so it's not really a good abstraction.\n\nCan you elaborate? It does return the items one block at a time. Is that \nwhat you mean by being specific for vacuumlazy? I guess that's a bit \nspecial, but if you imagine some other users for this abstraction, it's \nprobably not that unusual. For example, if we started using it in bitmap \nheap scans, a bitmap heap scan would also want to get the TIDs one block \nnumber at a time.\n\n> It also copies stuff a lot, so it's quite heavyweight. I'd suggest\n> trying to go for a lighter weight interface with less overhead that\n> is more general at the same time.\n\nNote that there was similar copying, to construct an array of \nOffsetNumbers, happening in lazy_vacuum_page() before this patch. So the \nnet amount of copying is the same.\n\nI'm envisioning that this data structure will sooner or later be \noptimized further, so that when you have a lot of TIDs pointing to the \nsame block, we would pack them more tightly, storing the block number \njust once, with an array of offset numbers. This interface that returns \nan array of offset numbers matches that future well, as the iterator \ncould just return a pointer to the array of offset numbers, with no \ncopying. (If we end up doing something even more dense, like a bitmap, \nthen it doesn't help, but that's ok too.)\n\n> About the B-tree, however, I don't think a B-tree is a good idea.\n> \n> Trees' main benefit is that they can be inserted to efficiently. When\n> all your data is loaded sequentially, in-order, in-memory and\n> immutable; the tree is pointless, more costly to build, and harder to\n> maintain - in terms of code complexity.\n> \n> In this use case, the only benefit of B-trees would be that they're\n> optimized for disk access.\n\nThose are not the reasons for which I'd prefer a B-tree. A B-tree has \ngood cache locality, and when you don't need to worry about random \ninsertions, page splits, deletions etc., it's also very simple to \nimplement. This patch is not much longer than the segmented multi-array.\n\n> On the other side, using B-trees incurs memory overhead due to the\n> need for internal nodes, can fragment memory because internal nodes\n> aren't the same size as leaf nodes, is easier to get wrong and\n> introduce bugs... I don't see a gain.\n\nThe memory overhead incurred by the internal nodes is quite minimal, and \ncan be adjusted by changing the node sizes. After some experimentation, \nI settled on 2048 items per leaf node, and 64 items per internal node. \nWith those values, the overhead caused by the internal nodes is minimal, \nbelow 0.5%. That seems fine, but we could increase the node sizes to \nbring it further down, if we'd prefer that tradeoff.\n\nI don't understand what memory fragmentation problems you're worried \nabout. The tree grows one node at a time, as new TIDs are added, until \nit's all released at the end. I don't see how the size of internal vs \nleaf nodes matters.\n\n> If you propose its use, at least benchmark it to show some gain.\n\nSure. I used the attached script to test this. It's inspired by the test \nscript you posted. It creates a pgbench database with scale factor 100, \ndeletes 80% of the rows, and runs vacuum. To stress lazy_tid_reaped() \nmore heavily, the test script creates a number of extra indexes. Half of \nthem are on the primary key, just to get more repetitions without having \nto re-initialize in between, and the rest are like this:\n\ncreate index random_1 on pgbench_accounts((hashint4(aid)))\n\nto stress lazy_vacuum_tid_reaped() with a random access pattern, rather \nthan the sequential one that you get with the primary key index.\n\nI ran the test script on my laptop, with unpatched master, with your \nlatest multi-array patch, and with the attached version of the b-tree \npatch. The results are quite noisy, unfortunately, so I wouldn't draw \nvery strong conclusions from it, but it seems that the performance of \nall three versions is roughly the same. I looked in particular at the \nCPU time spent in the index vacuums, as reported by VACUUM VERBOSE.\n\n> Furthermore, among the 200-ish messages this thread has accumulated,\n> better ideas have been proposed, better because they do use less\n> memory and are faster (like using bitmaps when possible), but if we\n> can't push a simple refactoring first, there's no chance a bigger\n> rewrite will fare better. Remember, in this use case, using less\n> memory far outweights any other consideration. Less memory directly\n> translates to less iterations over the indexes, because more can be\n> crammed into m_w_m, which is a huge time saving. Far more than any\n> micro-optimization.\n> \n> About 2 years ago, I chose to try to push this simple algorithm first,\n> then try to improve on it with better data structures. Nobody\n> complained at the time (I think, IIRC), and I don't think it fair to\n> go and revisit that now. It just delays getting a solution for this\n> issue for the persuit of \"the perfect implementaiton\" that might never\n> arrive. Or even if it doesn, there's nothing stopping us from pushing\n> another patch in the future with that better implementation if we\n> wish. Lets get something simple and proven first.\n\nTrue all that. My point is that the multi-segmented array isn't all that \nsimple and proven, compared to an also straightforward B-tree. It's \npretty similar to a B-tree, actually, except that it has exactly two \nlevels, and the node (= segment) sizes grow exponentially. I'd rather go \nwith a true B-tree, than something homegrown that resembles a B-tree, \nbut not quite.\n\n> I'm attaching again one version of them (I've been modifying it to\n> suit my purposes at each review round), you'll probably want to tweak\n> it to build test cases good for your purpose here.\n\nThanks!\n\nAttached is a new version of my b-tree version. Compared to yesterday's \nversion, I fixed a bunch of bugs that turned up in testing.\n\nLooking at the changes to the regression test in this, I don't quite \nunderstand what it's all about. What are the \"wait_barriers\" for? If I \nunderstand correctly, they're added so that the VACUUMs can remove the \ntuples that are deleted in the test. But why are they needed now? Was \nthat an orthogonal change we should've done anyway?\n\nRather than add those wait_barriers, should we stop running the 'vacuum' \ntest in parallel with the other tests? Or maybe it's a good thing to run \nit in parallel, to test some other things?\n\nWhat are the new tests supposed to cover? The test comment says \"large \nmwm vacuum runs\", and it sets maintenance_work_mem to 1 MB, which isn't \nvery large\n\n- Heikki","msg_date":"Fri, 6 Apr 2018 16:39:21 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 06/04/18 16:39, Heikki Linnakangas wrote:\n> Sure. I used the attached script to test this. \n\nSorry, I attached the wrong script. Here is the correct one that I used. \nHere are also the results I got from running it\n\n- Heikki","msg_date":"Fri, 6 Apr 2018 16:42:17 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Heikki Linnakangas wrote:\n> On 06/04/18 01:59, Claudio Freire wrote:\n> > The iteration interface, however, seems quite specific for the use\n> > case of vacuumlazy, so it's not really a good abstraction.\n> \n> Can you elaborate? It does return the items one block at a time. Is that\n> what you mean by being specific for vacuumlazy? I guess that's a bit\n> special, but if you imagine some other users for this abstraction, it's\n> probably not that unusual. For example, if we started using it in bitmap\n> heap scans, a bitmap heap scan would also want to get the TIDs one block\n> number at a time.\n\nFWIW I liked the idea of having this abstraction possibly do other\nthings -- for instance to vacuum brin indexes you'd like to mark index\ntuples as \"containing tuples that were removed\" and eventually\nre-summarize the range. With the current interface we cannot do that,\nbecause vacuum expects brin vacuuming to ask for each heap tuple \"is\nthis tid dead?\" and of course we don't have a list of tids to ask for.\nSo if we can ask instead \"how many dead tuples does this block contain?\"\nbrin vacuuming will be much happier.\n\n> Looking at the changes to the regression test in this, I don't quite\n> understand what it's all about. What are the \"wait_barriers\" for? If I\n> understand correctly, they're added so that the VACUUMs can remove the\n> tuples that are deleted in the test. But why are they needed now? Was that\n> an orthogonal change we should've done anyway?\n> \n> Rather than add those wait_barriers, should we stop running the 'vacuum'\n> test in parallel with the other tests? Or maybe it's a good thing to run it\n> in parallel, to test some other things?\n\n20180207235226.zygu4r3yv3yfcnmc@alvherre.pgsql\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Fri, 6 Apr 2018 11:00:16 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> On 06/04/18 01:59, Claudio Freire wrote:\n>>\n>> The iteration interface, however, seems quite specific for the use\n>> case of vacuumlazy, so it's not really a good abstraction.\n>\n>\n> Can you elaborate? It does return the items one block at a time. Is that\n> what you mean by being specific for vacuumlazy? I guess that's a bit\n> special, but if you imagine some other users for this abstraction, it's\n> probably not that unusual. For example, if we started using it in bitmap\n> heap scans, a bitmap heap scan would also want to get the TIDs one block\n> number at a time.\n\nBut you're also tying the caller to the format of the buffer holding\nthose TIDs, for instance. Why would you, when you can have an\ninterface that just iterates TIDs and let the caller store them\nif/however they want?\n\nI do believe a pure iterator interface is a better interface.\n\n>> It also copies stuff a lot, so it's quite heavyweight. I'd suggest\n>> trying to go for a lighter weight interface with less overhead that\n>> is more general at the same time.\n>\n>\n> Note that there was similar copying, to construct an array of OffsetNumbers,\n> happening in lazy_vacuum_page() before this patch. So the net amount of\n> copying is the same.\n>\n> I'm envisioning that this data structure will sooner or later be optimized\n> further, so that when you have a lot of TIDs pointing to the same block, we\n> would pack them more tightly, storing the block number just once, with an\n> array of offset numbers. This interface that returns an array of offset\n> numbers matches that future well, as the iterator could just return a\n> pointer to the array of offset numbers, with no copying. (If we end up doing\n> something even more dense, like a bitmap, then it doesn't help, but that's\n> ok too.)\n\nBut that's the thing. It's a specialized interface for a future we're\nnot certain. It's premature.\n\nA generic interface does not preclude the possibility of implementing\nthose in the future, it allows you *not* to if there's no gain. Doing\nit now, it forces you to.\n\n>> About the B-tree, however, I don't think a B-tree is a good idea.\n>>\n>> Trees' main benefit is that they can be inserted to efficiently. When\n>> all your data is loaded sequentially, in-order, in-memory and\n>> immutable; the tree is pointless, more costly to build, and harder to\n>> maintain - in terms of code complexity.\n>>\n>> In this use case, the only benefit of B-trees would be that they're\n>> optimized for disk access.\n>\n>\n> Those are not the reasons for which I'd prefer a B-tree. A B-tree has good\n> cache locality, and when you don't need to worry about random insertions,\n> page splits, deletions etc., it's also very simple to implement. This patch\n> is not much longer than the segmented multi-array.\n\nBut it *is* complex and less tested. Testing it and making it mature\nwill take time. Why do that if doing bitmaps is a better path?\n\n>> On the other side, using B-trees incurs memory overhead due to the\n>> need for internal nodes, can fragment memory because internal nodes\n>> aren't the same size as leaf nodes, is easier to get wrong and\n>> introduce bugs... I don't see a gain.\n>\n>\n> The memory overhead incurred by the internal nodes is quite minimal, and can\n> be adjusted by changing the node sizes. After some experimentation, I\n> settled on 2048 items per leaf node, and 64 items per internal node. With\n> those values, the overhead caused by the internal nodes is minimal, below\n> 0.5%. That seems fine, but we could increase the node sizes to bring it\n> further down, if we'd prefer that tradeoff.\n>\n> I don't understand what memory fragmentation problems you're worried about.\n> The tree grows one node at a time, as new TIDs are added, until it's all\n> released at the end. I don't see how the size of internal vs leaf nodes\n> matters.\n\nLarge vacuums do several passes, so they'll create one tid map for\neach pass. Each pass will allocate m_w_m-worth of pages, and then\ndeallocate them.\n\nB-tree page allocations are smaller than malloc's mmap threshold, so\nfreeing them won't return memory to the operating system. Furthermore,\nif other allocations get interleaved, objects could be left lying at\nrandom points in the heap, preventing efficient reuse of the heap for\nthe next round. In essence, internal fragmentation. This may be\nexacerbated by AllocSet's own fragmentation and double-accounting.\n From what I can tell, inner nodes will use pools, and leaf nodes will\nbe allocated as dedicated chunks (mallocd).\n\nSegments in my implementation are big, exactly because of that. The\naim is to have large buffers that malloc will mmap, so they get\nreturned to the os (unmapped) when freed quickly, and with little\noverhead.\n\nThis fragmentation may cause actual pain in autovacuum, since\nautovacuum workers are relatively long-lived.\n\n>> If you propose its use, at least benchmark it to show some gain.\n>\n>\n> Sure. I used the attached script to test this. It's inspired by the test\n> script you posted. It creates a pgbench database with scale factor 100,\n> deletes 80% of the rows, and runs vacuum. To stress lazy_tid_reaped() more\n> heavily, the test script creates a number of extra indexes. Half of them are\n> on the primary key, just to get more repetitions without having to\n> re-initialize in between, and the rest are like this:\n>\n> create index random_1 on pgbench_accounts((hashint4(aid)))\n>\n> to stress lazy_vacuum_tid_reaped() with a random access pattern, rather than\n> the sequential one that you get with the primary key index.\n>\n> I ran the test script on my laptop, with unpatched master, with your latest\n> multi-array patch, and with the attached version of the b-tree patch. The\n> results are quite noisy, unfortunately, so I wouldn't draw very strong\n> conclusions from it, but it seems that the performance of all three versions\n> is roughly the same. I looked in particular at the CPU time spent in the\n> index vacuums, as reported by VACUUM VERBOSE.\n\nScale factor 100 is hardly enough to stress large m_w_m vacuum. I\nfound scales of 1k-4k (or bigger) are best, with large m_w_m settings\n(4G for example) to get to really see how the data structure performs.\n\n>> Furthermore, among the 200-ish messages this thread has accumulated,\n>> better ideas have been proposed, better because they do use less\n>> memory and are faster (like using bitmaps when possible), but if we\n>> can't push a simple refactoring first, there's no chance a bigger\n>> rewrite will fare better. Remember, in this use case, using less\n>> memory far outweights any other consideration. Less memory directly\n>> translates to less iterations over the indexes, because more can be\n>> crammed into m_w_m, which is a huge time saving. Far more than any\n>> micro-optimization.\n>>\n>> About 2 years ago, I chose to try to push this simple algorithm first,\n>> then try to improve on it with better data structures. Nobody\n>> complained at the time (I think, IIRC), and I don't think it fair to\n>> go and revisit that now. It just delays getting a solution for this\n>> issue for the persuit of \"the perfect implementaiton\" that might never\n>> arrive. Or even if it doesn, there's nothing stopping us from pushing\n>> another patch in the future with that better implementation if we\n>> wish. Lets get something simple and proven first.\n>\n>\n> True all that. My point is that the multi-segmented array isn't all that\n> simple and proven, compared to an also straightforward B-tree. It's pretty\n> similar to a B-tree, actually, except that it has exactly two levels, and\n> the node (= segment) sizes grow exponentially. I'd rather go with a true\n> B-tree, than something homegrown that resembles a B-tree, but not quite.\n\nI disagree.\n\nBeing similar to what vacuum is already doing, we can be confident the\napproach is sound, at least as sound as current vacuum. It shares a\nlot with the current implementation, which is known to be good.\n\nThe multi-segmented array itself has received a lot of testing during\nthe ~1.5y it has spent in the making, as well. I've been running\nextensive benchmarking and tests each time I changed something, and\nI've even ran deep tests on an actual production snapshot. A complete\ndb-wide vacuum of a heavily bloated ~12TB production database, showing\nsignificant speedups not only because it does fewer index scans, but\nalso because it uses less CPU time to do so, with consistency checking\nafter the fact, to check for bugs. Of course I can't guarantee it's\nbug-free, but it *is* decently tested.\n\nI'm pretty sure the B-tree implementation hasn't reached that level of\ntesting yet. It might in the future, but it won't happen overnight.\n\nYour B-tree patch is also homegrown. You're not reusing well tested\nbtree code, you're coding a B-tree from scratch, so it's as suspect as\nany new code. I agree the multi-segment algorithm is quite similar to\na shallow b-tree, but I'm not convinced a b-tree is what we must\naspire to have. In fact, if you used large pages for the B-tree, you\ndon't need more than 2 levels (there's a 12GB limit ATM on the size of\nthe tid map), so the multi-segment approach and the b-tree approach\nare essentially the same. Except the multi-segment code got more\ntesting.\n\nIn short, there are other more enticing alternatives to try out first.\nI'm not enthused by the idea of having to bench and test yet another\nsorted set implementation before moving forward.\n\nOn Fri, Apr 6, 2018 at 11:00 AM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n> Heikki Linnakangas wrote:\n>> On 06/04/18 01:59, Claudio Freire wrote:\n>> > The iteration interface, however, seems quite specific for the use\n>> > case of vacuumlazy, so it's not really a good abstraction.\n>>\n>> Can you elaborate? It does return the items one block at a time. Is that\n>> what you mean by being specific for vacuumlazy? I guess that's a bit\n>> special, but if you imagine some other users for this abstraction, it's\n>> probably not that unusual. For example, if we started using it in bitmap\n>> heap scans, a bitmap heap scan would also want to get the TIDs one block\n>> number at a time.\n>\n> FWIW I liked the idea of having this abstraction possibly do other\n> things -- for instance to vacuum brin indexes you'd like to mark index\n> tuples as \"containing tuples that were removed\" and eventually\n> re-summarize the range. With the current interface we cannot do that,\n> because vacuum expects brin vacuuming to ask for each heap tuple \"is\n> this tid dead?\" and of course we don't have a list of tids to ask for.\n> So if we can ask instead \"how many dead tuples does this block contain?\"\n> brin vacuuming will be much happier.\n\nI don't think either patch gives you that.\n\nThe bulkdelete interface is part of the indexam and unlikely to change\nin this patch.\n\n","msg_date":"Fri, 6 Apr 2018 17:25:00 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"Claudio Freire wrote:\n\n> On Fri, Apr 6, 2018 at 11:00 AM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\n\n> > FWIW I liked the idea of having this abstraction possibly do other\n> > things -- for instance to vacuum brin indexes you'd like to mark index\n> > tuples as \"containing tuples that were removed\" and eventually\n> > re-summarize the range. With the current interface we cannot do that,\n> > because vacuum expects brin vacuuming to ask for each heap tuple \"is\n> > this tid dead?\" and of course we don't have a list of tids to ask for.\n> > So if we can ask instead \"how many dead tuples does this block contain?\"\n> > brin vacuuming will be much happier.\n> \n> I don't think either patch gives you that.\n> \n> The bulkdelete interface is part of the indexam and unlikely to change\n> in this patch.\n\nI'm sure you're correct. I was just saying that with the abstract\ninterface it is easier to implement what I suggest as a follow-on patch.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Fri, 6 Apr 2018 17:33:14 -0300","msg_from":"Alvaro Herrera <alvherre@alvh.no-ip.org>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> On 06/04/18 01:59, Claudio Freire wrote:\n>>>\n>>> The iteration interface, however, seems quite specific for the use\n>>> case of vacuumlazy, so it's not really a good abstraction.\n>>\n>>\n>> Can you elaborate? It does return the items one block at a time. Is that\n>> what you mean by being specific for vacuumlazy? I guess that's a bit\n>> special, but if you imagine some other users for this abstraction, it's\n>> probably not that unusual. For example, if we started using it in bitmap\n>> heap scans, a bitmap heap scan would also want to get the TIDs one block\n>> number at a time.\n>\n> But you're also tying the caller to the format of the buffer holding\n> those TIDs, for instance. Why would you, when you can have an\n> interface that just iterates TIDs and let the caller store them\n> if/however they want?\n>\n> I do believe a pure iterator interface is a better interface.\n\nBetween the b-tree or not discussion and the refactoring to separate\nthe code, I don't think we'll get this in the next 24hs.\n\nSo I guess we'll have ample time to poner on both issues during the\nnext commit fest.\n\n","msg_date":"Fri, 6 Apr 2018 21:00:20 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 04/06/2018 08:00 PM, Claudio Freire wrote:\n> On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>> On 06/04/18 01:59, Claudio Freire wrote:\n>>>> The iteration interface, however, seems quite specific for the use\n>>>> case of vacuumlazy, so it's not really a good abstraction.\n>>>\n>>> Can you elaborate? It does return the items one block at a time. Is that\n>>> what you mean by being specific for vacuumlazy? I guess that's a bit\n>>> special, but if you imagine some other users for this abstraction, it's\n>>> probably not that unusual. For example, if we started using it in bitmap\n>>> heap scans, a bitmap heap scan would also want to get the TIDs one block\n>>> number at a time.\n>> But you're also tying the caller to the format of the buffer holding\n>> those TIDs, for instance. Why would you, when you can have an\n>> interface that just iterates TIDs and let the caller store them\n>> if/however they want?\n>>\n>> I do believe a pure iterator interface is a better interface.\n> Between the b-tree or not discussion and the refactoring to separate\n> the code, I don't think we'll get this in the next 24hs.\n>\n> So I guess we'll have ample time to poner on both issues during the\n> next commit fest.\n>\n\n\n\nThere doesn't seem to have been much pondering done since then, at least \npublicly. Can we make some progress on this? It's been around for a long \ntime now.\n\ncheers\n\nandrew\n\n-- \nAndrew Dunstan https://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n","msg_date":"Thu, 12 Jul 2018 09:44:05 -0400","msg_from":"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Thu, Jul 12, 2018 at 10:44 AM Andrew Dunstan\n<andrew.dunstan@2ndquadrant.com> wrote:\n>\n>\n>\n> On 04/06/2018 08:00 PM, Claudio Freire wrote:\n> > On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> >> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> >>> On 06/04/18 01:59, Claudio Freire wrote:\n> >>>> The iteration interface, however, seems quite specific for the use\n> >>>> case of vacuumlazy, so it's not really a good abstraction.\n> >>>\n> >>> Can you elaborate? It does return the items one block at a time. Is that\n> >>> what you mean by being specific for vacuumlazy? I guess that's a bit\n> >>> special, but if you imagine some other users for this abstraction, it's\n> >>> probably not that unusual. For example, if we started using it in bitmap\n> >>> heap scans, a bitmap heap scan would also want to get the TIDs one block\n> >>> number at a time.\n> >> But you're also tying the caller to the format of the buffer holding\n> >> those TIDs, for instance. Why would you, when you can have an\n> >> interface that just iterates TIDs and let the caller store them\n> >> if/however they want?\n> >>\n> >> I do believe a pure iterator interface is a better interface.\n> > Between the b-tree or not discussion and the refactoring to separate\n> > the code, I don't think we'll get this in the next 24hs.\n> >\n> > So I guess we'll have ample time to poner on both issues during the\n> > next commit fest.\n> >\n>\n>\n>\n> There doesn't seem to have been much pondering done since then, at least\n> publicly. Can we make some progress on this? It's been around for a long\n> time now.\n\nYeah, life has kept me busy and I haven't had much time to make\nprogress here, but I was planning on doing the refactoring as we were\ndiscussing soon. Can't give a time frame for that, but \"soonish\".\n\n","msg_date":"Thu, 12 Jul 2018 13:38:18 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 07/12/2018 12:38 PM, Claudio Freire wrote:\n> On Thu, Jul 12, 2018 at 10:44 AM Andrew Dunstan\n> <andrew.dunstan@2ndquadrant.com> wrote:\n>>\n>>\n>> On 04/06/2018 08:00 PM, Claudio Freire wrote:\n>>> On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>>>> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>>>> On 06/04/18 01:59, Claudio Freire wrote:\n>>>>>> The iteration interface, however, seems quite specific for the use\n>>>>>> case of vacuumlazy, so it's not really a good abstraction.\n>>>>> Can you elaborate? It does return the items one block at a time. Is that\n>>>>> what you mean by being specific for vacuumlazy? I guess that's a bit\n>>>>> special, but if you imagine some other users for this abstraction, it's\n>>>>> probably not that unusual. For example, if we started using it in bitmap\n>>>>> heap scans, a bitmap heap scan would also want to get the TIDs one block\n>>>>> number at a time.\n>>>> But you're also tying the caller to the format of the buffer holding\n>>>> those TIDs, for instance. Why would you, when you can have an\n>>>> interface that just iterates TIDs and let the caller store them\n>>>> if/however they want?\n>>>>\n>>>> I do believe a pure iterator interface is a better interface.\n>>> Between the b-tree or not discussion and the refactoring to separate\n>>> the code, I don't think we'll get this in the next 24hs.\n>>>\n>>> So I guess we'll have ample time to poner on both issues during the\n>>> next commit fest.\n>>>\n>>\n>>\n>> There doesn't seem to have been much pondering done since then, at least\n>> publicly. Can we make some progress on this? It's been around for a long\n>> time now.\n> Yeah, life has kept me busy and I haven't had much time to make\n> progress here, but I was planning on doing the refactoring as we were\n> discussing soon. Can't give a time frame for that, but \"soonish\".\n\nI fully understand. I think this needs to go back to \"Waiting on Author\".\n\ncheers\n\nandrew\n\n-- \nAndrew Dunstan https://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n","msg_date":"Thu, 12 Jul 2018 18:15:54 -0400","msg_from":"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 2018-Jul-12, Andrew Dunstan wrote:\n\n> I fully understand. I think this needs to go back to \"Waiting on Author\".\n\nWhy? Heikki's patch applies fine and passes the regression tests.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n","msg_date":"Thu, 12 Jul 2018 18:34:05 -0400","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n> On 2018-Jul-12, Andrew Dunstan wrote:\n>\n>> I fully understand. I think this needs to go back to \"Waiting on Author\".\n> Why? Heikki's patch applies fine and passes the regression tests.\n>\n\n\nWell, I understood Claudio was going to do some more work (see \nupthread). If we're going to go with Heikki's patch then do we need to \nchange the author, or add him as an author?\n\ncheers\n\nandew\n\n-- \nAndrew Dunstan https://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n","msg_date":"Thu, 12 Jul 2018 18:39:38 -0400","msg_from":"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 13/07/18 01:39, Andrew Dunstan wrote:\n> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n>> On 2018-Jul-12, Andrew Dunstan wrote:\n>>\n>>> I fully understand. I think this needs to go back to \"Waiting on Author\".\n>> Why? Heikki's patch applies fine and passes the regression tests.\n> \n> Well, I understood Claudio was going to do some more work (see\n> upthread).\n\nClaudio raised a good point, that doing small pallocs leads to \nfragmentation, and in particular, it might mean that we can't give back \nthe memory to the OS. The default glibc malloc() implementation has a \nthreshold of 4 or 32 MB or something like that - allocations larger than \nthe threshold are mmap()'d, and can always be returned to the OS. I \nthink a simple solution to that is to allocate larger chunks, something \nlike 32-64 MB at a time, and carve out the allocations for the nodes \nfrom those chunks. That's pretty straightforward, because we don't need \nto worry about freeing the nodes in retail. Keep track of the current \nhalf-filled chunk, and allocate a new one when it fills up.\n\nHe also wanted to refactor the iterator API, to return one ItemPointer \nat a time. I don't think that's necessary, the current iterator API is \nmore convenient for the callers, but I don't feel strongly about that.\n\nAnything else?\n\n> If we're going to go with Heikki's patch then do we need to\n> change the author, or add him as an author?\n\nLet's list both of us. At least in the commit message, doesn't matter \nmuch what the commitfest app says.\n\n- Heikki\n\n","msg_date":"Fri, 13 Jul 2018 16:44:25 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\n> On 13/07/18 01:39, Andrew Dunstan wrote:\n>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n>>> On 2018-Jul-12, Andrew Dunstan wrote:\n>>>\n>>>> I fully understand. I think this needs to go back to \"Waiting on \n>>>> Author\".\n>>> Why? Heikki's patch applies fine and passes the regression tests.\n>>\n>> Well, I understood Claudio was going to do some more work (see\n>> upthread).\n>\n> Claudio raised a good point, that doing small pallocs leads to \n> fragmentation, and in particular, it might mean that we can't give \n> back the memory to the OS. The default glibc malloc() implementation \n> has a threshold of 4 or 32 MB or something like that - allocations \n> larger than the threshold are mmap()'d, and can always be returned to \n> the OS. I think a simple solution to that is to allocate larger \n> chunks, something like 32-64 MB at a time, and carve out the \n> allocations for the nodes from those chunks. That's pretty \n> straightforward, because we don't need to worry about freeing the \n> nodes in retail. Keep track of the current half-filled chunk, and \n> allocate a new one when it fills up.\n\n\nGoogle seems to suggest the default threshold is much lower, like 128K. \nStill, making larger allocations seems sensible. Are you going to work \non that?\n\n\n>\n> He also wanted to refactor the iterator API, to return one ItemPointer \n> at a time. I don't think that's necessary, the current iterator API is \n> more convenient for the callers, but I don't feel strongly about that.\n>\n> Anything else?\n>\n>> If we're going to go with Heikki's patch then do we need to\n>> change the author, or add him as an author?\n>\n> Let's list both of us. At least in the commit message, doesn't matter \n> much what the commitfest app says.\n>\n\n\nI added you as an author in the CF App\n\ncheers\n\nandrew\n\n-- \nAndrew Dunstan https://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n","msg_date":"Fri, 13 Jul 2018 16:43:12 -0400","msg_from":"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\n<andrew.dunstan@2ndquadrant.com> wrote:\n>\n>\n>\n> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\n> > On 13/07/18 01:39, Andrew Dunstan wrote:\n> >> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n> >>> On 2018-Jul-12, Andrew Dunstan wrote:\n> >>>\n> >>>> I fully understand. I think this needs to go back to \"Waiting on\n> >>>> Author\".\n> >>> Why? Heikki's patch applies fine and passes the regression tests.\n> >>\n> >> Well, I understood Claudio was going to do some more work (see\n> >> upthread).\n> >\n> > Claudio raised a good point, that doing small pallocs leads to\n> > fragmentation, and in particular, it might mean that we can't give\n> > back the memory to the OS. The default glibc malloc() implementation\n> > has a threshold of 4 or 32 MB or something like that - allocations\n> > larger than the threshold are mmap()'d, and can always be returned to\n> > the OS. I think a simple solution to that is to allocate larger\n> > chunks, something like 32-64 MB at a time, and carve out the\n> > allocations for the nodes from those chunks. That's pretty\n> > straightforward, because we don't need to worry about freeing the\n> > nodes in retail. Keep track of the current half-filled chunk, and\n> > allocate a new one when it fills up.\n>\n>\n> Google seems to suggest the default threshold is much lower, like 128K.\n> Still, making larger allocations seems sensible. Are you going to work\n> on that?\n\nBelow a few MB the threshold is dynamic, and if a block bigger than\n128K but smaller than the higher threshold (32-64MB IIRC) is freed,\nthe dynamic threshold is set to the size of the freed block.\n\nSee M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\n\nSo I'd suggest allocating blocks bigger than M_MMAP_MAX.\n\n[1] http://man7.org/linux/man-pages/man3/mallopt.3.html\n\n","msg_date":"Mon, 16 Jul 2018 11:34:53 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Jul 16, 2018 at 11:34 AM Claudio Freire <klaussfreire@gmail.com> wrote:\n>\n> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\n> <andrew.dunstan@2ndquadrant.com> wrote:\n> >\n> >\n> >\n> > On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\n> > > On 13/07/18 01:39, Andrew Dunstan wrote:\n> > >> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n> > >>> On 2018-Jul-12, Andrew Dunstan wrote:\n> > >>>\n> > >>>> I fully understand. I think this needs to go back to \"Waiting on\n> > >>>> Author\".\n> > >>> Why? Heikki's patch applies fine and passes the regression tests.\n> > >>\n> > >> Well, I understood Claudio was going to do some more work (see\n> > >> upthread).\n> > >\n> > > Claudio raised a good point, that doing small pallocs leads to\n> > > fragmentation, and in particular, it might mean that we can't give\n> > > back the memory to the OS. The default glibc malloc() implementation\n> > > has a threshold of 4 or 32 MB or something like that - allocations\n> > > larger than the threshold are mmap()'d, and can always be returned to\n> > > the OS. I think a simple solution to that is to allocate larger\n> > > chunks, something like 32-64 MB at a time, and carve out the\n> > > allocations for the nodes from those chunks. That's pretty\n> > > straightforward, because we don't need to worry about freeing the\n> > > nodes in retail. Keep track of the current half-filled chunk, and\n> > > allocate a new one when it fills up.\n> >\n> >\n> > Google seems to suggest the default threshold is much lower, like 128K.\n> > Still, making larger allocations seems sensible. Are you going to work\n> > on that?\n>\n> Below a few MB the threshold is dynamic, and if a block bigger than\n> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\n> the dynamic threshold is set to the size of the freed block.\n>\n> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\n>\n> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\n>\n> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\n\nSorry, substitute M_MMAP_MAX with DEFAULT_MMAP_THRESHOLD_MAX, the\nformer is something else.\n\n","msg_date":"Mon, 16 Jul 2018 12:35:17 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On 16/07/18 18:35, Claudio Freire wrote:\n> On Mon, Jul 16, 2018 at 11:34 AM Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\n>> <andrew.dunstan@2ndquadrant.com> wrote:\n>>> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\n>>>> Claudio raised a good point, that doing small pallocs leads to\n>>>> fragmentation, and in particular, it might mean that we can't give\n>>>> back the memory to the OS. The default glibc malloc() implementation\n>>>> has a threshold of 4 or 32 MB or something like that - allocations\n>>>> larger than the threshold are mmap()'d, and can always be returned to\n>>>> the OS. I think a simple solution to that is to allocate larger\n>>>> chunks, something like 32-64 MB at a time, and carve out the\n>>>> allocations for the nodes from those chunks. That's pretty\n>>>> straightforward, because we don't need to worry about freeing the\n>>>> nodes in retail. Keep track of the current half-filled chunk, and\n>>>> allocate a new one when it fills up.\n>>>\n>>> Google seems to suggest the default threshold is much lower, like 128K.\n>>> Still, making larger allocations seems sensible. Are you going to work\n>>> on that?\n>>\n>> Below a few MB the threshold is dynamic, and if a block bigger than\n>> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\n>> the dynamic threshold is set to the size of the freed block.\n>>\n>> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\n>>\n>> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\n>>\n>> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\n> \n> Sorry, substitute M_MMAP_MAX with DEFAULT_MMAP_THRESHOLD_MAX, the\n> former is something else.\n\nYeah, we basically want to be well above whatever the threshold is. I \ndon't think we should try to check for any specific constant, just make \nit large enough. Different libc implementations might have different \npolicies, too. There's little harm in overshooting, and making e.g. 64 \nMB allocations when 1 MB would've been enough to trigger the mmap() \nbehavior. It's going to be more granular than the current situation, \nanyway, where we do a single massive allocation.\n\n(A code comment to briefly mention the thresholds on common platforms \nwould be good, though).\n\n- Heikki\n\n","msg_date":"Mon, 16 Jul 2018 18:47:45 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 07/16/2018 10:34 AM, Claudio Freire wrote:\n> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\n> <andrew.dunstan@2ndquadrant.com> wrote:\n>>\n>>\n>> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\n>>> On 13/07/18 01:39, Andrew Dunstan wrote:\n>>>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n>>>>> On 2018-Jul-12, Andrew Dunstan wrote:\n>>>>>\n>>>>>> I fully understand. I think this needs to go back to \"Waiting on\n>>>>>> Author\".\n>>>>> Why? Heikki's patch applies fine and passes the regression tests.\n>>>> Well, I understood Claudio was going to do some more work (see\n>>>> upthread).\n>>> Claudio raised a good point, that doing small pallocs leads to\n>>> fragmentation, and in particular, it might mean that we can't give\n>>> back the memory to the OS. The default glibc malloc() implementation\n>>> has a threshold of 4 or 32 MB or something like that - allocations\n>>> larger than the threshold are mmap()'d, and can always be returned to\n>>> the OS. I think a simple solution to that is to allocate larger\n>>> chunks, something like 32-64 MB at a time, and carve out the\n>>> allocations for the nodes from those chunks. That's pretty\n>>> straightforward, because we don't need to worry about freeing the\n>>> nodes in retail. Keep track of the current half-filled chunk, and\n>>> allocate a new one when it fills up.\n>>\n>> Google seems to suggest the default threshold is much lower, like 128K.\n>> Still, making larger allocations seems sensible. Are you going to work\n>> on that?\n> Below a few MB the threshold is dynamic, and if a block bigger than\n> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\n> the dynamic threshold is set to the size of the freed block.\n>\n> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\n>\n> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\n>\n> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\n\n\nThat page says:\n\n M_MMAP_MAX\n This parameter specifies the maximum number of allocation\n requests that may be simultaneously serviced using mmap(2).\n This parameter exists because some systems have a limited\n number of internal tables for use by mmap(2), and using more\n than a few of them may degrade performance.\n\n The default value is 65,536, a value which has no special\n significance and which serves only as a safeguard. Setting\n this parameter to 0 disables the use of mmap(2) for servicing\n large allocation requests.\n\n\nI'm confused about the relevance.\n\ncheers\n\nandrew\n\n-- \nAndrew Dunstan https://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n","msg_date":"Mon, 16 Jul 2018 14:30:13 -0400","msg_from":"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Jul 16, 2018 at 3:30 PM Andrew Dunstan\n<andrew.dunstan@2ndquadrant.com> wrote:\n>\n>\n>\n> On 07/16/2018 10:34 AM, Claudio Freire wrote:\n> > On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\n> > <andrew.dunstan@2ndquadrant.com> wrote:\n> >>\n> >>\n> >> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\n> >>> On 13/07/18 01:39, Andrew Dunstan wrote:\n> >>>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n> >>>>> On 2018-Jul-12, Andrew Dunstan wrote:\n> >>>>>\n> >>>>>> I fully understand. I think this needs to go back to \"Waiting on\n> >>>>>> Author\".\n> >>>>> Why? Heikki's patch applies fine and passes the regression tests.\n> >>>> Well, I understood Claudio was going to do some more work (see\n> >>>> upthread).\n> >>> Claudio raised a good point, that doing small pallocs leads to\n> >>> fragmentation, and in particular, it might mean that we can't give\n> >>> back the memory to the OS. The default glibc malloc() implementation\n> >>> has a threshold of 4 or 32 MB or something like that - allocations\n> >>> larger than the threshold are mmap()'d, and can always be returned to\n> >>> the OS. I think a simple solution to that is to allocate larger\n> >>> chunks, something like 32-64 MB at a time, and carve out the\n> >>> allocations for the nodes from those chunks. That's pretty\n> >>> straightforward, because we don't need to worry about freeing the\n> >>> nodes in retail. Keep track of the current half-filled chunk, and\n> >>> allocate a new one when it fills up.\n> >>\n> >> Google seems to suggest the default threshold is much lower, like 128K.\n> >> Still, making larger allocations seems sensible. Are you going to work\n> >> on that?\n> > Below a few MB the threshold is dynamic, and if a block bigger than\n> > 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\n> > the dynamic threshold is set to the size of the freed block.\n> >\n> > See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\n> >\n> > So I'd suggest allocating blocks bigger than M_MMAP_MAX.\n> >\n> > [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\n>\n>\n> That page says:\n>\n> M_MMAP_MAX\n> This parameter specifies the maximum number of allocation\n> requests that may be simultaneously serviced using mmap(2).\n> This parameter exists because some systems have a limited\n> number of internal tables for use by mmap(2), and using more\n> than a few of them may degrade performance.\n>\n> The default value is 65,536, a value which has no special\n> significance and which serves only as a safeguard. Setting\n> this parameter to 0 disables the use of mmap(2) for servicing\n> large allocation requests.\n>\n>\n> I'm confused about the relevance.\n\nIt isn't relevant. See my next message, it should have read\nDEFAULT_MMAP_THRESHOLD_MAX.\n\n","msg_date":"Mon, 16 Jul 2018 15:32:03 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":true,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"\n\nOn 07/16/2018 11:35 AM, Claudio Freire wrote:\n> On Mon, Jul 16, 2018 at 11:34 AM Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\n>> <andrew.dunstan@2ndquadrant.com> wrote:\n>>>\n>>>\n>>> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\n>>>> On 13/07/18 01:39, Andrew Dunstan wrote:\n>>>>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\n>>>>>> On 2018-Jul-12, Andrew Dunstan wrote:\n>>>>>>\n>>>>>>> I fully understand. I think this needs to go back to \"Waiting on\n>>>>>>> Author\".\n>>>>>> Why? Heikki's patch applies fine and passes the regression tests.\n>>>>> Well, I understood Claudio was going to do some more work (see\n>>>>> upthread).\n>>>> Claudio raised a good point, that doing small pallocs leads to\n>>>> fragmentation, and in particular, it might mean that we can't give\n>>>> back the memory to the OS. The default glibc malloc() implementation\n>>>> has a threshold of 4 or 32 MB or something like that - allocations\n>>>> larger than the threshold are mmap()'d, and can always be returned to\n>>>> the OS. I think a simple solution to that is to allocate larger\n>>>> chunks, something like 32-64 MB at a time, and carve out the\n>>>> allocations for the nodes from those chunks. That's pretty\n>>>> straightforward, because we don't need to worry about freeing the\n>>>> nodes in retail. Keep track of the current half-filled chunk, and\n>>>> allocate a new one when it fills up.\n>>>\n>>> Google seems to suggest the default threshold is much lower, like 128K.\n>>> Still, making larger allocations seems sensible. Are you going to work\n>>> on that?\n>> Below a few MB the threshold is dynamic, and if a block bigger than\n>> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\n>> the dynamic threshold is set to the size of the freed block.\n>>\n>> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\n>>\n>> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\n>>\n>> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\n> Sorry, substitute M_MMAP_MAX with DEFAULT_MMAP_THRESHOLD_MAX, the\n> former is something else.\n\n\nAh, ok. Thanks. ignore the email I just sent about that.\n\ncheers\n\nandrew\n\n-- \nAndrew Dunstan https://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n","msg_date":"Mon, 16 Jul 2018 14:33:17 -0400","msg_from":"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Fri, Apr 6, 2018 at 4:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> True all that. My point is that the multi-segmented array isn't all that\n>> simple and proven, compared to an also straightforward B-tree. It's pretty\n>> similar to a B-tree, actually, except that it has exactly two levels, and\n>> the node (= segment) sizes grow exponentially. I'd rather go with a true\n>> B-tree, than something homegrown that resembles a B-tree, but not quite.\n>\n> I disagree.\n\nYeah, me too. I think a segmented array is a lot simpler than a\nhome-grown btree. I wrote a home-grown btree that ended up becoming\nsrc/backend/utils/mmgr/freepage.c and it took me a long time to get\nrid of all the bugs. Heikki is almost certainly better at coding up a\nbug-free btree than I am, but a segmented array is a dead simple data\nstructure, or should be if done properly, and a btree is not.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n","msg_date":"Tue, 17 Jul 2018 13:30:15 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"},{"msg_contents":"On Mon, Jul 16, 2018 at 02:33:17PM -0400, Andrew Dunstan wrote:\n> Ah, ok. Thanks. ignore the email I just sent about that.\n\nSo... This thread has basically died of inactivity, while there have\nbeen a couple of interesting things discussed, like the version from\nHeikki here:\nhttps://www.postgresql.org/message-id/cd8f7b62-17e1-4307-9f81-427922e5a1f6@iki.fi\n\nI am marking the patches as returned with feedback for now.\n--\nMichael","msg_date":"Tue, 2 Oct 2018 10:43:03 +0900","msg_from":"Michael Paquier <michael@paquier.xyz>","msg_from_op":false,"msg_subject":"Re: Vacuum: allow usage of more than 1GB of work mem"}],"string":"[\n {\n \"msg_contents\": \"The attached patch allows setting maintainance_work_mem or\\nautovacuum_work_mem higher than 1GB (and be effective), by turning the\\nallocation of the dead_tuples into a huge allocation.\\n\\nThis results in fewer index scans for heavily bloated tables, and\\ncould be a lifesaver in many situations (in particular, the situation\\nI'm living right now in production, where we don't have enough room\\nfor a vacuum full, and have just deleted 75% of a table to make room\\nbut have to rely on regular lazy vacuum to free the space).\\n\\nThe patch also makes vacuum free the dead_tuples before starting\\ntruncation. It didn't seem necessary to hold onto it beyond that\\npoint, and it might help give the OS more cache, especially if work\\nmem is configured very high to avoid multiple index scans.\\n\\nTested with pgbench scale 4000 after deleting the whole\\npgbench_accounts table, seemed to work fine.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sat, 3 Sep 2016 00:25:37 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 3 September 2016 at 04:25, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> The attached patch allows setting maintainance_work_mem or\\n> autovacuum_work_mem higher than 1GB (and be effective), by turning the\\n> allocation of the dead_tuples into a huge allocation.\\n>\\n> This results in fewer index scans for heavily bloated tables, and\\n> could be a lifesaver in many situations (in particular, the situation\\n> I'm living right now in production, where we don't have enough room\\n> for a vacuum full, and have just deleted 75% of a table to make room\\n> but have to rely on regular lazy vacuum to free the space).\\n\\nThis part looks fine. I'm inclined to commit the attached patch soon.\\n\\n> The patch also makes vacuum free the dead_tuples before starting\\n> truncation. It didn't seem necessary to hold onto it beyond that\\n> point, and it might help give the OS more cache, especially if work\\n> mem is configured very high to avoid multiple index scans.\\n\\nHow long does that part ever take? Is there any substantial gain from this?\\n\\nLets discuss that as a potential second patch.\\n\\n> Tested with pgbench scale 4000 after deleting the whole\\n> pgbench_accounts table, seemed to work fine.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sun, 4 Sep 2016 07:46:26 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 9/4/16 1:46 AM, Simon Riggs wrote:\\n>> > The patch also makes vacuum free the dead_tuples before starting\\n>> > truncation. It didn't seem necessary to hold onto it beyond that\\n>> > point, and it might help give the OS more cache, especially if work\\n>> > mem is configured very high to avoid multiple index scans.\\n> How long does that part ever take? Is there any substantial gain from this?\\n\\nIf you're asking about how long the dealloc takes, we're going to have \\nto pay that cost anyway when the context gets destroyed/reset, no? Doing \\nthat sooner rather than later certainly seems like a good idea since \\nwe've seen that truncation can take quite some time. Might as well give \\nthe memory back to the OS ASAP.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 4 Sep 2016 18:10:36 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 4, 2016 at 3:46 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 3 September 2016 at 04:25, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> The patch also makes vacuum free the dead_tuples before starting\\n>> truncation. It didn't seem necessary to hold onto it beyond that\\n>> point, and it might help give the OS more cache, especially if work\\n>> mem is configured very high to avoid multiple index scans.\\n>\\n> How long does that part ever take? Is there any substantial gain from this?\\n>\\n> Lets discuss that as a potential second patch.\\n\\nIn the test case I mentioned, it takes longer than the vacuum part itself.\\n\\nOther than freeing RAM there's no gain. I didn't measure any speed\\ndifference while testing, but that's probably because the backward\\nscan doesn't benefit from the cache, but other activity on the system\\nmight. So, depending on the workload on the server, extra available\\nRAM may be a significant gain on its own or not. It just didn't seem\\nthere was a reason to keep that RAM reserved, especially after making\\nit a huge allocation.\\n\\nI'm fine either way. I can remove that from the patch or leave it\\nas-is. It just seemed like a good idea at the time.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 11:50:28 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 5, 2016 at 11:50 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Sun, Sep 4, 2016 at 3:46 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> On 3 September 2016 at 04:25, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> The patch also makes vacuum free the dead_tuples before starting\\n>>> truncation. It didn't seem necessary to hold onto it beyond that\\n>>> point, and it might help give the OS more cache, especially if work\\n>>> mem is configured very high to avoid multiple index scans.\\n>>\\n>> How long does that part ever take? Is there any substantial gain from this?\\n>>\\n>> Lets discuss that as a potential second patch.\\n>\\n> In the test case I mentioned, it takes longer than the vacuum part itself.\\n>\\n> Other than freeing RAM there's no gain. I didn't measure any speed\\n> difference while testing, but that's probably because the backward\\n> scan doesn't benefit from the cache, but other activity on the system\\n> might. So, depending on the workload on the server, extra available\\n> RAM may be a significant gain on its own or not. It just didn't seem\\n> there was a reason to keep that RAM reserved, especially after making\\n> it a huge allocation.\\n>\\n> I'm fine either way. I can remove that from the patch or leave it\\n> as-is. It just seemed like a good idea at the time.\\n\\n\\nRebased and split versions attached\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 5 Sep 2016 16:15:40 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 5 September 2016 at 15:50, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Sun, Sep 4, 2016 at 3:46 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> On 3 September 2016 at 04:25, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> The patch also makes vacuum free the dead_tuples before starting\\n>>> truncation. It didn't seem necessary to hold onto it beyond that\\n>>> point, and it might help give the OS more cache, especially if work\\n>>> mem is configured very high to avoid multiple index scans.\\n>>\\n>> How long does that part ever take? Is there any substantial gain from this?\\n>>\\n>> Lets discuss that as a potential second patch.\\n>\\n> In the test case I mentioned, it takes longer than the vacuum part itself.\\n\\nPlease provide a test case and timings so we can see what's happening.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 21:36:16 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 5, 2016 at 5:36 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 5 September 2016 at 15:50, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Sun, Sep 4, 2016 at 3:46 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>>> On 3 September 2016 at 04:25, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>>> The patch also makes vacuum free the dead_tuples before starting\\n>>>> truncation. It didn't seem necessary to hold onto it beyond that\\n>>>> point, and it might help give the OS more cache, especially if work\\n>>>> mem is configured very high to avoid multiple index scans.\\n>>>\\n>>> How long does that part ever take? Is there any substantial gain from this?\\n>>>\\n>>> Lets discuss that as a potential second patch.\\n>>\\n>> In the test case I mentioned, it takes longer than the vacuum part itself.\\n>\\n> Please provide a test case and timings so we can see what's happening.\\n\\nThe referenced test case is the one I mentioned on the OP:\\n\\n- createdb pgbench\\n- pgbench -i -s 4000 pgbench\\n- psql pgbench -c 'delete from pgbench_accounts;'\\n- vacuumdb -v -t pgbench_accounts pgbench\\n\\nfsync=off, autovacuum=off, maintainance_work_mem=4GB\\n\\n From what I remember, it used ~2.7GB of RAM up until the truncate\\nphase, where it freed it. It performed a single index scan over the\\nPK.\\n\\nI don't remember timings, and I didn't take them, so I'll have to\\nrepeat the test to get them. It takes all day and makes my laptop\\nunusably slow, so I'll post them later, but they're not very\\ninteresting. The only interesting bit is that it does a single index\\nscan instead of several, which on TB-or-more tables it's kinda nice.\\n\\nBtw, without a further patch to prefetch pages on the backward scan\\nfor truncate, however, my patience ran out before it finished\\ntruncating. I haven't submitted that patch because there was an\\nidentical patch in an older thread that was discussed and more or less\\nrejected since it slightly penalized SSDs. While I'm confident my\\nversion of the patch is a little easier on SSDs, I haven't got an SSD\\nat hand to confirm, so that patch is still waiting on the queue until\\nI get access to an SSD. The tests I'll make include that patch, so the\\ntiming regarding truncate won't be representative of HEAD (I really\\ncan't afford to run the tests on a scale=4000 pgbench without that\\npatch, it crawls, and smaller scales don't fill the dead_tuples\\narray).\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 17:58:17 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 5 September 2016 at 21:58, Claudio Freire <klaussfreire@gmail.com> wrote:\\n\\n>>>> How long does that part ever take? Is there any substantial gain from this?\\n\\n> Btw, without a further patch to prefetch pages on the backward scan\\n> for truncate, however, my patience ran out before it finished\\n> truncating. I haven't submitted that patch because there was an\\n> identical patch in an older thread that was discussed and more or less\\n> rejected since it slightly penalized SSDs.\\n\\nOK, thats enough context. Sorry for being forgetful on that point.\\n\\nPlease post that new patch also.\\n\\n\\nThis whole idea of backwards scanning to confirm truncation seems\\nwrong. What we want is an O(1) solution. Thinking.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 07:45:45 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Sat, Sep 3, 2016 at 8:55 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> The attached patch allows setting maintainance_work_mem or\\n> autovacuum_work_mem higher than 1GB (and be effective), by turning the\\n> allocation of the dead_tuples into a huge allocation.\\n>\\n> This results in fewer index scans for heavily bloated tables, and\\n> could be a lifesaver in many situations (in particular, the situation\\n> I'm living right now in production, where we don't have enough room\\n> for a vacuum full, and have just deleted 75% of a table to make room\\n> but have to rely on regular lazy vacuum to free the space).\\n>\\n> The patch also makes vacuum free the dead_tuples before starting\\n> truncation. It didn't seem necessary to hold onto it beyond that\\n> point, and it might help give the OS more cache, especially if work\\n> mem is configured very high to avoid multiple index scans.\\n>\\n> Tested with pgbench scale 4000 after deleting the whole\\n> pgbench_accounts table, seemed to work fine.\\n\\nThe problem with this is that we allocate the entire amount of\\nmaintenance_work_mem even when the number of actual dead tuples turns\\nout to be very small. That's not so bad if the amount of memory we're\\npotentially wasting is limited to ~1 GB, but it seems pretty dangerous\\nto remove the 1 GB limit, because somebody might have\\nmaintenance_work_mem set to tens or hundreds of gigabytes to speed\\nindex creation, and allocating that much space for a VACUUM that\\nencounters 1 dead tuple does not seem like a good plan.\\n\\nWhat I think we need to do is make some provision to initially\\nallocate only a small amount of memory and then grow the allocation\\nlater if needed. For example, instead of having\\nvacrelstats->dead_tuples be declared as ItemPointer, declare it as\\nItemPointer * and allocate the array progressively in segments. I'd\\nactually argue that the segment size should be substantially smaller\\nthan 1 GB, like say 64MB; there are still some people running systems\\nwhich are small enough that allocating 1 GB when we may need only 6\\nbytes can drive the system into OOM.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 22:12:25 +0530\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 4, 2016 at 8:10 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n> On 9/4/16 1:46 AM, Simon Riggs wrote:\\n>>>\\n>>> > The patch also makes vacuum free the dead_tuples before starting\\n>>> > truncation. It didn't seem necessary to hold onto it beyond that\\n>>> > point, and it might help give the OS more cache, especially if work\\n>>> > mem is configured very high to avoid multiple index scans.\\n>>\\n>> How long does that part ever take? Is there any substantial gain from\\n>> this?\\n>\\n>\\n> If you're asking about how long the dealloc takes, we're going to have to\\n> pay that cost anyway when the context gets destroyed/reset, no? Doing that\\n> sooner rather than later certainly seems like a good idea since we've seen\\n> that truncation can take quite some time. Might as well give the memory back\\n> to the OS ASAP.\\n\\nAFAIK, except on debug builds where it has to memset the whole thing,\\nthe cost is constant (unrelated to the allocated block size), so it\\nshould be rather small in this context.\\n\\n\\nOn Tue, Sep 6, 2016 at 1:42 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Sat, Sep 3, 2016 at 8:55 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> The attached patch allows setting maintainance_work_mem or\\n>> autovacuum_work_mem higher than 1GB (and be effective), by turning the\\n>> allocation of the dead_tuples into a huge allocation.\\n>>\\n>> This results in fewer index scans for heavily bloated tables, and\\n>> could be a lifesaver in many situations (in particular, the situation\\n>> I'm living right now in production, where we don't have enough room\\n>> for a vacuum full, and have just deleted 75% of a table to make room\\n>> but have to rely on regular lazy vacuum to free the space).\\n>>\\n>> The patch also makes vacuum free the dead_tuples before starting\\n>> truncation. It didn't seem necessary to hold onto it beyond that\\n>> point, and it might help give the OS more cache, especially if work\\n>> mem is configured very high to avoid multiple index scans.\\n>>\\n>> Tested with pgbench scale 4000 after deleting the whole\\n>> pgbench_accounts table, seemed to work fine.\\n>\\n> The problem with this is that we allocate the entire amount of\\n> maintenance_work_mem even when the number of actual dead tuples turns\\n> out to be very small. That's not so bad if the amount of memory we're\\n> potentially wasting is limited to ~1 GB, but it seems pretty dangerous\\n> to remove the 1 GB limit, because somebody might have\\n> maintenance_work_mem set to tens or hundreds of gigabytes to speed\\n> index creation, and allocating that much space for a VACUUM that\\n> encounters 1 dead tuple does not seem like a good plan.\\n>\\n> What I think we need to do is make some provision to initially\\n> allocate only a small amount of memory and then grow the allocation\\n> later if needed. For example, instead of having\\n> vacrelstats->dead_tuples be declared as ItemPointer, declare it as\\n> ItemPointer * and allocate the array progressively in segments. I'd\\n> actually argue that the segment size should be substantially smaller\\n> than 1 GB, like say 64MB; there are still some people running systems\\n> which are small enough that allocating 1 GB when we may need only 6\\n> bytes can drive the system into OOM.\\n\\nThis would however incur the cost of having to copy the whole GB-sized\\nchunk every time it's expanded. It woudln't be cheap.\\n\\nI've monitored the vacuum as it runs and the OS doesn't map the whole\\nblock unless it's touched, which it isn't until dead tuples are found.\\nSurely, if overcommit is disabled (as it should), it could exhaust the\\nvirtual address space if set very high, but it wouldn't really use the\\nmemory unless it's needed, it would merely reserve it.\\n\\nTo fix that, rather than repalloc the whole thing, dead_tuples would\\nhave to be an ItemPointer** of sorted chunks. That'd be a\\nsignificantly more complex patch, but at least it wouldn't incur the\\nmemcpy. I could attempt that, but I don't see the difference between\\nvacuum and create index in this case. Both could allocate a huge chunk\\nof the virtual address space if maintainance work mem says so, both\\nproportional to the size of the table. I can't see how that could take\\nany DBA by surprise.\\n\\nA sensible compromise could be dividing the maintainance_work_mem by\\nautovacuum_max_workers when used in autovacuum, as is done for cost\\nlimits, to protect those that set both rather high.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 13:58:25 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 10:28 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> The problem with this is that we allocate the entire amount of\\n>> maintenance_work_mem even when the number of actual dead tuples turns\\n>> out to be very small. That's not so bad if the amount of memory we're\\n>> potentially wasting is limited to ~1 GB, but it seems pretty dangerous\\n>> to remove the 1 GB limit, because somebody might have\\n>> maintenance_work_mem set to tens or hundreds of gigabytes to speed\\n>> index creation, and allocating that much space for a VACUUM that\\n>> encounters 1 dead tuple does not seem like a good plan.\\n>>\\n>> What I think we need to do is make some provision to initially\\n>> allocate only a small amount of memory and then grow the allocation\\n>> later if needed. For example, instead of having\\n>> vacrelstats->dead_tuples be declared as ItemPointer, declare it as\\n>> ItemPointer * and allocate the array progressively in segments. I'd\\n>> actually argue that the segment size should be substantially smaller\\n>> than 1 GB, like say 64MB; there are still some people running systems\\n>> which are small enough that allocating 1 GB when we may need only 6\\n>> bytes can drive the system into OOM.\\n>\\n> This would however incur the cost of having to copy the whole GB-sized\\n> chunk every time it's expanded. It woudln't be cheap.\\n\\nNo, I don't want to end up copying the whole array; that's what I\\nmeant by allocating it progressively in segments. Something like what\\nyou go on to propose.\\n\\n> I've monitored the vacuum as it runs and the OS doesn't map the whole\\n> block unless it's touched, which it isn't until dead tuples are found.\\n> Surely, if overcommit is disabled (as it should), it could exhaust the\\n> virtual address space if set very high, but it wouldn't really use the\\n> memory unless it's needed, it would merely reserve it.\\n\\nYeah, but I've seen actual breakage from exactly this issue on\\ncustomer systems even with the 1GB limit, and when we start allowing\\n100GB it's going to get a whole lot worse.\\n\\n> To fix that, rather than repalloc the whole thing, dead_tuples would\\n> have to be an ItemPointer** of sorted chunks. That'd be a\\n> significantly more complex patch, but at least it wouldn't incur the\\n> memcpy.\\n\\nRight, this is what I had in mind. I don't think this is actually\\nvery complicated, because the way we use this array is really simple.\\nWe basically just keep appending to the array until we run out of\\nspace, and that's not very hard to implement with an array-of-arrays.\\nThe chunks are, in some sense, sorted, as you say, but you don't need\\nto do qsort() or anything like that. You're just replacing a single\\nflat array with a data structure that can be grown incrementally in\\nfixed-size chunks.\\n\\n> I could attempt that, but I don't see the difference between\\n> vacuum and create index in this case. Both could allocate a huge chunk\\n> of the virtual address space if maintainance work mem says so, both\\n> proportional to the size of the table. I can't see how that could take\\n> any DBA by surprise.\\n\\nReally? CREATE INDEX isn't going to allocate more storage space than\\nthe size of the data actually being sorted, because tuplesort.c is\\nsmart about that kind of thing. But VACUUM will very happily allocate\\nvastly more memory than the number of dead tuples. It is thankfully\\nsmart enough not to allocate more storage than the number of line\\npointers that could theoretically exist in a relation of the given\\nsize, but that only helps for very small relations. In a large\\nrelation that divergence between the amount of storage space that\\ncould theoretically be needed and the amount that is actually needed\\nis likely to be extremely high. 1 TB relation = 2^27 blocks, each of\\nwhich can contain MaxHeapTuplesPerPage dead line pointers. On my\\nsystem, MaxHeapTuplesPerPage is 291, so that's 291 * 2^27 possible\\ndead line pointers, which at 6 bytes each is 291 * 6 * 2^27 = ~218GB,\\nbut the expected number of dead line pointers is much less than that.\\nEven if this is a vacuum triggered by autovacuum_vacuum_scale_factor\\nand you're using the default of 0.2 (probably too high for such a\\nlarge table), assuming there are about 60 tuples for page (which is\\nwhat I get with pgbench -i) the table would have about 2^27 * 60 = 7.7\\nbillion tuples of which 1.5 billion would be dead, meaning we need\\nabout 9-10GB of space to store all of those dead tuples. Allocating\\nas much as 218GB when we need 9-10GB is going to sting, and I don't\\nsee how you will get a comparable distortion with CREATE INDEX. I\\nmight be missing something, though.\\n\\nThere's no real issue when there's only one process running on the\\nsystem at a time. If the user set maintenance_work_mem to an amount\\nof memory that he can't afford to pay even once, then that's simple\\nmisconfiguration and it's not really our problem. The issue is that\\nwhen there are 3 or potentially more VACUUM processes running plus a\\nCREATE INDEX or two at the same time. If you set maintenance_work_mem\\nto a value that is large enough to make the CREATE INDEX run fast, now\\nwith your patch that is also going to cause each VACUUM process to\\ngobble up lots of extra memory that it probably doesn't need, and now\\nyou may well start to get failures. I've seen this happen even with\\nthe current 1GB limit, though you need a pretty small system - e.g.\\n8GB RAM - for it to be a problem. I think it is really really likely\\nto cause big problems for us if we dramatically increase that limit\\nwithout making the allocation algorithm smarter.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 23:09:49 +0530\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 2:39 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> I could attempt that, but I don't see the difference between\\n>> vacuum and create index in this case. Both could allocate a huge chunk\\n>> of the virtual address space if maintainance work mem says so, both\\n>> proportional to the size of the table. I can't see how that could take\\n>> any DBA by surprise.\\n>\\n> Really? CREATE INDEX isn't going to allocate more storage space than\\n> the size of the data actually being sorted, because tuplesort.c is\\n> smart about that kind of thing. But VACUUM will very happily allocate\\n> vastly more memory than the number of dead tuples. It is thankfully\\n> smart enough not to allocate more storage than the number of line\\n> pointers that could theoretically exist in a relation of the given\\n> size, but that only helps for very small relations. In a large\\n> relation that divergence between the amount of storage space that\\n> could theoretically be needed and the amount that is actually needed\\n> is likely to be extremely high. 1 TB relation = 2^27 blocks, each of\\n> which can contain MaxHeapTuplesPerPage dead line pointers. On my\\n> system, MaxHeapTuplesPerPage is 291, so that's 291 * 2^27 possible\\n> dead line pointers, which at 6 bytes each is 291 * 6 * 2^27 = ~218GB,\\n> but the expected number of dead line pointers is much less than that.\\n> Even if this is a vacuum triggered by autovacuum_vacuum_scale_factor\\n> and you're using the default of 0.2 (probably too high for such a\\n> large table), assuming there are about 60 tuples for page (which is\\n> what I get with pgbench -i) the table would have about 2^27 * 60 = 7.7\\n> billion tuples of which 1.5 billion would be dead, meaning we need\\n> about 9-10GB of space to store all of those dead tuples. Allocating\\n> as much as 218GB when we need 9-10GB is going to sting, and I don't\\n> see how you will get a comparable distortion with CREATE INDEX. I\\n> might be missing something, though.\\n\\nCREATE INDEX could also allocate 218GB, you just need to index enough\\ncolumns and you'll get that.\\n\\nAside from the fact that CREATE INDEX will only allocate what is going\\nto be used and VACUUM will overallocate, the potential to fully\\nallocate the amount given is still there for both cases.\\n\\n> There's no real issue when there's only one process running on the\\n> system at a time. If the user set maintenance_work_mem to an amount\\n> of memory that he can't afford to pay even once, then that's simple\\n> misconfiguration and it's not really our problem. The issue is that\\n> when there are 3 or potentially more VACUUM processes running plus a\\n> CREATE INDEX or two at the same time. If you set maintenance_work_mem\\n> to a value that is large enough to make the CREATE INDEX run fast, now\\n> with your patch that is also going to cause each VACUUM process to\\n> gobble up lots of extra memory that it probably doesn't need, and now\\n> you may well start to get failures. I've seen this happen even with\\n> the current 1GB limit, though you need a pretty small system - e.g.\\n> 8GB RAM - for it to be a problem. I think it is really really likely\\n> to cause big problems for us if we dramatically increase that limit\\n> without making the allocation algorithm smarter.\\n\\nOk, a pity it will invalidate all the testing already done though (I\\nwas almost done with the testing).\\n\\nI guess I'll send the results anyway.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 14:52:26 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 11:22 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> CREATE INDEX could also allocate 218GB, you just need to index enough\\n> columns and you'll get that.\\n>\\n> Aside from the fact that CREATE INDEX will only allocate what is going\\n> to be used and VACUUM will overallocate, the potential to fully\\n> allocate the amount given is still there for both cases.\\n\\nI agree with that, but I think there's a big difference between\\nallocating the memory only when it's needed and allocating it whether\\nit is needed or not. YMMV, of course, but that's what I think....\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 23:28:54 +0530\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Robert Haas <robertmhaas@gmail.com> writes:\\n> Yeah, but I've seen actual breakage from exactly this issue on\\n> customer systems even with the 1GB limit, and when we start allowing\\n> 100GB it's going to get a whole lot worse.\\n\\nWhile it's not necessarily a bad idea to consider these things,\\nI think people are greatly overestimating the consequences of the\\npatch-as-proposed. AFAICS, it does *not* let you tell VACUUM to\\neat 100GB of workspace. Note the line right in front of the one\\nbeing changed:\\n\\n maxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\\n maxtuples = Min(maxtuples, INT_MAX);\\n- maxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\\n+ maxtuples = Min(maxtuples, MaxAllocHugeSize / sizeof(ItemPointerData));\\n\\nRegardless of what vac_work_mem is, we aren't gonna let you have more\\nthan INT_MAX ItemPointers, hence 12GB at the most. So the worst-case\\nincrease from the patch as given is 12X. Maybe that's enough to cause\\nbad consequences on some systems, but it's not the sort of disaster\\nRobert posits above.\\n\\nIt's also worth re-reading the lines just after this, which constrain\\nthe allocation a whole lot more for small tables. Robert comments:\\n\\n> ... But VACUUM will very happily allocate\\n> vastly more memory than the number of dead tuples. It is thankfully\\n> smart enough not to allocate more storage than the number of line\\n> pointers that could theoretically exist in a relation of the given\\n> size, but that only helps for very small relations. In a large\\n> relation that divergence between the amount of storage space that\\n> could theoretically be needed and the amount that is actually needed\\n> is likely to be extremely high. 1 TB relation = 2^27 blocks, each of\\n> which can contain MaxHeapTuplesPerPage dead line pointers. On my\\n> system, MaxHeapTuplesPerPage is 291, so that's 291 * 2^27 possible\\n> dead line pointers, which at 6 bytes each is 291 * 6 * 2^27 = ~218GB,\\n> but the expected number of dead line pointers is much less than that.\\n\\nIf we think the expected number of dead pointers is so much less than\\nthat, why don't we just decrease LAZY_ALLOC_TUPLES, and take a hit in\\nextra index vacuum cycles when we're wrong?\\n\\n(Actually, what I'd be inclined to do is let it have MaxHeapTuplesPerPage\\nslots per page up till a few meg, and then start tailing off the\\nspace-per-page, figuring that the law of large numbers will probably kick\\nin.)\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 14:00:44 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 6 September 2016 at 19:00, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Robert Haas <robertmhaas@gmail.com> writes:\\n>> Yeah, but I've seen actual breakage from exactly this issue on\\n>> customer systems even with the 1GB limit, and when we start allowing\\n>> 100GB it's going to get a whole lot worse.\\n>\\n> While it's not necessarily a bad idea to consider these things,\\n> I think people are greatly overestimating the consequences of the\\n> patch-as-proposed. AFAICS, it does *not* let you tell VACUUM to\\n> eat 100GB of workspace. Note the line right in front of the one\\n> being changed:\\n>\\n> maxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\\n> maxtuples = Min(maxtuples, INT_MAX);\\n> - maxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\\n> + maxtuples = Min(maxtuples, MaxAllocHugeSize / sizeof(ItemPointerData));\\n>\\n> Regardless of what vac_work_mem is, we aren't gonna let you have more\\n> than INT_MAX ItemPointers, hence 12GB at the most. So the worst-case\\n> increase from the patch as given is 12X. Maybe that's enough to cause\\n> bad consequences on some systems, but it's not the sort of disaster\\n> Robert posits above.\\n\\nIs there a reason we can't use repalloc here?\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 19:06:16 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 2:00 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Robert Haas <robertmhaas@gmail.com> writes:\\n>> Yeah, but I've seen actual breakage from exactly this issue on\\n>> customer systems even with the 1GB limit, and when we start allowing\\n>> 100GB it's going to get a whole lot worse.\\n>\\n> While it's not necessarily a bad idea to consider these things,\\n> I think people are greatly overestimating the consequences of the\\n> patch-as-proposed. AFAICS, it does *not* let you tell VACUUM to\\n> eat 100GB of workspace. Note the line right in front of the one\\n> being changed:\\n>\\n> maxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\\n> maxtuples = Min(maxtuples, INT_MAX);\\n> - maxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\\n> + maxtuples = Min(maxtuples, MaxAllocHugeSize / sizeof(ItemPointerData));\\n>\\n> Regardless of what vac_work_mem is, we aren't gonna let you have more\\n> than INT_MAX ItemPointers, hence 12GB at the most. So the worst-case\\n> increase from the patch as given is 12X. Maybe that's enough to cause\\n> bad consequences on some systems, but it's not the sort of disaster\\n> Robert posits above.\\n\\nHmm, OK. Yes, that is a lot less bad. (I think it's still bad.)\\n\\n> If we think the expected number of dead pointers is so much less than\\n> that, why don't we just decrease LAZY_ALLOC_TUPLES, and take a hit in\\n> extra index vacuum cycles when we're wrong?\\n\\nBecause that's really inefficient. Growing the array, even with a\\nstupid approach that copies all of the TIDs every time, is a heck of a\\nlot faster than incurring an extra index vac cycle.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 14:07:08 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 2:06 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 6 September 2016 at 19:00, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>> Robert Haas <robertmhaas@gmail.com> writes:\\n>>> Yeah, but I've seen actual breakage from exactly this issue on\\n>>> customer systems even with the 1GB limit, and when we start allowing\\n>>> 100GB it's going to get a whole lot worse.\\n>>\\n>> While it's not necessarily a bad idea to consider these things,\\n>> I think people are greatly overestimating the consequences of the\\n>> patch-as-proposed. AFAICS, it does *not* let you tell VACUUM to\\n>> eat 100GB of workspace. Note the line right in front of the one\\n>> being changed:\\n>>\\n>> maxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\\n>> maxtuples = Min(maxtuples, INT_MAX);\\n>> - maxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\\n>> + maxtuples = Min(maxtuples, MaxAllocHugeSize / sizeof(ItemPointerData));\\n>>\\n>> Regardless of what vac_work_mem is, we aren't gonna let you have more\\n>> than INT_MAX ItemPointers, hence 12GB at the most. So the worst-case\\n>> increase from the patch as given is 12X. Maybe that's enough to cause\\n>> bad consequences on some systems, but it's not the sort of disaster\\n>> Robert posits above.\\n>\\n> Is there a reason we can't use repalloc here?\\n\\nThere are two possible problems, either of which is necessarily fatal:\\n\\n1. I expect repalloc probably works by allocating the new space,\\ncopying from old to new, and freeing the old. That could work out\\nbadly if we are nearly the edge of the system's allocation limit.\\n\\n2. It's slower than the approach proposed upthread of allocating the\\narray in segments. With that approach, we never need to memcpy()\\nanything.\\n\\nOn the plus side, it's probably less code.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 14:09:32 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 2:09 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> There are two possible problems, either of which is necessarily fatal:\\n\\nI meant to write \\\"neither of which\\\" not \\\"either of which\\\".\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 14:09:59 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Simon Riggs <simon@2ndquadrant.com> writes:\\n> Is there a reason we can't use repalloc here?\\n\\n(1) repalloc will probably copy the data.\\n\\n(2) that answer doesn't excuse you from choosing a limit.\\n\\nWe could get around (1) by something like Robert's idea of segmented\\nallocation, but TBH I've seen nothing on this thread to make me think\\nit's necessary or would even result in any performance improvement\\nat all. The bigger we make that array, the worse index-cleaning\\nis going to perform, and complicating the data structure will add\\nanother hit on top of that.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 14:11:49 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 3:11 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> We could get around (1) by something like Robert's idea of segmented\\n> allocation, but TBH I've seen nothing on this thread to make me think\\n> it's necessary or would even result in any performance improvement\\n> at all. The bigger we make that array, the worse index-cleaning\\n> is going to perform, and complicating the data structure will add\\n> another hit on top of that.\\n\\nI wouldn't be so sure, I've seen cases where two binary searches were\\nfaster than a single binary search, especially when working with\\nhumongus arrays like this tid array, because touching less (memory)\\npages for a search does pay off considerably.\\n\\nI'd try before giving up on the idea.\\n\\nThe test results (which I'll post in a second) do give credit to your\\nexpectation that making the array bigger/more complex does impact\\nindex scan performance. It's still faster than scanning several times\\nthough.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 15:16:11 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 6 September 2016 at 19:09, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Tue, Sep 6, 2016 at 2:06 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> On 6 September 2016 at 19:00, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>>> Robert Haas <robertmhaas@gmail.com> writes:\\n>>>> Yeah, but I've seen actual breakage from exactly this issue on\\n>>>> customer systems even with the 1GB limit, and when we start allowing\\n>>>> 100GB it's going to get a whole lot worse.\\n>>>\\n>>> While it's not necessarily a bad idea to consider these things,\\n>>> I think people are greatly overestimating the consequences of the\\n>>> patch-as-proposed. AFAICS, it does *not* let you tell VACUUM to\\n>>> eat 100GB of workspace. Note the line right in front of the one\\n>>> being changed:\\n>>>\\n>>> maxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\\n>>> maxtuples = Min(maxtuples, INT_MAX);\\n>>> - maxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\\n>>> + maxtuples = Min(maxtuples, MaxAllocHugeSize / sizeof(ItemPointerData));\\n>>>\\n>>> Regardless of what vac_work_mem is, we aren't gonna let you have more\\n>>> than INT_MAX ItemPointers, hence 12GB at the most. So the worst-case\\n>>> increase from the patch as given is 12X. Maybe that's enough to cause\\n>>> bad consequences on some systems, but it's not the sort of disaster\\n>>> Robert posits above.\\n>>\\n>> Is there a reason we can't use repalloc here?\\n>\\n> There are two possible problems, either of which is necessarily fatal:\\n>\\n> 1. I expect repalloc probably works by allocating the new space,\\n> copying from old to new, and freeing the old. That could work out\\n> badly if we are nearly the edge of the system's allocation limit.\\n>\\n> 2. It's slower than the approach proposed upthread of allocating the\\n> array in segments. With that approach, we never need to memcpy()\\n> anything.\\n>\\n> On the plus side, it's probably less code.\\n\\nHmm, OK.\\n\\nWhat occurs to me is that we can exactly predict how many tuples we\\nare going to get when we autovacuum, since we measure that and we know\\nwhat the number is when we trigger it.\\n\\nSo there doesn't need to be any guessing going on at all, nor do we\\nneed it to be flexible.\\n\\nMy proposal now is to pass in the number of rows changed since last\\nvacuum and use that (+10% to be safe) as the size of the array, up to\\nthe defined limit.\\n\\nManual VACUUM still needs to guess, so we might need a flexible\\nsolution there, but generally we don't. We could probably estimate it\\nfrom the VM.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 19:16:27 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 2:16 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> What occurs to me is that we can exactly predict how many tuples we\\n> are going to get when we autovacuum, since we measure that and we know\\n> what the number is when we trigger it.\\n>\\n> So there doesn't need to be any guessing going on at all, nor do we\\n> need it to be flexible.\\n\\nNo, that's not really true. A lot can change between the time it's\\ntriggered and the time it happens, or even while it's happening.\\nSomebody can run a gigantic bulk delete just after we start the\\nVACUUM.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 14:23:48 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 3:45 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 5 September 2016 at 21:58, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>\\n>>>>> How long does that part ever take? Is there any substantial gain from this?\\n>\\n>> Btw, without a further patch to prefetch pages on the backward scan\\n>> for truncate, however, my patience ran out before it finished\\n>> truncating. I haven't submitted that patch because there was an\\n>> identical patch in an older thread that was discussed and more or less\\n>> rejected since it slightly penalized SSDs.\\n>\\n> OK, thats enough context. Sorry for being forgetful on that point.\\n>\\n> Please post that new patch also.\\n\\nAttached.\\n\\nOn Mon, Sep 5, 2016 at 5:58 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Mon, Sep 5, 2016 at 5:36 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> On 5 September 2016 at 15:50, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> On Sun, Sep 4, 2016 at 3:46 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>>>> On 3 September 2016 at 04:25, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>>>> The patch also makes vacuum free the dead_tuples before starting\\n>>>>> truncation. It didn't seem necessary to hold onto it beyond that\\n>>>>> point, and it might help give the OS more cache, especially if work\\n>>>>> mem is configured very high to avoid multiple index scans.\\n>>>>\\n>>>> How long does that part ever take? Is there any substantial gain from this?\\n>>>>\\n>>>> Lets discuss that as a potential second patch.\\n>>>\\n>>> In the test case I mentioned, it takes longer than the vacuum part itself.\\n>>\\n>> Please provide a test case and timings so we can see what's happening.\\n\\nRobert made a strong point for a change in the approach, so the\\ninformation below is applicable only to the old patch (to be\\nrewritten).\\n\\nI'm sending this merely to document the testing done, it will be a\\nwhile before I can get the proposed design running and tested.\\n\\n> The referenced test case is the one I mentioned on the OP:\\n>\\n> - createdb pgbench\\n> - pgbench -i -s 4000 pgbench\\n> - psql pgbench -c 'delete from pgbench_accounts;'\\n> - vacuumdb -v -t pgbench_accounts pgbench\\n>\\n> fsync=off, autovacuum=off, maintainance_work_mem=4GB\\n>\\n> From what I remember, it used ~2.7GB of RAM up until the truncate\\n> phase, where it freed it. It performed a single index scan over the\\n> PK.\\n>\\n> I don't remember timings, and I didn't take them, so I'll have to\\n> repeat the test to get them. It takes all day and makes my laptop\\n> unusably slow, so I'll post them later, but they're not very\\n> interesting. The only interesting bit is that it does a single index\\n> scan instead of several, which on TB-or-more tables it's kinda nice.\\n\\n\\nSo, the test results below:\\n\\nDuring setup, maybe for context, the delete took 52m 50s real time\\n(measured with time psql pgbench -c 'delete from pgbench_accounts;')\\n\\nDuring the delete, my I/O was on average like the following, which\\nshould give an indication of what my I/O subsystem is capable of (not\\nmuch, granted):\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 0.47 5.27 35.53 77.42 17.58 42.95\\n1097.51 145.22 1295.23 33.47 1874.36 8.85 100.00\\n\\nSince it's a 5k RPM laptop drive, it's rather slow on IOPS, and since\\nI'm using the defaults for shared buffers and checkpoints, write\\nthoughput isn't stellar either. But that's not the point of the test\\nanyway, it's just for context.\\n\\nThe hardware is an HP envy laptop with a 1TB 5.4k RPM hard drive, 12GB\\nRAM, core i7-4722HQ, no weird performance tweaking of any kind (ie:\\ncpu scaling left intact). The system was not dedicated of course,\\nbeing a laptop, but it had little else going on while the test was\\nrunning. Given the size of the test, I don't believe there's any\\nchance concurrent activity could invalidate the results.\\n\\nThe timing for setup was comparable with both versions (patched and\\nunpatched), so I'm reporting the patched times only.\\n\\n\\nThe vacuum phase:\\n\\npatched:\\n\\n$ vacuumdb -v -t pgbench_accounts pgbench\\nINFO: vacuuming \\\"public.pgbench_accounts\\\"\\nINFO: scanned index \\\"pgbench_accounts_pkey\\\" to remove 400000000 row versions\\nDETAIL: CPU 12.46s/48.76u sec elapsed 566.47 sec.\\nINFO: \\\"pgbench_accounts\\\": removed 400000000 row versions in 6557378 pages\\nDETAIL: CPU 56.68s/28.90u sec elapsed 1872.76 sec.\\nINFO: index \\\"pgbench_accounts_pkey\\\" now contains 0 row versions in\\n1096762 pages\\nDETAIL: 400000000 index row versions were removed.\\n1092896 index pages have been deleted, 0 are currently reusable.\\nCPU 0.00s/0.00u sec elapsed 0.47 sec.\\nINFO: \\\"pgbench_accounts\\\": found 400000000 removable, 0 nonremovable\\nrow versions in 6557378 out of 6557378 pages\\nDETAIL: 0 dead row versions cannot be removed yet.\\nThere were 0 unused item pointers.\\nSkipped 0 pages due to buffer pins.\\n0 pages are entirely empty.\\nCPU 129.24s/127.24u sec elapsed 3877.13 sec.\\nINFO: \\\"pgbench_accounts\\\": truncated 6557378 to 0 pages\\nDETAIL: CPU 34.88s/7.91u sec elapsed 1645.90 sec.\\n\\nTotal elapsed time: ~92 minutes\\n\\nI/O during initial heap scan:\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 1.52 99.78 72.63 62.47 31.94 33.22\\n987.80 146.71 1096.29 25.39 2341.48 7.40 100.00\\n\\nIndex scan:\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 7.08 3.87 55.18 59.87 17.06 31.83\\n870.33 146.61 1243.34 31.42 2360.44 8.69 100.00\\n\\nFinal heap scan:\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 0.78 8.65 65.32 57.32 31.50 32.96\\n1076.56 152.22 1928.67 1410.63 2519.01 8.15 100.00\\n\\nTruncate (with prefetch):\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 159.67 0.87 3720.03 2.82 30.31 0.12\\n16.74 19.11 5.13 4.95 242.60 0.27 99.23\\n\\nWithout prefetch, rMB/s during truncation varies between 4MB/s and\\n6MB/s, so it's on average 6 times slower, meaning it would take over 3\\nhours.\\n\\nPeak memory used: 2369MB RSS, 4260MB VIRT (source: top)\\n\\nUnpatched + prefetch (same config, effective work mem 1GB due to\\nnon-huge allocation limit):\\n\\n$ vacuumdb -v -t pgbench_accounts pgbench\\nINFO: vacuuming \\\"public.pgbench_accounts\\\"\\nINFO: scanned index \\\"pgbench_accounts_pkey\\\" to remove 178956737 row versions\\nDETAIL: CPU 5.88s/53.77u sec elapsed 263.63 sec.\\nINFO: \\\"pgbench_accounts\\\": removed 178956737 row versions in 2933717 pages\\nDETAIL: CPU 22.28s/12.94u sec elapsed 757.45 sec.\\nINFO: scanned index \\\"pgbench_accounts_pkey\\\" to remove 178956737 row versions\\nDETAIL: CPU 7.44s/31.28u sec elapsed 282.41 sec.\\nINFO: \\\"pgbench_accounts\\\": removed 178956737 row versions in 2933717 pages\\nDETAIL: CPU 22.24s/13.30u sec elapsed 806.54 sec.\\nINFO: scanned index \\\"pgbench_accounts_pkey\\\" to remove 42086526 row versions\\nDETAIL: CPU 4.30s/5.83u sec elapsed 170.30 sec.\\nINFO: \\\"pgbench_accounts\\\": removed 42086526 row versions in 689944 pages\\nDETAIL: CPU 3.35s/3.23u sec elapsed 126.22 sec.\\nINFO: index \\\"pgbench_accounts_pkey\\\" now contains 0 row versions in\\n1096762 pages\\nDETAIL: 400000000 index row versions were removed.\\n1096351 index pages have been deleted, 0 are currently reusable.\\nCPU 0.00s/0.00u sec elapsed 0.40 sec.\\nINFO: \\\"pgbench_accounts\\\": found 400000000 removable, 0 nonremovable\\nrow versions in 6557378 out of 6557378 pages\\nDETAIL: 0 dead row versions cannot be removed yet.\\nThere were 0 unused item pointers.\\nSkipped 0 pages due to buffer pins.\\n0 pages are entirely empty.\\nCPU 123.82s/183.76u sec elapsed 4071.54 sec.\\nINFO: \\\"pgbench_accounts\\\": truncated 6557378 to 0 pages\\nDETAIL: CPU 40.36s/7.72u sec elapsed 1648.22 sec.\\n\\nTotal elapsed time: ~95m\\n\\nI/O during initial heap scan:\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 1.48 32.53 66.10 60.50 31.95 34.88\\n1081.06 149.20 1175.78 25.44 2432.59 8.02 101.59\\n\\nFirst index scan:\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 1.17 14.95 43.85 70.07 19.65 40.18\\n1075.57 145.98 1278.39 31.86 2058.51 8.78 100.00\\n\\nFinal index scan:\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 17.12 1.50 169.85 2.28 68.33 0.67\\n820.95 158.32 312.00 28.14 21426.95 5.81 100.00\\n\\nTruncation:\\n\\nDevice: rrqm/s wrqm/s r/s w/s rMB/s wMB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsda 142.93 1.23 3444.70 4.65 28.16 0.36\\n16.93 18.52 5.37 5.25 91.17 0.29 99.22\\n\\nPeak memory used is 1135MB RSS and 1188MB VIRT\\n\\nComparing:\\n\\nTime reportedly spent scanning indexes: 716.34 unpatched, 566.47 patched\\nTime reportedly spent scanning heap: 1690.21 unpatched, 1872.76 patched\\nTotal vacuum scan as reported: 4071.54 unpatched, 3877.13 patched\\n\\nSurely I didn't expect it to be such a close call. I believe the key\\nreason is the speedup it got during the final index scan for not\\nhaving to delete so many tuples. Clearly, having to interleave reads\\nand writes is stressing my HD, and the last index scan, having to\\nwrite less, was thus faster.\\n\\nI don't believe this would have happened if the index hadn't been\\npristine and in almost physical (heap) order, so I'd expect real-world\\ncases (with properly aged, shuffled and bloated indexes) to show a\\nmore pronounced difference. Or when using a cost limit, that will\\nartificially limit the I/O rate vacuum can reach.\\n\\nClearly the patch is of use when I/O is the limiting factor, either\\ndue to vacuum cost limits, or due to the I/O subsystem being the\\nbottleneck, as was the case during the above test case. Since more\\nwork mem will mean a slower lookup of the dead_tuples array, not only\\ndue to the extra comparisons but also poorer cache locality, I believe\\nit won't benefit the runtime cost of CPU-bound cases, but it should at\\nleast generate less WAL since that's another benefit of scanning the\\nindexes fewer times (increased WAL rates during vacuum is another\\nproblem we regularly face in our production setup).\\n\\nGiven the I/O subsystem on my test machine isn't able to produce a\\nCPU-bound test case for the amount of dead_tuples involved in\\nstressing the patch, I cannot confirm the above statement, but it\\nshould be evident given the implementation.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 6 Sep 2016 15:25:10 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 6 September 2016 at 19:23, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Tue, Sep 6, 2016 at 2:16 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> What occurs to me is that we can exactly predict how many tuples we\\n>> are going to get when we autovacuum, since we measure that and we know\\n>> what the number is when we trigger it.\\n>>\\n>> So there doesn't need to be any guessing going on at all, nor do we\\n>> need it to be flexible.\\n>\\n> No, that's not really true. A lot can change between the time it's\\n> triggered and the time it happens, or even while it's happening.\\n> Somebody can run a gigantic bulk delete just after we start the\\n> VACUUM.\\n\\nWhich wouldn't be removed by the VACUUM, so can be ignored.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 19:51:14 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 2:51 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 6 September 2016 at 19:23, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> On Tue, Sep 6, 2016 at 2:16 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>>> What occurs to me is that we can exactly predict how many tuples we\\n>>> are going to get when we autovacuum, since we measure that and we know\\n>>> what the number is when we trigger it.\\n>>>\\n>>> So there doesn't need to be any guessing going on at all, nor do we\\n>>> need it to be flexible.\\n>>\\n>> No, that's not really true. A lot can change between the time it's\\n>> triggered and the time it happens, or even while it's happening.\\n>> Somebody can run a gigantic bulk delete just after we start the\\n>> VACUUM.\\n>\\n> Which wouldn't be removed by the VACUUM, so can be ignored.\\n\\nOK, true. But I still think it's very unlikely that we can calculate\\nan exact count of how many dead tuples we might run into. I think we\\nshouldn't rely on the stats collector to be perfectly correct anyway -\\nfor one thing, you can turn it off - and instead cope with the\\nuncertainty.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 14:55:31 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Simon Riggs <simon@2ndquadrant.com> writes:\\n> On 6 September 2016 at 19:23, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> On Tue, Sep 6, 2016 at 2:16 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>>> What occurs to me is that we can exactly predict how many tuples we\\n>>> are going to get when we autovacuum, since we measure that and we know\\n>>> what the number is when we trigger it.\\n>>> So there doesn't need to be any guessing going on at all, nor do we\\n>>> need it to be flexible.\\n\\n>> No, that's not really true. A lot can change between the time it's\\n>> triggered and the time it happens, or even while it's happening.\\n>> Somebody can run a gigantic bulk delete just after we start the\\n>> VACUUM.\\n\\n> Which wouldn't be removed by the VACUUM, so can be ignored.\\n\\n(1) If the delete commits just before the vacuum starts, it may be\\nremovable. I think you're nuts to imagine there are no race conditions\\nhere.\\n\\n(2) Stats from the stats collector never have been, and likely never will\\nbe, anything but approximate. That goes double for dead-tuple counts,\\nwhich are inaccurate even as sent from backends, never mind the multiple\\nways that the collector might lose the counts.\\n\\nThe idea of looking to the stats to *guess* about how many tuples are\\nremovable doesn't seem bad at all. But imagining that that's going to be\\nexact is folly of the first magnitude.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 14:59:14 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 6 September 2016 at 19:59, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n\\n> The idea of looking to the stats to *guess* about how many tuples are\\n> removable doesn't seem bad at all. But imagining that that's going to be\\n> exact is folly of the first magnitude.\\n\\nYes. Bear in mind I had already referred to allowing +10% to be safe,\\nso I think we agree that a reasonably accurate, yet imprecise\\ncalculation is possible in most cases.\\n\\nIf a recent transaction has committed, we will see both committed dead\\nrows and stats to show they exist. I'm sure there are corner cases and\\nrace conditions where a major effect (greater than 10%) could occur,\\nin which case we run the index scan more than once, just as we do now.\\n\\nThe attached patch raises the limits as suggested by Claudio, allowing\\nfor larger memory allocations if possible, yet limits the allocation\\nfor larger tables based on the estimate gained from pg_stats, while\\nadding 10% for caution.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 7 Sep 2016 13:45:50 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 7, 2016 at 1:45 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 6 September 2016 at 19:59, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>\\n>> The idea of looking to the stats to *guess* about how many tuples are\\n>> removable doesn't seem bad at all. But imagining that that's going to be\\n>> exact is folly of the first magnitude.\\n>\\n> Yes. Bear in mind I had already referred to allowing +10% to be safe,\\n> so I think we agree that a reasonably accurate, yet imprecise\\n> calculation is possible in most cases.\\n\\nThat would all be well and good if it weren't trivial to do what\\nRobert suggested. This is just a large unsorted list that we need to\\niterate throught. Just allocate chunks of a few megabytes and when\\nit's full allocate a new chunk and keep going. There's no need to get\\ntricky with estimates and resizing and whatever.\\n\\n-- \\ngreg\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 16:12:16 +0100\",\n \"msg_from\": \"Greg Stark <stark@mit.edu>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 7, 2016 at 12:12 PM, Greg Stark <stark@mit.edu> wrote:\\n> On Wed, Sep 7, 2016 at 1:45 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> On 6 September 2016 at 19:59, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>>\\n>>> The idea of looking to the stats to *guess* about how many tuples are\\n>>> removable doesn't seem bad at all. But imagining that that's going to be\\n>>> exact is folly of the first magnitude.\\n>>\\n>> Yes. Bear in mind I had already referred to allowing +10% to be safe,\\n>> so I think we agree that a reasonably accurate, yet imprecise\\n>> calculation is possible in most cases.\\n>\\n> That would all be well and good if it weren't trivial to do what\\n> Robert suggested. This is just a large unsorted list that we need to\\n> iterate throught. Just allocate chunks of a few megabytes and when\\n> it's full allocate a new chunk and keep going. There's no need to get\\n> tricky with estimates and resizing and whatever.\\n\\nI agree. While the idea of estimating the right size sounds promising\\na priori, considering the estimate can go wrong and over or\\nunderallocate quite severely, the risks outweigh the benefits when you\\nconsider the alternative of a dynamic allocation strategy.\\n\\nUnless the dynamic strategy has a bigger CPU impact than expected, I\\nbelieve it's a superior approach.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 13:48:47 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 7, 2016 at 2:39 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Tue, Sep 6, 2016 at 10:28 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> The problem with this is that we allocate the entire amount of\\n>>> maintenance_work_mem even when the number of actual dead tuples turns\\n>>> out to be very small. That's not so bad if the amount of memory we're\\n>>> potentially wasting is limited to ~1 GB, but it seems pretty dangerous\\n>>> to remove the 1 GB limit, because somebody might have\\n>>> maintenance_work_mem set to tens or hundreds of gigabytes to speed\\n>>> index creation, and allocating that much space for a VACUUM that\\n>>> encounters 1 dead tuple does not seem like a good plan.\\n>>>\\n>>> What I think we need to do is make some provision to initially\\n>>> allocate only a small amount of memory and then grow the allocation\\n>>> later if needed. For example, instead of having\\n>>> vacrelstats->dead_tuples be declared as ItemPointer, declare it as\\n>>> ItemPointer * and allocate the array progressively in segments. I'd\\n>>> actually argue that the segment size should be substantially smaller\\n>>> than 1 GB, like say 64MB; there are still some people running systems\\n>>> which are small enough that allocating 1 GB when we may need only 6\\n>>> bytes can drive the system into OOM.\\n>>\\n>> This would however incur the cost of having to copy the whole GB-sized\\n>> chunk every time it's expanded. It woudln't be cheap.\\n>\\n> No, I don't want to end up copying the whole array; that's what I\\n> meant by allocating it progressively in segments. Something like what\\n> you go on to propose.\\n>\\n>> I've monitored the vacuum as it runs and the OS doesn't map the whole\\n>> block unless it's touched, which it isn't until dead tuples are found.\\n>> Surely, if overcommit is disabled (as it should), it could exhaust the\\n>> virtual address space if set very high, but it wouldn't really use the\\n>> memory unless it's needed, it would merely reserve it.\\n>\\n> Yeah, but I've seen actual breakage from exactly this issue on\\n> customer systems even with the 1GB limit, and when we start allowing\\n> 100GB it's going to get a whole lot worse.\\n>\\n>> To fix that, rather than repalloc the whole thing, dead_tuples would\\n>> have to be an ItemPointer** of sorted chunks. That'd be a\\n>> significantly more complex patch, but at least it wouldn't incur the\\n>> memcpy.\\n>\\n> Right, this is what I had in mind. I don't think this is actually\\n> very complicated, because the way we use this array is really simple.\\n> We basically just keep appending to the array until we run out of\\n> space, and that's not very hard to implement with an array-of-arrays.\\n> The chunks are, in some sense, sorted, as you say, but you don't need\\n> to do qsort() or anything like that. You're just replacing a single\\n> flat array with a data structure that can be grown incrementally in\\n> fixed-size chunks.\\n>\\n\\nIf we replaced dead_tuples with an array-of-array, isn't there\\nnegative performance impact for lazy_tid_reap()?\\nAs chunk is added, that performance would be decrease.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 17:48:07 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 9/8/16 3:48 AM, Masahiko Sawada wrote:\\n> If we replaced dead_tuples with an array-of-array, isn't there\\n> negative performance impact for lazy_tid_reap()?\\n> As chunk is added, that performance would be decrease.\\n\\nYes, it certainly would, as you'd have to do 2 binary searches. I'm not \\nsure how much that matters though; presumably the index scans are \\nnormally IO-bound?\\n\\nAnother option would be to use the size estimation ideas others have \\nmentioned to create one array. If the estimates prove to be wrong you \\ncould then create a single additional segment; by that point you should \\nhave a better idea of how far off the original estimate was. That means \\nthe added search cost would only be a compare and a second pointer redirect.\\n\\nSomething else that occurred to me... AFAIK the only reason we don't \\nsupport syncscan with VACUUM is because it would require sorting the TID \\nlist. If we just added a second TID list we would be able to support \\nsyncscan, swapping over to the 'low' list when we hit the end of the \\nrelation.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 09:35:29 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 7, 2016 at 10:18 PM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n> On Wed, Sep 7, 2016 at 12:12 PM, Greg Stark <stark@mit.edu> wrote:\\n> > On Wed, Sep 7, 2016 at 1:45 PM, Simon Riggs <simon@2ndquadrant.com>\\n> wrote:\\n> >> On 6 September 2016 at 19:59, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> >>\\n> >>> The idea of looking to the stats to *guess* about how many tuples are\\n> >>> removable doesn't seem bad at all. But imagining that that's going to\\n> be\\n> >>> exact is folly of the first magnitude.\\n> >>\\n> >> Yes. Bear in mind I had already referred to allowing +10% to be safe,\\n> >> so I think we agree that a reasonably accurate, yet imprecise\\n> >> calculation is possible in most cases.\\n> >\\n> > That would all be well and good if it weren't trivial to do what\\n> > Robert suggested. This is just a large unsorted list that we need to\\n> > iterate throught. Just allocate chunks of a few megabytes and when\\n> > it's full allocate a new chunk and keep going. There's no need to get\\n> > tricky with estimates and resizing and whatever.\\n>\\n> I agree. While the idea of estimating the right size sounds promising\\n> a priori, considering the estimate can go wrong and over or\\n> underallocate quite severely, the risks outweigh the benefits when you\\n> consider the alternative of a dynamic allocation strategy.\\n>\\n> Unless the dynamic strategy has a bigger CPU impact than expected, I\\n> believe it's a superior approach.\\n>\\n>\\nHow about a completely different representation for the TID array? Now this\\nis probably not something new, but I couldn't find if the exact same idea\\nwas discussed before. I also think it's somewhat orthogonal to what we are\\ntrying to do here, and will probably be a bigger change. But I thought I'll\\nmention since we are at the topic.\\n\\nWhat I propose is to use a simple bitmap to represent the tuples. If a\\ntuple at <block, offset> is dead then the corresponding bit in the bitmap\\nis set. So clearly the searches through dead tuples are O(1) operations,\\nimportant for very large tables and large arrays.\\n\\nChallenge really is that a heap page can theoretically have MaxOffsetNumber\\nof line pointers (or to be precise maximum possible offset number). For a\\n8K block, that comes be about 2048. Having so many bits per page is neither\\npractical nor optimal. But in practice the largest offset on a heap page\\nshould not be significantly greater than MaxHeapTuplesPerPage, which is a\\nmore reasonable value of 291 on my machine. Again, that's with zero sized\\ntuple and for real life large tables, with much wider tuples, the number\\nmay go down even further.\\n\\nSo we cap the offsets represented in the bitmap to some realistic value,\\ncomputed by looking at page density and then multiplying it by a small\\nfactor (not more than two) to take into account LP_DEAD and LP_REDIRECT\\nline pointers. That should practically represent majority of the dead\\ntuples in the table, but we then keep an overflow area to record tuples\\nbeyond the limit set for per page. The search routine will do a direct\\nlookup for offsets less than the limit and search in the sorted overflow\\narea for offsets beyond the limit.\\n\\nFor example, for a table with 60 bytes wide tuple (including 24 byte\\nheader), each page can approximately have 8192/60 = 136 tuples. Say we\\nprovision for 136*2 = 272 bits per page i.e. 34 bytes per page for the\\nbitmap. First 272 offsets in every page are represented in the bitmap and\\nanything greater than are in overflow region. On the other hand, the\\ncurrent representation will need about 16 bytes per page assuming 2% dead\\ntuples, 40 bytes per page assuming 5% dead tuples and 80 bytes assuming 10%\\ndead tuples. So bitmap will take more space for small tuples or when vacuum\\nis run very aggressively, both seems unlikely for very large tables. Of\\ncourse the calculation does not take into account the space needed by the\\noverflow area, but I expect that too be small.\\n\\nI guess we can make a choice between two representations at the start\\nlooking at various table stats. We can also be smart and change from bitmap\\nto traditional representation as we scan the table and see many more tuples\\nin the overflow region than we provisioned for. There will be some\\nchallenges in converting representation mid-way, especially in terms of\\nmemory allocation, but I think those can be sorted out if we think that the\\nidea has merit.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Wed, Sep 7, 2016 at 10:18 PM, Claudio Freire <klaussfreire@gmail.com> wrote:On Wed, Sep 7, 2016 at 12:12 PM, Greg Stark <stark@mit.edu> wrote:\\n> On Wed, Sep 7, 2016 at 1:45 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> On 6 September 2016 at 19:59, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>>\\n>>> The idea of looking to the stats to *guess* about how many tuples are\\n>>> removable doesn't seem bad at all. But imagining that that's going to be\\n>>> exact is folly of the first magnitude.\\n>>\\n>> Yes. Bear in mind I had already referred to allowing +10% to be safe,\\n>> so I think we agree that a reasonably accurate, yet imprecise\\n>> calculation is possible in most cases.\\n>\\n> That would all be well and good if it weren't trivial to do what\\n> Robert suggested. This is just a large unsorted list that we need to\\n> iterate throught. Just allocate chunks of a few megabytes and when\\n> it's full allocate a new chunk and keep going. There's no need to get\\n> tricky with estimates and resizing and whatever.\\n\\nI agree. While the idea of estimating the right size sounds promising\\na priori, considering the estimate can go wrong and over or\\nunderallocate quite severely, the risks outweigh the benefits when you\\nconsider the alternative of a dynamic allocation strategy.\\n\\nUnless the dynamic strategy has a bigger CPU impact than expected, I\\nbelieve it's a superior approach.\\nHow about a completely different representation for the TID array? Now this is probably not something new, but I couldn't find if the exact same idea was discussed before. I also think it's somewhat orthogonal to what we are trying to do here, and will probably be a bigger change. But I thought I'll mention since we are at the topic.What I propose is to use a simple bitmap to represent the tuples. If a tuple at <block, offset> is dead then the corresponding bit in the bitmap is set. So clearly the searches through dead tuples are O(1) operations, important for very large tables and large arrays.Challenge really is that a heap page can theoretically have MaxOffsetNumber of line pointers (or to be precise maximum possible offset number). For a 8K block, that comes be about 2048. Having so many bits per page is neither practical nor optimal. But in practice the largest offset on a heap page should not be significantly greater than MaxHeapTuplesPerPage, which is a more reasonable value of 291 on my machine. Again, that's with zero sized tuple and for real life large tables, with much wider tuples, the number may go down even further.So we cap the offsets represented in the bitmap to some realistic value, computed by looking at page density and then multiplying it by a small factor (not more than two) to take into account LP_DEAD and LP_REDIRECT line pointers. That should practically represent majority of the dead tuples in the table, but we then keep an overflow area to record tuples beyond the limit set for per page. The search routine will do a direct lookup for offsets less than the limit and search in the sorted overflow area for offsets beyond the limit.For example, for a table with 60 bytes wide tuple (including 24 byte header), each page can approximately have 8192/60 = 136 tuples. Say we provision for 136*2 = 272 bits per page i.e. 34 bytes per page for the bitmap. First 272 offsets in every page are represented in the bitmap and anything greater than are in overflow region. On the other hand, the current representation will need about 16 bytes per page assuming 2% dead tuples, 40 bytes per page assuming 5% dead tuples and 80 bytes assuming 10% dead tuples. So bitmap will take more space for small tuples or when vacuum is run very aggressively, both seems unlikely for very large tables. Of course the calculation does not take into account the space needed by the overflow area, but I expect that too be small.I guess we can make a choice between two representations at the start looking at various table stats. We can also be smart and change from bitmap to traditional representation as we scan the table and see many more tuples in the overflow region than we provisioned for. There will be some challenges in converting representation mid-way, especially in terms of memory allocation, but I think those can be sorted out if we think that the idea has merit.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Thu, 8 Sep 2016 20:24:19 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 11:54 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> For example, for a table with 60 bytes wide tuple (including 24 byte\\n> header), each page can approximately have 8192/60 = 136 tuples. Say we\\n> provision for 136*2 = 272 bits per page i.e. 34 bytes per page for the\\n> bitmap. First 272 offsets in every page are represented in the bitmap and\\n> anything greater than are in overflow region. On the other hand, the current\\n> representation will need about 16 bytes per page assuming 2% dead tuples, 40\\n> bytes per page assuming 5% dead tuples and 80 bytes assuming 10% dead\\n> tuples. So bitmap will take more space for small tuples or when vacuum is\\n> run very aggressively, both seems unlikely for very large tables. Of course\\n> the calculation does not take into account the space needed by the overflow\\n> area, but I expect that too be small.\\n\\nI thought about something like this, but it could be extremely\\ninefficient for mostly frozen tables, since the bitmap cannot account\\nfor frozen pages without losing the O(1) lookup characteristic\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 12:12:55 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 8:42 PM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n> On Thu, Sep 8, 2016 at 11:54 AM, Pavan Deolasee\\n> <pavan.deolasee@gmail.com> wrote:\\n> > For example, for a table with 60 bytes wide tuple (including 24 byte\\n> > header), each page can approximately have 8192/60 = 136 tuples. Say we\\n> > provision for 136*2 = 272 bits per page i.e. 34 bytes per page for the\\n> > bitmap. First 272 offsets in every page are represented in the bitmap and\\n> > anything greater than are in overflow region. On the other hand, the\\n> current\\n> > representation will need about 16 bytes per page assuming 2% dead\\n> tuples, 40\\n> > bytes per page assuming 5% dead tuples and 80 bytes assuming 10% dead\\n> > tuples. So bitmap will take more space for small tuples or when vacuum is\\n> > run very aggressively, both seems unlikely for very large tables. Of\\n> course\\n> > the calculation does not take into account the space needed by the\\n> overflow\\n> > area, but I expect that too be small.\\n>\\n> I thought about something like this, but it could be extremely\\n> inefficient for mostly frozen tables, since the bitmap cannot account\\n> for frozen pages without losing the O(1) lookup characteristic\\n>\\n\\nWell, that's correct. But I thought the whole point is when there are large\\nnumber of dead tuples which requires large memory. If my math was correct\\nas explained above, then even at 5% dead tuples, bitmap representation will\\nconsume approximate same memory but provide O(1) search time.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Thu, Sep 8, 2016 at 8:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:On Thu, Sep 8, 2016 at 11:54 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> For example, for a table with 60 bytes wide tuple (including 24 byte\\n> header), each page can approximately have 8192/60 = 136 tuples. Say we\\n> provision for 136*2 = 272 bits per page i.e. 34 bytes per page for the\\n> bitmap. First 272 offsets in every page are represented in the bitmap and\\n> anything greater than are in overflow region. On the other hand, the current\\n> representation will need about 16 bytes per page assuming 2% dead tuples, 40\\n> bytes per page assuming 5% dead tuples and 80 bytes assuming 10% dead\\n> tuples. So bitmap will take more space for small tuples or when vacuum is\\n> run very aggressively, both seems unlikely for very large tables. Of course\\n> the calculation does not take into account the space needed by the overflow\\n> area, but I expect that too be small.\\n\\nI thought about something like this, but it could be extremely\\ninefficient for mostly frozen tables, since the bitmap cannot account\\nfor frozen pages without losing the O(1) lookup characteristic\\nWell, that's correct. But I thought the whole point is when there are large number of dead tuples which requires large memory. If my math was correct as explained above, then even at 5% dead tuples, bitmap representation will consume approximate same memory but provide O(1) search time.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Thu, 8 Sep 2016 22:21:31 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 11:54 PM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n> On Wed, Sep 7, 2016 at 10:18 PM, Claudio Freire <klaussfreire@gmail.com>\\n> wrote:\\n>>\\n>> On Wed, Sep 7, 2016 at 12:12 PM, Greg Stark <stark@mit.edu> wrote:\\n>> > On Wed, Sep 7, 2016 at 1:45 PM, Simon Riggs <simon@2ndquadrant.com>\\n>> > wrote:\\n>> >> On 6 September 2016 at 19:59, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>> >>\\n>> >>> The idea of looking to the stats to *guess* about how many tuples are\\n>> >>> removable doesn't seem bad at all. But imagining that that's going to\\n>> >>> be\\n>> >>> exact is folly of the first magnitude.\\n>> >>\\n>> >> Yes. Bear in mind I had already referred to allowing +10% to be safe,\\n>> >> so I think we agree that a reasonably accurate, yet imprecise\\n>> >> calculation is possible in most cases.\\n>> >\\n>> > That would all be well and good if it weren't trivial to do what\\n>> > Robert suggested. This is just a large unsorted list that we need to\\n>> > iterate throught. Just allocate chunks of a few megabytes and when\\n>> > it's full allocate a new chunk and keep going. There's no need to get\\n>> > tricky with estimates and resizing and whatever.\\n>>\\n>> I agree. While the idea of estimating the right size sounds promising\\n>> a priori, considering the estimate can go wrong and over or\\n>> underallocate quite severely, the risks outweigh the benefits when you\\n>> consider the alternative of a dynamic allocation strategy.\\n>>\\n>> Unless the dynamic strategy has a bigger CPU impact than expected, I\\n>> believe it's a superior approach.\\n>>\\n>\\n> How about a completely different representation for the TID array? Now this\\n> is probably not something new, but I couldn't find if the exact same idea\\n> was discussed before. I also think it's somewhat orthogonal to what we are\\n> trying to do here, and will probably be a bigger change. But I thought I'll\\n> mention since we are at the topic.\\n>\\n> What I propose is to use a simple bitmap to represent the tuples. If a tuple\\n> at <block, offset> is dead then the corresponding bit in the bitmap is set.\\n> So clearly the searches through dead tuples are O(1) operations, important\\n> for very large tables and large arrays.\\n>\\n> Challenge really is that a heap page can theoretically have MaxOffsetNumber\\n> of line pointers (or to be precise maximum possible offset number). For a 8K\\n> block, that comes be about 2048. Having so many bits per page is neither\\n> practical nor optimal. But in practice the largest offset on a heap page\\n> should not be significantly greater than MaxHeapTuplesPerPage, which is a\\n> more reasonable value of 291 on my machine. Again, that's with zero sized\\n> tuple and for real life large tables, with much wider tuples, the number may\\n> go down even further.\\n>\\n> So we cap the offsets represented in the bitmap to some realistic value,\\n> computed by looking at page density and then multiplying it by a small\\n> factor (not more than two) to take into account LP_DEAD and LP_REDIRECT line\\n> pointers. That should practically represent majority of the dead tuples in\\n> the table, but we then keep an overflow area to record tuples beyond the\\n> limit set for per page. The search routine will do a direct lookup for\\n> offsets less than the limit and search in the sorted overflow area for\\n> offsets beyond the limit.\\n>\\n> For example, for a table with 60 bytes wide tuple (including 24 byte\\n> header), each page can approximately have 8192/60 = 136 tuples. Say we\\n> provision for 136*2 = 272 bits per page i.e. 34 bytes per page for the\\n> bitmap. First 272 offsets in every page are represented in the bitmap and\\n> anything greater than are in overflow region. On the other hand, the current\\n> representation will need about 16 bytes per page assuming 2% dead tuples, 40\\n> bytes per page assuming 5% dead tuples and 80 bytes assuming 10% dead\\n> tuples. So bitmap will take more space for small tuples or when vacuum is\\n> run very aggressively, both seems unlikely for very large tables. Of course\\n> the calculation does not take into account the space needed by the overflow\\n> area, but I expect that too be small.\\n>\\n> I guess we can make a choice between two representations at the start\\n> looking at various table stats. We can also be smart and change from bitmap\\n> to traditional representation as we scan the table and see many more tuples\\n> in the overflow region than we provisioned for. There will be some\\n> challenges in converting representation mid-way, especially in terms of\\n> memory allocation, but I think those can be sorted out if we think that the\\n> idea has merit.\\n>\\n\\nMaking the vacuum possible to choose between two data representations\\nsounds good.\\nI implemented the patch that changes dead tuple representation to bitmap before.\\nI will measure the performance of bitmap representation again and post them.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 9 Sep 2016 03:10:31 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 11:40 PM, Masahiko Sawada <sawada.mshk@gmail.com>\\nwrote:\\n\\n>\\n>\\n> Making the vacuum possible to choose between two data representations\\n> sounds good.\\n> I implemented the patch that changes dead tuple representation to bitmap\\n> before.\\n> I will measure the performance of bitmap representation again and post\\n> them.\\n\\n\\nSounds great! I haven't seen your patch, but what I would suggest is to\\ncompute page density (D) = relpages/(dead+live tuples) and experiment with\\nbitmap of sizes of D to 2D bits per page. May I also suggest that instead\\nof putting in efforts in implementing the overflow area, just count how\\nmany dead TIDs would fall under overflow area for a given choice of bitmap\\nsize.\\n\\nIt might be a good idea to experiment with different vacuum scale factor,\\nvarying between 2% to 20% (may be 2, 5, 10, 20). You can probably run a\\nlongish pgbench test on a large table and then save the data directory for\\nrepeated experiments, although I'm not sure if pgbench will be a good\\nchoice because HOT will prevent accumulation of dead pointers, in which\\ncase you may try adding another index on abalance column.\\n\\nIt'll be worth measuring memory consumption of both representations as well\\nas performance implications on index vacuum. I don't expect to see any\\nmajor difference in either heap scans.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Thu, Sep 8, 2016 at 11:40 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n\\nMaking the vacuum possible to choose between two data representations\\nsounds good.\\nI implemented the patch that changes dead tuple representation to bitmap before.\\nI will measure the performance of bitmap representation again and post them.Sounds great! I haven't seen your patch, but what I would suggest is to compute page density (D) = relpages/(dead+live tuples) and experiment with bitmap of sizes of D to 2D bits per page. May I also suggest that instead of putting in efforts in implementing the overflow area, just count how many dead TIDs would fall under overflow area for a given choice of bitmap size.It might be a good idea to experiment with different vacuum scale factor, varying between 2% to 20% (may be 2, 5, 10, 20). You can probably run a longish pgbench test on a large table and then save the data directory for repeated experiments, although I'm not sure if pgbench will be a good choice because HOT will prevent accumulation of dead pointers, in which case you may try adding another index on abalance column.It'll be worth measuring memory consumption of both representations as well as performance implications on index vacuum. I don't expect to see any major difference in either heap scans.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Fri, 9 Sep 2016 09:03:56 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 12:33 PM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n> On Thu, Sep 8, 2016 at 11:40 PM, Masahiko Sawada <sawada.mshk@gmail.com>\\n> wrote:\\n>>\\n>>\\n>>\\n>> Making the vacuum possible to choose between two data representations\\n>> sounds good.\\n>> I implemented the patch that changes dead tuple representation to bitmap\\n>> before.\\n>> I will measure the performance of bitmap representation again and post\\n>> them.\\n>\\n>\\n> Sounds great! I haven't seen your patch, but what I would suggest is to\\n> compute page density (D) = relpages/(dead+live tuples) and experiment with\\n> bitmap of sizes of D to 2D bits per page. May I also suggest that instead of\\n> putting in efforts in implementing the overflow area, just count how many\\n> dead TIDs would fall under overflow area for a given choice of bitmap size.\\n>\\n\\nIsn't that formula \\\"page density (D) = (dead+live tuples)/relpages\\\"?\\n\\n> It might be a good idea to experiment with different vacuum scale factor,\\n> varying between 2% to 20% (may be 2, 5, 10, 20). You can probably run a\\n> longish pgbench test on a large table and then save the data directory for\\n> repeated experiments, although I'm not sure if pgbench will be a good choice\\n> because HOT will prevent accumulation of dead pointers, in which case you\\n> may try adding another index on abalance column.\\n\\nThank you, I will experiment with this.\\n\\n>\\n> It'll be worth measuring memory consumption of both representations as well\\n> as performance implications on index vacuum. I don't expect to see any major\\n> difference in either heap scans.\\n>\\n\\nYeah, it would be effective for the index vacuum speed and the number\\nof execution of index vacuum.\\n\\nAttached PoC patch changes the representation of dead tuple locations\\nto the hashmap having tuple bitmap.\\nThe one hashmap entry consists of the block number and the TID bitmap\\nof corresponding block, and the block number is the hash key of\\nhashmap.\\nCurrent implementation of this patch is not smart yet because each\\nhashmap entry allocates the tuple bitmap with fixed\\nsize(LAZY_ALLOC_TUPLES), so each hashentry can store up to\\nLAZY_ALLOC_TUPLES(291 if block size is 8kB) tuples.\\nIn case where one block can store only the several tens tuples, the\\nmost bits are would be waste.\\n\\nAfter improved this patch as you suggested, I will measure performance benefit.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 9 Sep 2016 16:04:15 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 3:04 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> Attached PoC patch changes the representation of dead tuple locations\\n> to the hashmap having tuple bitmap.\\n> The one hashmap entry consists of the block number and the TID bitmap\\n> of corresponding block, and the block number is the hash key of\\n> hashmap.\\n> Current implementation of this patch is not smart yet because each\\n> hashmap entry allocates the tuple bitmap with fixed\\n> size(LAZY_ALLOC_TUPLES), so each hashentry can store up to\\n> LAZY_ALLOC_TUPLES(291 if block size is 8kB) tuples.\\n> In case where one block can store only the several tens tuples, the\\n> most bits are would be waste.\\n>\\n> After improved this patch as you suggested, I will measure performance benefit.\\n\\nWe also need to consider the amount of memory gets used. What I\\nproposed - replacing the array with an array of arrays - would not\\nincrease memory utilization significantly. I don't think it would\\nhave much impact on CPU utilization either. It would require\\nreplacing the call to bsearch() in lazy_heap_reaptid() with an\\nopen-coded implementation of bsearch, or with one bsearch to find the\\nchunk and another to find the TID within the chunk, but that shouldn't\\nbe very expensive. For one thing, if the array chunks are around the\\nsize I proposed (64MB), you've got more than ten million tuples per\\nchunk, so you can't have very many chunks unless your table is both\\nreally large and possessed of quite a bit of dead stuff.\\n\\nNow, if I'm reading it correctly, this patch allocates a 132-byte\\nstructure for every page with at least one dead tuple. In the worst\\ncase where there's just one dead tuple per page, that's a 20x\\nregression in memory usage. Actually, it's more like 40x, because\\nAllocSetAlloc rounds small allocation sizes up to the next-higher\\npower of two, which really stings for a 132-byte allocation, and then\\nadds a 16-byte header to each chunk. But even 20x is clearly not\\ngood. There are going to be lots of real-world cases where this uses\\nway more memory to track the same number of dead tuples, and I'm\\nguessing that benchmarking is going to reveal that it's not faster,\\neither.\\n\\nI think it's probably wrong to worry that an array-of-arrays is going\\nto be meaningfully slower than a single array here. It's basically\\ncosting you some small number of additional memory references per\\ntuple, which I suspect isn't all that relevant for a bulk operation\\nthat does I/O, writes WAL, locks buffers, etc. But if it is relevant,\\nthen I think there are other ways to buy that performance back which\\nare likely to be more memory efficient than converting this to use a\\nhash table. For example, we could keep a bitmap with one bit per K\\npages. If the bit is set, there is at least 1 dead tuple on that\\npage; if clear, there are none. When we see an index tuple, we\\nconsult the bitmap to determine whether we need to search the TID\\nlist. We select K to be the smallest power of 2 such that the bitmap\\nuses less memory than some threshold, perhaps 64kB. Assuming that\\nupdates and deletes to the table have some locality, we should be able\\nto skip a large percentage of the TID searches with a probe into this\\nvery compact bitmap. Note that we can set K = 1 for tables up to 4GB\\nin size, and even a 1TB table only needs K = 256. Odds are very good\\nthat a 1TB table being vacuumed has many 256-page ranges containing no\\ndead tuples at all ... and if this proves to be false and the dead\\ntuples are scattered uniformly throughout the table, then you should\\nprobably be more worried about the fact that you're dumping a bare\\nminimum of 4GB of random I/O on your hapless disk controller than\\nabout how efficient the TID search is.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 13 Sep 2016 14:51:59 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 13, 2016 at 11:51 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> I think it's probably wrong to worry that an array-of-arrays is going\\n> to be meaningfully slower than a single array here. It's basically\\n> costing you some small number of additional memory references per\\n> tuple, which I suspect isn't all that relevant for a bulk operation\\n> that does I/O, writes WAL, locks buffers, etc.\\n\\nThis analysis makes perfect sense to me.\\n\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 13 Sep 2016 11:56:49 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 13, 2016 at 3:51 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Fri, Sep 9, 2016 at 3:04 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> Attached PoC patch changes the representation of dead tuple locations\\n>> to the hashmap having tuple bitmap.\\n>> The one hashmap entry consists of the block number and the TID bitmap\\n>> of corresponding block, and the block number is the hash key of\\n>> hashmap.\\n>> Current implementation of this patch is not smart yet because each\\n>> hashmap entry allocates the tuple bitmap with fixed\\n>> size(LAZY_ALLOC_TUPLES), so each hashentry can store up to\\n>> LAZY_ALLOC_TUPLES(291 if block size is 8kB) tuples.\\n>> In case where one block can store only the several tens tuples, the\\n>> most bits are would be waste.\\n>>\\n>> After improved this patch as you suggested, I will measure performance benefit.\\n>\\n> We also need to consider the amount of memory gets used. What I\\n> proposed - replacing the array with an array of arrays - would not\\n> increase memory utilization significantly. I don't think it would\\n> have much impact on CPU utilization either.\\n\\nI've finished writing that patch, I'm in the process of testing its CPU impact.\\n\\nFirst test seemed to hint at a 40% increase in CPU usage, which seems\\nrather steep compared to what I expected, so I'm trying to rule out\\nsome methodology error here.\\n\\n> It would require\\n> replacing the call to bsearch() in lazy_heap_reaptid() with an\\n> open-coded implementation of bsearch, or with one bsearch to find the\\n> chunk and another to find the TID within the chunk, but that shouldn't\\n> be very expensive.\\n\\nI did a linear search to find the chunk, with exponentially growing\\nchunks, and then a bsearch to find the item inside the chunk.\\n\\nWith the typical number of segments and given the 12GB limit, the\\nsegment array size is well within the range that favors linear search.\\n\\n> For example, we could keep a bitmap with one bit per K\\n> pages. If the bit is set, there is at least 1 dead tuple on that\\n> page; if clear, there are none. When we see an index tuple, we\\n> consult the bitmap to determine whether we need to search the TID\\n> list. We select K to be the smallest power of 2 such that the bitmap\\n> uses less memory than some threshold, perhaps 64kB.\\n\\nI've been pondering something like that, but that's an optimization\\nthat's quite orthogonal to the multiarray stuff.\\n\\n> Assuming that\\n> updates and deletes to the table have some locality, we should be able\\n> to skip a large percentage of the TID searches with a probe into this\\n> very compact bitmap.\\n\\nI don't think you can assume locality\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 13 Sep 2016 15:59:28 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 13, 2016 at 2:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> I've finished writing that patch, I'm in the process of testing its CPU impact.\\n>\\n> First test seemed to hint at a 40% increase in CPU usage, which seems\\n> rather steep compared to what I expected, so I'm trying to rule out\\n> some methodology error here.\\n\\nHmm, wow. That's pretty steep. Maybe lazy_heap_reaptid() is hotter\\nthan I think it is, but even if it accounts for 10% of total CPU usage\\nwithin a vacuum, which seems like an awful lot, you'd have to make it\\n4x as expensive, which also seems like an awful lot.\\n\\n>> It would require\\n>> replacing the call to bsearch() in lazy_heap_reaptid() with an\\n>> open-coded implementation of bsearch, or with one bsearch to find the\\n>> chunk and another to find the TID within the chunk, but that shouldn't\\n>> be very expensive.\\n>\\n> I did a linear search to find the chunk, with exponentially growing\\n> chunks, and then a bsearch to find the item inside the chunk.\\n>\\n> With the typical number of segments and given the 12GB limit, the\\n> segment array size is well within the range that favors linear search.\\n\\nAh, OK.\\n\\n>> For example, we could keep a bitmap with one bit per K\\n>> pages. If the bit is set, there is at least 1 dead tuple on that\\n>> page; if clear, there are none. When we see an index tuple, we\\n>> consult the bitmap to determine whether we need to search the TID\\n>> list. We select K to be the smallest power of 2 such that the bitmap\\n>> uses less memory than some threshold, perhaps 64kB.\\n>\\n> I've been pondering something like that, but that's an optimization\\n> that's quite orthogonal to the multiarray stuff.\\n\\nSure, but if this really does increase CPU time, it'd be reasonable to\\ndo something to decrease it again in order to get the other benefits\\nof this patch - i.e. increasing the maintenance_work_mem limit while\\nreducing the chances that overallocation will cause OOM.\\n\\n>> Assuming that\\n>> updates and deletes to the table have some locality, we should be able\\n>> to skip a large percentage of the TID searches with a probe into this\\n>> very compact bitmap.\\n>\\n> I don't think you can assume locality\\n\\nReally? If you have a 1TB table, how many 2MB ranges of that table do\\nyou think will contain dead tuples for a typical vacuum? I think most\\ntables of that size are going to be mostly static, and the all-visible\\nand all-frozen bits are going to be mostly set. You *could* have\\nsomething like a pgbench-type workload that does scattered updates\\nacross the entire table, but that's going to perform pretty poorly\\nbecause you'll constantly be updating blocks that have to be pulled in\\nfrom disk.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 13 Sep 2016 15:06:03 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 13, 2016 at 4:06 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Tue, Sep 13, 2016 at 2:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> I've finished writing that patch, I'm in the process of testing its CPU impact.\\n>>\\n>> First test seemed to hint at a 40% increase in CPU usage, which seems\\n>> rather steep compared to what I expected, so I'm trying to rule out\\n>> some methodology error here.\\n>\\n> Hmm, wow. That's pretty steep. Maybe lazy_heap_reaptid() is hotter\\n> than I think it is, but even if it accounts for 10% of total CPU usage\\n> within a vacuum, which seems like an awful lot, you'd have to make it\\n> 4x as expensive, which also seems like an awful lot.\\n\\nIIRC perf top reported a combined 45% between layz_heap_reaptid +\\nvac_cmp_itemptr (after patching).\\n\\nvac_cmp_itemptr was around 15% on its own\\n\\nDebug build of couse (I need the assertions and the debug symbols),\\nI'll retest with optimizations once debug tests make sense.\\n\\n>>> For example, we could keep a bitmap with one bit per K\\n>>> pages. If the bit is set, there is at least 1 dead tuple on that\\n>>> page; if clear, there are none. When we see an index tuple, we\\n>>> consult the bitmap to determine whether we need to search the TID\\n>>> list. We select K to be the smallest power of 2 such that the bitmap\\n>>> uses less memory than some threshold, perhaps 64kB.\\n>>\\n>> I've been pondering something like that, but that's an optimization\\n>> that's quite orthogonal to the multiarray stuff.\\n>\\n> Sure, but if this really does increase CPU time, it'd be reasonable to\\n> do something to decrease it again in order to get the other benefits\\n> of this patch - i.e. increasing the maintenance_work_mem limit while\\n> reducing the chances that overallocation will cause OOM.\\n\\nI was hoping it wouldn't regress performance so much. I'd rather\\nmicro-optimize the multiarray implementation until it doesn't and then\\nthink of orthogonal optimizations.\\n\\n>>> Assuming that\\n>>> updates and deletes to the table have some locality, we should be able\\n>>> to skip a large percentage of the TID searches with a probe into this\\n>>> very compact bitmap.\\n>>\\n>> I don't think you can assume locality\\n>\\n> Really? If you have a 1TB table, how many 2MB ranges of that table do\\n> you think will contain dead tuples for a typical vacuum? I think most\\n> tables of that size are going to be mostly static, and the all-visible\\n> and all-frozen bits are going to be mostly set. You *could* have\\n> something like a pgbench-type workload that does scattered updates\\n> across the entire table, but that's going to perform pretty poorly\\n> because you'll constantly be updating blocks that have to be pulled in\\n> from disk.\\n\\nI have a few dozen of those in my biggest database. They do updates\\nand deletes all over the place and, even if they were few, they're\\nscattered almost uniformly.\\n\\nThing is, I think we really need to not worsen that case, which seems\\nrather common (almost any OLTP with a big enough user base, or a K-V\\ntype of table, or TOAST tables).\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 13 Sep 2016 16:31:51 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 12:21 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n> On Fri, Sep 9, 2016 at 3:04 AM, Masahiko Sawada <sawada.mshk@gmail.com>\\n> wrote:\\n> > Attached PoC patch changes the representation of dead tuple locations\\n> > to the hashmap having tuple bitmap.\\n> > The one hashmap entry consists of the block number and the TID bitmap\\n> > of corresponding block, and the block number is the hash key of\\n> > hashmap.\\n> > Current implementation of this patch is not smart yet because each\\n> > hashmap entry allocates the tuple bitmap with fixed\\n> > size(LAZY_ALLOC_TUPLES), so each hashentry can store up to\\n> > LAZY_ALLOC_TUPLES(291 if block size is 8kB) tuples.\\n> > In case where one block can store only the several tens tuples, the\\n> > most bits are would be waste.\\n> >\\n> > After improved this patch as you suggested, I will measure performance\\n> benefit.\\n>\\n>\\n>\\n> Now, if I'm reading it correctly, this patch allocates a 132-byte\\n> structure for every page with at least one dead tuple. In the worst\\n> case where there's just one dead tuple per page, that's a 20x\\n> regression in memory usage. Actually, it's more like 40x, because\\n> AllocSetAlloc rounds small allocation sizes up to the next-higher\\n> power of two, which really stings for a 132-byte allocation, and then\\n> adds a 16-byte header to each chunk. But even 20x is clearly not\\n> good. There are going to be lots of real-world cases where this uses\\n> way more memory to track the same number of dead tuples, and I'm\\n> guessing that benchmarking is going to reveal that it's not faster,\\n> either.\\n>\\n>\\nSawada-san offered to reimplement the patch based on what I proposed\\nupthread. In the new scheme of things, we will allocate a fixed size bitmap\\nof length 2D bits per page where D is average page density of live + dead\\ntuples. (The rational behind multiplying D by a factor of 2 is to consider\\nworst case scenario where every tuple also has a LP_DIRECT line\\npointer). The value of D in most real world, large tables should not go\\nmuch beyond, say 100, assuming 80 bytes wide tuple and 8K blocksize. That\\ntranslates to about 25 bytes/page. So all TIDs with offset less than 2D can\\nbe represented by a single bit. We augment this with an overflow to track\\ntuples which fall outside this limit. I believe this area will be small,\\nsay 10% of the total allocation.\\n\\nThis representation is at least as good the current representation if there\\nare at least 4-5% dead tuples. I don't think very large tables will be\\nvacuumed with a scale factor less than that. And assuming 10% dead tuples,\\nthis representation will actually be much more optimal.\\n\\nThe idea can fail when (a) there are very few dead tuples in the table, say\\nless than 5% or (b) there are large number of tuples falling outside the 2D\\nlimit. While I don't expect any of these to hold for real world, very large\\ntables, (a) we can anticipate when the vacuum starts and use current\\nrepresentation. (b) we can detect at run time and do a one time switch\\nbetween representation. You may argue that managing two representations is\\nclumsy, which I agree, but the code is completely isolated and probably not\\nmore than a few hundred lines.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Wed, Sep 14, 2016 at 12:21 AM, Robert Haas <robertmhaas@gmail.com> wrote:On Fri, Sep 9, 2016 at 3:04 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> Attached PoC patch changes the representation of dead tuple locations\\n> to the hashmap having tuple bitmap.\\n> The one hashmap entry consists of the block number and the TID bitmap\\n> of corresponding block, and the block number is the hash key of\\n> hashmap.\\n> Current implementation of this patch is not smart yet because each\\n> hashmap entry allocates the tuple bitmap with fixed\\n> size(LAZY_ALLOC_TUPLES), so each hashentry can store up to\\n> LAZY_ALLOC_TUPLES(291 if block size is 8kB) tuples.\\n> In case where one block can store only the several tens tuples, the\\n> most bits are would be waste.\\n>\\n> After improved this patch as you suggested, I will measure performance benefit.\\n\\n\\nNow, if I'm reading it correctly, this patch allocates a 132-byte\\nstructure for every page with at least one dead tuple. In the worst\\ncase where there's just one dead tuple per page, that's a 20x\\nregression in memory usage. Actually, it's more like 40x, because\\nAllocSetAlloc rounds small allocation sizes up to the next-higher\\npower of two, which really stings for a 132-byte allocation, and then\\nadds a 16-byte header to each chunk. But even 20x is clearly not\\ngood. There are going to be lots of real-world cases where this uses\\nway more memory to track the same number of dead tuples, and I'm\\nguessing that benchmarking is going to reveal that it's not faster,\\neither.\\nSawada-san offered to reimplement the patch based on what I proposed upthread. In the new scheme of things, we will allocate a fixed size bitmap of length 2D bits per page where D is average page density of live + dead tuples. (The rational behind multiplying D by a factor of 2 is to consider worst case scenario where every tuple also has a LP_DIRECT line pointer). The value of D in most real world, large tables should not go much beyond, say 100, assuming 80 bytes wide tuple and 8K blocksize. That translates to about 25 bytes/page. So all TIDs with offset less than 2D can be represented by a single bit. We augment this with an overflow to track tuples which fall outside this limit. I believe this area will be small, say 10% of the total allocation.This representation is at least as good the current representation if there are at least 4-5% dead tuples. I don't think very large tables will be vacuumed with a scale factor less than that. And assuming 10% dead tuples, this representation will actually be much more optimal.The idea can fail when (a) there are very few dead tuples in the table, say less than 5% or (b) there are large number of tuples falling outside the 2D limit. While I don't expect any of these to hold for real world, very large tables, (a) we can anticipate when the vacuum starts and use current representation. (b) we can detect at run time and do a one time switch between representation. You may argue that managing two representations is clumsy, which I agree, but the code is completely isolated and probably not more than a few hundred lines.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Wed, 14 Sep 2016 08:47:25 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 8:47 AM, Pavan Deolasee <pavan.deolasee@gmail.com>\\nwrote:\\n\\n>\\n>>\\n> Sawada-san offered to reimplement the patch based on what I proposed\\n> upthread. In the new scheme of things, we will allocate a fixed size bitmap\\n> of length 2D bits per page where D is average page density of live + dead\\n> tuples. (The rational behind multiplying D by a factor of 2 is to consider\\n> worst case scenario where every tuple also has a LP_DIRECT line\\n> pointer). The value of D in most real world, large tables should not go\\n> much beyond, say 100, assuming 80 bytes wide tuple and 8K blocksize. That\\n> translates to about 25 bytes/page. So all TIDs with offset less than 2D can\\n> be represented by a single bit. We augment this with an overflow to track\\n> tuples which fall outside this limit. I believe this area will be small,\\n> say 10% of the total allocation.\\n>\\n>\\nSo I cooked up the attached patch to track number of live/dead tuples found\\nat offset 1 to MaxOffsetNumber. The idea was to see how many tuples\\nactually go beyond the threshold of 2D offsets per page. Note that I am\\nproposing to track 2D offsets via bitmap and rest via regular TID array.\\n\\nSo I ran a pgbench test for 2hrs with scale factor 500. autovacuum scale\\nfactor was set to 0.1 or 10%.\\n\\nSome interesting bits:\\n\\npostgres=# select relname, n_tup_ins, n_tup_upd, n_tup_hot_upd, n_live_tup,\\nn_dead_tup, pg_relation_size(relid)/8192 as relsize,\\n(n_live_tup+n_dead_tup)/(pg_relation_size(relid)/8192) as density from\\npg_stat_user_tables ;\\n relname | n_tup_ins | n_tup_upd | n_tup_hot_upd | n_live_tup |\\nn_dead_tup | relsize | density\\n------------------+-----------+-----------+---------------+------------+------------+---------+---------\\n pgbench_tellers | 5000 | 95860289 | 87701578 | 5000 |\\n 0 | 3493 | 1\\n pgbench_branches | 500 | 95860289 | 94158081 | 967 |\\n 0 | 1544 | 0\\n pgbench_accounts | 50000000 | 95860289 | 93062567 | 51911657 |\\n 3617465 | 865635 | 64\\n pgbench_history | 95860289 | 0 | 0 | 95258548 |\\n 0 | 610598 | 156\\n(4 rows)\\n\\nSmaller tellers and branches tables bloat so much that the density as\\ncomputed by live + dead tuples falls close to 1 tuple/page. So for such\\ntables, the idea of 2D bits/page will fail miserably. But I think these\\ntables are worst representatives and I would be extremely surprised if we\\never find very large table bloated so much. But even then, this probably\\ntells us that we can't solely rely on the density measure.\\n\\nAnother interesting bit about these small tables is that the largest used\\noffset for these tables never went beyond 291 which is the value of\\nMaxHeapTuplesPerPage. I don't know if there is something that prevents\\ninserting more than MaxHeapTuplesPerPage offsets per heap page and I don't\\nknow at this point if this gives us upper limit for bits per page (may be\\nit does).\\n\\nFor pgbench_accounts table, the maximum offset used was 121, though bulk of\\nthe used offsets were at the start of the page (see attached graph). Now\\nthe test did not create enough dead tuples to trigger autovacuum on\\npgbench_accounts table. So I ran a manul vacuum at the end. (There are\\nabout 5% dead tuples in the table by the time test finished)\\n\\npostgres=# VACUUM VERBOSE pgbench_accounts ;\\nINFO: vacuuming \\\"public.pgbench_accounts\\\"\\nINFO: scanned index \\\"pgbench_accounts_pkey\\\" to remove 2797722 row versions\\nDETAIL: CPU 0.00s/9.39u sec elapsed 9.39 sec.\\nINFO: \\\"pgbench_accounts\\\": removed 2797722 row versions in 865399 pages\\nDETAIL: CPU 0.10s/7.01u sec elapsed 7.11 sec.\\nINFO: index \\\"pgbench_accounts_pkey\\\" now contains 50000000 row versions in\\n137099 pages\\nDETAIL: 2797722 index row versions were removed.\\n0 index pages have been deleted, 0 are currently reusable.\\nCPU 0.00s/0.00u sec elapsed 0.00 sec.\\nINFO: \\\"pgbench_accounts\\\": found 852487 removable, 50000000 nonremovable\\nrow versions in 865635 out of 865635 pages\\nDETAIL: 0 dead row versions cannot be removed yet.\\nThere were 802256 unused item pointers.\\nSkipped 0 pages due to buffer pins.\\n0 pages are entirely empty.\\nCPU 0.73s/27.20u sec elapsed 27.98 sec.tuple count at each offset\\n(offnum:all_tuples:dead_tuples)\\n\\nFor 2797722 dead line pointers, the current representation would have used\\n2797722 x 6 = 16786332 bytes of memory. The most optimal bitmap would have\\nused 121 bits/page x 865399 pages = 13089159 bytes where as if we had\\nprovisioned 2D bits/page and assuming D = 64 based on the above\\ncalculation, we would have used 13846384 bytes of memory. This is about 18%\\nless than the current representation. Of course, we would have allocated\\nsome space for overflow region, which will make the difference\\nsmaller/negligible. But the bitmaps would be extremely cheap to lookup\\nduring index scans.\\n\\nNow may be I got lucky, may be I did nor run tests long enough (though I\\nbelieve that may have worked in favour of bitmap), may be mostly HOT\\nupdated tables are not good candidate for testing and may be there are\\nsituations where the proposed bitmap representation will fail badly. But\\nthese tests show that the idea is at least worth considering and we can\\nimprove things for at least some workload. The question is can be avoid\\nregression in not-so-good cases.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 14 Sep 2016 15:15:32 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 5:45 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> Another interesting bit about these small tables is that the largest used\\n> offset for these tables never went beyond 291 which is the value of\\n> MaxHeapTuplesPerPage. I don't know if there is something that prevents\\n> inserting more than MaxHeapTuplesPerPage offsets per heap page and I don't\\n> know at this point if this gives us upper limit for bits per page (may be it\\n> does).\\n\\n From PageAddItemExtended:\\n\\n /* Reject placing items beyond heap boundary, if heap */\\n if ((flags & PAI_IS_HEAP) != 0 && offsetNumber > MaxHeapTuplesPerPage)\\n {\\n elog(WARNING, \\\"can't put more than MaxHeapTuplesPerPage items\\nin a heap page\\\");\\n return InvalidOffsetNumber;\\n }\\n\\nAlso see the comment where MaxHeapTuplesPerPage is defined:\\n\\n * Note: with HOT, there could theoretically be more line pointers (not actual\\n * tuples) than this on a heap page. However we constrain the number of line\\n * pointers to this anyway, to avoid excessive line-pointer bloat and not\\n * require increases in the size of work arrays.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 08:02:58 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 5:32 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n> On Wed, Sep 14, 2016 at 5:45 AM, Pavan Deolasee\\n> <pavan.deolasee@gmail.com> wrote:\\n> > Another interesting bit about these small tables is that the largest used\\n> > offset for these tables never went beyond 291 which is the value of\\n> > MaxHeapTuplesPerPage. I don't know if there is something that prevents\\n> > inserting more than MaxHeapTuplesPerPage offsets per heap page and I\\n> don't\\n> > know at this point if this gives us upper limit for bits per page (may\\n> be it\\n> > does).\\n>\\n> From PageAddItemExtended:\\n>\\n> /* Reject placing items beyond heap boundary, if heap */\\n> if ((flags & PAI_IS_HEAP) != 0 && offsetNumber > MaxHeapTuplesPerPage)\\n> {\\n> elog(WARNING, \\\"can't put more than MaxHeapTuplesPerPage items\\n> in a heap page\\\");\\n> return InvalidOffsetNumber;\\n> }\\n>\\n> Also see the comment where MaxHeapTuplesPerPage is defined:\\n>\\n> * Note: with HOT, there could theoretically be more line pointers (not\\n> actual\\n> * tuples) than this on a heap page. However we constrain the number of\\n> line\\n> * pointers to this anyway, to avoid excessive line-pointer bloat and not\\n> * require increases in the size of work arrays.\\n>\\n>\\nAh, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per\\npage bitmap size. Thats about 36 bytes for 8K page. IOW if on an average\\nthere are 6 or more dead tuples per page, bitmap will outperform the\\ncurrent representation, assuming max allocation for bitmap. If we can use\\nadditional estimates to restrict the size to somewhat more conservative\\nvalue and then keep overflow area, then probably the break-even happens\\neven earlier than that. I hope this gives us a good starting point, but let\\nme know if you think it's still a wrong approach to pursue.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Wed, Sep 14, 2016 at 5:32 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Wed, Sep 14, 2016 at 5:45 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> Another interesting bit about these small tables is that the largest used\\n> offset for these tables never went beyond 291 which is the value of\\n> MaxHeapTuplesPerPage. I don't know if there is something that prevents\\n> inserting more than MaxHeapTuplesPerPage offsets per heap page and I don't\\n> know at this point if this gives us upper limit for bits per page (may be it\\n> does).\\n\\nFrom PageAddItemExtended:\\n\\n /* Reject placing items beyond heap boundary, if heap */\\n if ((flags & PAI_IS_HEAP) != 0 && offsetNumber > MaxHeapTuplesPerPage)\\n {\\n elog(WARNING, \\\"can't put more than MaxHeapTuplesPerPage items\\nin a heap page\\\");\\n return InvalidOffsetNumber;\\n }\\n\\nAlso see the comment where MaxHeapTuplesPerPage is defined:\\n\\n * Note: with HOT, there could theoretically be more line pointers (not actual\\n * tuples) than this on a heap page. However we constrain the number of line\\n * pointers to this anyway, to avoid excessive line-pointer bloat and not\\n * require increases in the size of work arrays.\\nAh, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per page bitmap size. Thats about 36 bytes for 8K page. IOW if on an average there are 6 or more dead tuples per page, bitmap will outperform the current representation, assuming max allocation for bitmap. If we can use additional estimates to restrict the size to somewhat more conservative value and then keep overflow area, then probably the break-even happens even earlier than that. I hope this gives us a good starting point, but let me know if you think it's still a wrong approach to pursue.Thanks,Pavan -- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Wed, 14 Sep 2016 17:46:08 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 8:16 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> Ah, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per page\\n> bitmap size. Thats about 36 bytes for 8K page. IOW if on an average there\\n> are 6 or more dead tuples per page, bitmap will outperform the current\\n> representation, assuming max allocation for bitmap. If we can use additional\\n> estimates to restrict the size to somewhat more conservative value and then\\n> keep overflow area, then probably the break-even happens even earlier than\\n> that. I hope this gives us a good starting point, but let me know if you\\n> think it's still a wrong approach to pursue.\\n\\nWell, it's certainly a bigger change. I think the big concern is that\\nthe amount of memory now becomes fixed based on the table size. So\\none problem is that you have to figure out what you're going to do if\\nthe bitmap doesn't fit in maintenance_work_mem. A related problem is\\nthat it might fit but use more memory than before, which could cause\\nproblems for some people. Now on the other hand it could also use\\nless memory for some people, and that would be good.\\n\\nI am kind of doubtful about this whole line of investigation because\\nwe're basically trying pretty hard to fix something that I'm not sure\\nis broken. I do agree that, all other things being equal, the TID\\nlookups will probably be faster with a bitmap than with a binary\\nsearch, but maybe not if the table is large and the number of dead\\nTIDs is small, because cache efficiency is pretty important. But even\\nif it's always faster, does TID lookup speed even really matter to\\noverall VACUUM performance? Claudio's early results suggest that it\\nmight, but maybe that's just a question of some optimization that\\nhasn't been done yet.\\n\\nI'm fairly sure that our number one priority should be to minimize the\\nnumber of cases where we need to do multiple scans of the indexes to\\nstay within maintenance_work_mem. If we're satisfied we've met that\\ngoal, then within that we should try to make VACUUM as fast as\\npossible with as little memory usage as possible. I'm not 100% sure I\\nknow how to get there, or how much work it's worth expending. In\\ntheory we could even start with the list of TIDs and switch to the\\nbitmap if the TID list becomes larger than the bitmap would have been,\\nbut I don't know if it's worth the effort.\\n\\n/me thinks a bit.\\n\\nActually, I think that probably *is* worthwhile, specifically because\\nit might let us avoid multiple index scans in cases where we currently\\nrequire them. Right now, our default maintenance_work_mem value is\\n64MB, which is enough to hold a little over ten million tuples. It's\\nalso large enough to hold a bitmap for a 14GB table. So right now if\\nyou deleted, say, 100 tuples per page you would end up with an index\\nvacuum cycles for every ~100,000 pages = 800MB, whereas switching to\\nthe bitmap representation for such cases would require only one index\\nvacuum cycle for every 14GB, more than an order of magnitude\\nimprovement!\\n\\nOn the other hand, if we switch to the bitmap as the ONLY possible\\nrepresentation, we will lose badly when there are scattered updates -\\ne.g. 1 deleted tuple every 10 pages. So it seems like we probably\\nwant to have both options. One tricky part is figuring out how we\\nswitch between them when memory gets tight; we have to avoid bursting\\nabove our memory limit while making the switch. And even if our\\nmemory limit is very high, we want to avoid using memory gratuitously;\\nI think we should try to grow memory usage incrementally with either\\nrepresentation.\\n\\nFor instance, one idea to grow memory usage incrementally would be to\\nstore dead tuple information separately for each 1GB segment of the\\nrelation. So we have an array of dead-tuple-representation objects,\\none for every 1GB of the relation. If there are no dead tuples in a\\ngiven 1GB segment, then this pointer can just be NULL. Otherwise, it\\ncan point to either the bitmap representation (which will take ~4.5MB)\\nor it can point to an array of TIDs (which will take 6 bytes/TID).\\nThat could handle an awfully wide variety of usage patterns\\nefficiently; it's basically never worse than what we're doing today,\\nand when the dead tuple density is high for any portion of the\\nrelation it's a lot better.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 11:17:48 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>\\n> I am kind of doubtful about this whole line of investigation because\\n> we're basically trying pretty hard to fix something that I'm not sure\\n> is broken. I do agree that, all other things being equal, the TID\\n> lookups will probably be faster with a bitmap than with a binary\\n> search, but maybe not if the table is large and the number of dead\\n> TIDs is small, because cache efficiency is pretty important. But even\\n> if it's always faster, does TID lookup speed even really matter to\\n> overall VACUUM performance? Claudio's early results suggest that it\\n> might, but maybe that's just a question of some optimization that\\n> hasn't been done yet.\\n\\nFYI, the reported impact was on CPU time, not runtime. There was no\\nsignificant difference in runtime (real time), because my test is\\nheavily I/O bound.\\n\\nI tested with a few small tables and there was no significant\\ndifference either, but small tables don't stress the array lookup\\nanyway so that's expected.\\n\\nBut on the assumption that some systems may be CPU bound during vacuum\\n(particularly those able to do more than 300-400MB/s sequential I/O),\\nin those cases the increased or decreased cost of lazy_tid_reaped will\\ndirectly correlate to runtime. It's just none of my systems, which all\\nrun on amazon and is heavily bandwidth constrained (fastest I/O\\nsubsystem I can get my hands on does 200MB/s).\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 12:24:13 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Sep 14, 2016 5:18 PM, \\\"Robert Haas\\\" <robertmhaas@gmail.com> wrote:\\n>\\n> On Wed, Sep 14, 2016 at 8:16 AM, Pavan Deolasee\\n> <pavan.deolasee@gmail.com> wrote:\\n> > Ah, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per\\npage\\n> > bitmap size. Thats about 36 bytes for 8K page. IOW if on an average\\nthere\\n> > are 6 or more dead tuples per page, bitmap will outperform the current\\n> > representation, assuming max allocation for bitmap. If we can use\\nadditional\\n> > estimates to restrict the size to somewhat more conservative value and\\nthen\\n> > keep overflow area, then probably the break-even happens even earlier\\nthan\\n> > that. I hope this gives us a good starting point, but let me know if you\\n> > think it's still a wrong approach to pursue.\\n>\\n> Well, it's certainly a bigger change. I think the big concern is that\\n> the amount of memory now becomes fixed based on the table size. So\\n> one problem is that you have to figure out what you're going to do if\\n> the bitmap doesn't fit in maintenance_work_mem. A related problem is\\n> that it might fit but use more memory than before, which could cause\\n> problems for some people. Now on the other hand it could also use\\n> less memory for some people, and that would be good.\\n>\\n> I am kind of doubtful about this whole line of investigation because\\n> we're basically trying pretty hard to fix something that I'm not sure\\n> is broken. I do agree that, all other things being equal, the TID\\n> lookups will probably be faster with a bitmap than with a binary\\n> search, but maybe not if the table is large and the number of dead\\n> TIDs is small, because cache efficiency is pretty important. But even\\n> if it's always faster, does TID lookup speed even really matter to\\n> overall VACUUM performance? Claudio's early results suggest that it\\n> might, but maybe that's just a question of some optimization that\\n> hasn't been done yet.\\n>\\n> I'm fairly sure that our number one priority should be to minimize the\\n> number of cases where we need to do multiple scans of the indexes to\\n> stay within maintenance_work_mem. If we're satisfied we've met that\\n> goal, then within that we should try to make VACUUM as fast as\\n> possible with as little memory usage as possible. I'm not 100% sure I\\n> know how to get there, or how much work it's worth expending. In\\n> theory we could even start with the list of TIDs and switch to the\\n> bitmap if the TID list becomes larger than the bitmap would have been,\\n> but I don't know if it's worth the effort.\\n>\\n> /me thinks a bit.\\n>\\n> Actually, I think that probably *is* worthwhile, specifically because\\n> it might let us avoid multiple index scans in cases where we currently\\n> require them. Right now, our default maintenance_work_mem value is\\n> 64MB, which is enough to hold a little over ten million tuples. It's\\n> also large enough to hold a bitmap for a 14GB table. So right now if\\n> you deleted, say, 100 tuples per page you would end up with an index\\n> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\\n> the bitmap representation for such cases would require only one index\\n> vacuum cycle for every 14GB, more than an order of magnitude\\n> improvement!\\n>\\n> On the other hand, if we switch to the bitmap as the ONLY possible\\n> representation, we will lose badly when there are scattered updates -\\n> e.g. 1 deleted tuple every 10 pages. So it seems like we probably\\n> want to have both options. One tricky part is figuring out how we\\n> switch between them when memory gets tight; we have to avoid bursting\\n> above our memory limit while making the switch. And even if our\\n> memory limit is very high, we want to avoid using memory gratuitously;\\n> I think we should try to grow memory usage incrementally with either\\n> representation.\\n>\\n> For instance, one idea to grow memory usage incrementally would be to\\n> store dead tuple information separately for each 1GB segment of the\\n> relation. So we have an array of dead-tuple-representation objects,\\n> one for every 1GB of the relation. If there are no dead tuples in a\\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\\n> can point to either the bitmap representation (which will take ~4.5MB)\\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\\n> That could handle an awfully wide variety of usage patterns\\n> efficiently; it's basically never worse than what we're doing today,\\n> and when the dead tuple density is high for any portion of the\\n> relation it's a lot better.\\n>\\n> --\\n> Robert Haas\\n> EnterpriseDB: http://www.enterprisedb.com\\n> The Enterprise PostgreSQL Company\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\n\\nI'd say it's an idea worth pursuing. It's the base idea behind roaring\\nbitmaps, arguably the best overall compressed bitmap implementation.\\n\\n\\nOn Sep 14, 2016 5:18 PM, \\\"Robert Haas\\\" <robertmhaas@gmail.com> wrote:\\n>\\n> On Wed, Sep 14, 2016 at 8:16 AM, Pavan Deolasee\\n> <pavan.deolasee@gmail.com> wrote:\\n> > Ah, thanks. So MaxHeapTuplesPerPage sets the upper boundary for the per page\\n> > bitmap size. Thats about 36 bytes for 8K page. IOW if on an average there\\n> > are 6 or more dead tuples per page, bitmap will outperform the current\\n> > representation, assuming max allocation for bitmap. If we can use additional\\n> > estimates to restrict the size to somewhat more conservative value and then\\n> > keep overflow area, then probably the break-even happens even earlier than\\n> > that. I hope this gives us a good starting point, but let me know if you\\n> > think it's still a wrong approach to pursue.\\n>\\n> Well, it's certainly a bigger change. I think the big concern is that\\n> the amount of memory now becomes fixed based on the table size. So\\n> one problem is that you have to figure out what you're going to do if\\n> the bitmap doesn't fit in maintenance_work_mem. A related problem is\\n> that it might fit but use more memory than before, which could cause\\n> problems for some people. Now on the other hand it could also use\\n> less memory for some people, and that would be good.\\n>\\n> I am kind of doubtful about this whole line of investigation because\\n> we're basically trying pretty hard to fix something that I'm not sure\\n> is broken. I do agree that, all other things being equal, the TID\\n> lookups will probably be faster with a bitmap than with a binary\\n> search, but maybe not if the table is large and the number of dead\\n> TIDs is small, because cache efficiency is pretty important. But even\\n> if it's always faster, does TID lookup speed even really matter to\\n> overall VACUUM performance? Claudio's early results suggest that it\\n> might, but maybe that's just a question of some optimization that\\n> hasn't been done yet.\\n>\\n> I'm fairly sure that our number one priority should be to minimize the\\n> number of cases where we need to do multiple scans of the indexes to\\n> stay within maintenance_work_mem. If we're satisfied we've met that\\n> goal, then within that we should try to make VACUUM as fast as\\n> possible with as little memory usage as possible. I'm not 100% sure I\\n> know how to get there, or how much work it's worth expending. In\\n> theory we could even start with the list of TIDs and switch to the\\n> bitmap if the TID list becomes larger than the bitmap would have been,\\n> but I don't know if it's worth the effort.\\n>\\n> /me thinks a bit.\\n>\\n> Actually, I think that probably *is* worthwhile, specifically because\\n> it might let us avoid multiple index scans in cases where we currently\\n> require them. Right now, our default maintenance_work_mem value is\\n> 64MB, which is enough to hold a little over ten million tuples. It's\\n> also large enough to hold a bitmap for a 14GB table. So right now if\\n> you deleted, say, 100 tuples per page you would end up with an index\\n> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\\n> the bitmap representation for such cases would require only one index\\n> vacuum cycle for every 14GB, more than an order of magnitude\\n> improvement!\\n>\\n> On the other hand, if we switch to the bitmap as the ONLY possible\\n> representation, we will lose badly when there are scattered updates -\\n> e.g. 1 deleted tuple every 10 pages. So it seems like we probably\\n> want to have both options. One tricky part is figuring out how we\\n> switch between them when memory gets tight; we have to avoid bursting\\n> above our memory limit while making the switch. And even if our\\n> memory limit is very high, we want to avoid using memory gratuitously;\\n> I think we should try to grow memory usage incrementally with either\\n> representation.\\n>\\n> For instance, one idea to grow memory usage incrementally would be to\\n> store dead tuple information separately for each 1GB segment of the\\n> relation. So we have an array of dead-tuple-representation objects,\\n> one for every 1GB of the relation. If there are no dead tuples in a\\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\\n> can point to either the bitmap representation (which will take ~4.5MB)\\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\\n> That could handle an awfully wide variety of usage patterns\\n> efficiently; it's basically never worse than what we're doing today,\\n> and when the dead tuple density is high for any portion of the\\n> relation it's a lot better.\\n>\\n> --\\n> Robert Haas\\n> EnterpriseDB: http://www.enterprisedb.com\\n> The Enterprise PostgreSQL Company\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\nI'd say it's an idea worth pursuing. It's the base idea behind roaring bitmaps, arguably the best overall compressed bitmap implementation.\",\n \"msg_date\": \"Wed, 14 Sep 2016 17:59:16 +0200\",\n \"msg_from\": \"Arthur Silva <arthurprs@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 8:47 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n>\\n>\\n> I am kind of doubtful about this whole line of investigation because\\n> we're basically trying pretty hard to fix something that I'm not sure\\n> is broken. I do agree that, all other things being equal, the TID\\n> lookups will probably be faster with a bitmap than with a binary\\n> search, but maybe not if the table is large and the number of dead\\n> TIDs is small, because cache efficiency is pretty important. But even\\n> if it's always faster, does TID lookup speed even really matter to\\n> overall VACUUM performance? Claudio's early results suggest that it\\n> might, but maybe that's just a question of some optimization that\\n> hasn't been done yet.\\n\\n\\nYeah, I wouldn't worry only about lookup speedup, but if does speeds up,\\nthat's a bonus. But the bitmaps seem to win even for memory consumption. As\\ntheory and experiments both show, at 10% dead tuple ratio, bitmaps will win\\nhandsomely.\\n\\n In\\n> theory we could even start with the list of TIDs and switch to the\\n> bitmap if the TID list becomes larger than the bitmap would have been,\\n> but I don't know if it's worth the effort.\\n>\\n>\\nYes, that works too. Or may be even better because we already know the\\nbitmap size requirements, definitely for the tuples collected so far. We\\nmight need to maintain some more stats to further optimise the\\nrepresentation, but that seems like unnecessary detailing at this point.\\n\\n\\n>\\n> On the other hand, if we switch to the bitmap as the ONLY possible\\n> representation, we will lose badly when there are scattered updates -\\n> e.g. 1 deleted tuple every 10 pages.\\n\\n\\nSure. I never suggested that. What I'd suggested is to switch back to array\\nrepresentation once we realise bitmaps are not going to work. But I see\\nit's probably better the other way round.\\n\\n\\n\\n> So it seems like we probably\\n> want to have both options. One tricky part is figuring out how we\\n> switch between them when memory gets tight; we have to avoid bursting\\n> above our memory limit while making the switch.\\n\\n\\nYes, I was thinking about this problem. Some modelling will be necessary to\\nensure that we don't go (much) beyond the maintenance_work_mem while\\nswitching representation, which probably means you need to do that earlier\\nthan necessary.\\n\\n\\n> For instance, one idea to grow memory usage incrementally would be to\\n> store dead tuple information separately for each 1GB segment of the\\n> relation. So we have an array of dead-tuple-representation objects,\\n> one for every 1GB of the relation. If there are no dead tuples in a\\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\\n> can point to either the bitmap representation (which will take ~4.5MB)\\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\\n> That could handle an awfully wide variety of usage patterns\\n> efficiently; it's basically never worse than what we're doing today,\\n> and when the dead tuple density is high for any portion of the\\n> relation it's a lot better.\\n>\\n>\\nYes seems like a good idea. Another idea that I'd in mind is to use some\\nsort of indirection map where bitmap for every block or a set of blocks\\nwill either be recorded or not, depending on whether a bit is set for the\\nrange. If the bitmap exists, the indirection map will give out the offset\\ninto the larger bitmap area. Seems similar to what you described.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Wed, Sep 14, 2016 at 8:47 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\nI am kind of doubtful about this whole line of investigation because\\nwe're basically trying pretty hard to fix something that I'm not sure\\nis broken. I do agree that, all other things being equal, the TID\\nlookups will probably be faster with a bitmap than with a binary\\nsearch, but maybe not if the table is large and the number of dead\\nTIDs is small, because cache efficiency is pretty important. But even\\nif it's always faster, does TID lookup speed even really matter to\\noverall VACUUM performance? Claudio's early results suggest that it\\nmight, but maybe that's just a question of some optimization that\\nhasn't been done yet. Yeah, I wouldn't worry only about lookup speedup, but if does speeds up, that's a bonus. But the bitmaps seem to win even for memory consumption. As theory and experiments both show, at 10% dead tuple ratio, bitmaps will win handsomely. In\\ntheory we could even start with the list of TIDs and switch to the\\nbitmap if the TID list becomes larger than the bitmap would have been,\\nbut I don't know if it's worth the effort.\\nYes, that works too. Or may be even better because we already know the bitmap size requirements, definitely for the tuples collected so far. We might need to maintain some more stats to further optimise the representation, but that seems like unnecessary detailing at this point. \\n\\nOn the other hand, if we switch to the bitmap as the ONLY possible\\nrepresentation, we will lose badly when there are scattered updates -\\ne.g. 1 deleted tuple every 10 pages. Sure. I never suggested that. What I'd suggested is to switch back to array representation once we realise bitmaps are not going to work. But I see it's probably better the other way round. So it seems like we probably\\nwant to have both options. One tricky part is figuring out how we\\nswitch between them when memory gets tight; we have to avoid bursting\\nabove our memory limit while making the switch.Yes, I was thinking about this problem. Some modelling will be necessary to ensure that we don't go (much) beyond the maintenance_work_mem while switching representation, which probably means you need to do that earlier than necessary. For instance, one idea to grow memory usage incrementally would be to\\nstore dead tuple information separately for each 1GB segment of the\\nrelation. So we have an array of dead-tuple-representation objects,\\none for every 1GB of the relation. If there are no dead tuples in a\\ngiven 1GB segment, then this pointer can just be NULL. Otherwise, it\\ncan point to either the bitmap representation (which will take ~4.5MB)\\nor it can point to an array of TIDs (which will take 6 bytes/TID).\\nThat could handle an awfully wide variety of usage patterns\\nefficiently; it's basically never worse than what we're doing today,\\nand when the dead tuple density is high for any portion of the\\nrelation it's a lot better.\\n\\nYes seems like a good idea. Another idea that I'd in mind is to use some sort of indirection map where bitmap for every block or a set of blocks will either be recorded or not, depending on whether a bit is set for the range. If the bitmap exists, the indirection map will give out the offset into the larger bitmap area. Seems similar to what you described.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Wed, 14 Sep 2016 21:49:43 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> For instance, one idea to grow memory usage incrementally would be to\\n> store dead tuple information separately for each 1GB segment of the\\n> relation. So we have an array of dead-tuple-representation objects,\\n> one for every 1GB of the relation. If there are no dead tuples in a\\n> given 1GB segment, then this pointer can just be NULL. Otherwise, it\\n> can point to either the bitmap representation (which will take ~4.5MB)\\n> or it can point to an array of TIDs (which will take 6 bytes/TID).\\n> That could handle an awfully wide variety of usage patterns\\n> efficiently; it's basically never worse than what we're doing today,\\n> and when the dead tuple density is high for any portion of the\\n> relation it's a lot better.\\n\\nIf you compress the list into a bitmap a posteriori, you know the\\nnumber of tuples per page, so you could encode the bitmap even more\\nefficiently.\\n\\nIt's not a bad idea, one that can be slapped on top of the multiarray\\npatch - when closing a segment, it can be decided whether to turn it\\ninto a bitmap or not.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 13:42:38 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Robert Haas wrote:\\n\\n> Actually, I think that probably *is* worthwhile, specifically because\\n> it might let us avoid multiple index scans in cases where we currently\\n> require them. Right now, our default maintenance_work_mem value is\\n> 64MB, which is enough to hold a little over ten million tuples. It's\\n> also large enough to hold a bitmap for a 14GB table. So right now if\\n> you deleted, say, 100 tuples per page you would end up with an index\\n> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\\n> the bitmap representation for such cases would require only one index\\n> vacuum cycle for every 14GB, more than an order of magnitude\\n> improvement!\\n\\nYeah, this sounds worthwhile. If we switch to the more compact\\nin-memory representation close to the point where we figure the TID\\narray is not going to fit in m_w_m, then we're saving some number of\\nadditional index scans, and I'm pretty sure that the time to transform\\nfrom array to bitmap is going to be more than paid back by the I/O\\nsavings.\\n\\nOne thing not quite clear to me is how do we create the bitmap\\nrepresentation starting from the array representation in midflight\\nwithout using twice as much memory transiently. Are we going to write\\nthe array to a temp file, free the array memory, then fill the bitmap by\\nreading the array from disk?\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 14:23:54 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 14 September 2016 at 11:19, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n\\n>> In\\n>> theory we could even start with the list of TIDs and switch to the\\n>> bitmap if the TID list becomes larger than the bitmap would have been,\\n>> but I don't know if it's worth the effort.\\n>>\\n>\\n> Yes, that works too. Or may be even better because we already know the\\n> bitmap size requirements, definitely for the tuples collected so far. We\\n> might need to maintain some more stats to further optimise the\\n> representation, but that seems like unnecessary detailing at this point.\\n\\nThat sounds best to me... build the simple representation, but as we\\ndo maintain stats to show to what extent that set of tuples is\\ncompressible.\\n\\nWhen we hit the limit on memory we can then selectively compress\\nchunks to stay within memory, starting with the most compressible\\nchunks.\\n\\nI think we should use the chunking approach Robert suggests, though\\nmainly because that allows us to consider how parallel VACUUM should\\nwork - writing the chunks to shmem. That would also allow us to apply\\na single global limit for vacuum memory rather than an allocation per\\nVACUUM.\\nWe can then scan multiple indexes at once in parallel, all accessing\\nthe shmem data structure.\\n\\nWe should also find the compression is better when we consider chunks\\nrather than the whole data structure at once.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 12:40:00 -0500\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\\nwrote:\\n\\n>\\n>\\n> One thing not quite clear to me is how do we create the bitmap\\n> representation starting from the array representation in midflight\\n> without using twice as much memory transiently. Are we going to write\\n> the array to a temp file, free the array memory, then fill the bitmap by\\n> reading the array from disk?\\n>\\n\\nWe could do that. Or may be compress TID array when consumed half m_w_m and\\ndo this repeatedly with remaining memory. For example, if we start with 1GB\\nmemory, we decide to compress at 512MB. Say that results in 300MB for\\nbitmap. We then continue to accumulate TID and do another round of fold up\\nwhen another 350MB is consumed.\\n\\nI think we should maintain per offset count of number of dead tuples to\\nchoose the most optimal bitmap size (that needs overflow region). We can\\nalso track how many blocks or block ranges have at least one dead tuple to\\nknow if it's worthwhile to have some sort of indirection. Together that can\\ntell us how much compression can be achieved and allow us to choose the\\nmost optimal representation.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com> wrote:\\n\\nOne thing not quite clear to me is how do we create the bitmap\\nrepresentation starting from the array representation in midflight\\nwithout using twice as much memory transiently. Are we going to write\\nthe array to a temp file, free the array memory, then fill the bitmap by\\nreading the array from disk?We could do that. Or may be compress TID array when consumed half m_w_m and do this repeatedly with remaining memory. For example, if we start with 1GB memory, we decide to compress at 512MB. Say that results in 300MB for bitmap. We then continue to accumulate TID and do another round of fold up when another 350MB is consumed.I think we should maintain per offset count of number of dead tuples to choose the most optimal bitmap size (that needs overflow region). We can also track how many blocks or block ranges have at least one dead tuple to know if it's worthwhile to have some sort of indirection. Together that can tell us how much compression can be achieved and allow us to choose the most optimal representation.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Wed, 14 Sep 2016 23:10:09 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Pavan Deolasee <pavan.deolasee@gmail.com> writes:\\n> On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\\n> wrote:\\n>> One thing not quite clear to me is how do we create the bitmap\\n>> representation starting from the array representation in midflight\\n>> without using twice as much memory transiently. Are we going to write\\n>> the array to a temp file, free the array memory, then fill the bitmap by\\n>> reading the array from disk?\\n\\n> We could do that.\\n\\nPeople who are vacuuming because they are out of disk space will be very\\nvery unhappy with that solution.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 13:57:42 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 1:23 PM, Alvaro Herrera\\n<alvherre@2ndquadrant.com> wrote:\\n> Robert Haas wrote:\\n>> Actually, I think that probably *is* worthwhile, specifically because\\n>> it might let us avoid multiple index scans in cases where we currently\\n>> require them. Right now, our default maintenance_work_mem value is\\n>> 64MB, which is enough to hold a little over ten million tuples. It's\\n>> also large enough to hold a bitmap for a 14GB table. So right now if\\n>> you deleted, say, 100 tuples per page you would end up with an index\\n>> vacuum cycles for every ~100,000 pages = 800MB, whereas switching to\\n>> the bitmap representation for such cases would require only one index\\n>> vacuum cycle for every 14GB, more than an order of magnitude\\n>> improvement!\\n>\\n> Yeah, this sounds worthwhile. If we switch to the more compact\\n> in-memory representation close to the point where we figure the TID\\n> array is not going to fit in m_w_m, then we're saving some number of\\n> additional index scans, and I'm pretty sure that the time to transform\\n> from array to bitmap is going to be more than paid back by the I/O\\n> savings.\\n\\nYes, that seems pretty clear. The indexes can be arbitrarily large\\nand there can be arbitrarily many of them, so we could be save a LOT\\nof I/O.\\n\\n> One thing not quite clear to me is how do we create the bitmap\\n> representation starting from the array representation in midflight\\n> without using twice as much memory transiently. Are we going to write\\n> the array to a temp file, free the array memory, then fill the bitmap by\\n> reading the array from disk?\\n\\nI was just thinking about this exact problem while I was out to\\nlunch.[1] I wonder if we could do something like this:\\n\\n1. Allocate an array large enough for one pointer per gigabyte of the\\nunderlying relation.\\n\\n2. Allocate 64MB, or the remaining amount of maintenance_work_mem if\\nit's less, to store TIDs.\\n\\n3. At the beginning of each 1GB chunk, add a pointer to the first free\\nbyte in the slab allocated in step 2 to the array allocated in step 1.\\nWrite a header word that identifies this as a TID list (rather than a\\nbitmap) and leave space for a TID count; then, write the TIDs\\nafterwards. Continue doing this until one of the following things\\nhappens: (a) we reach the end of the 1GB chunk - if that happens,\\nrestart step 3 for the next chunk; (b) we fill the chunk - see step 4,\\nor (c) we write more TIDs for the chunk than the space being used for\\nTIDs now exceeds the space needed for a bitmap - see step 5.\\n\\n4. When we fill up one of the slabs allocated in step 2, allocate a\\nnew one and move the tuples for the current 1GB chunk to the beginning\\nof the new slab using memmove(). This is wasteful of both CPU time\\nand memory, but I think it's not that bad. The maximum possible waste\\nis less than 10%, and many allocators have more overhead than that.\\nWe could reduce the waste by using, say, 256MB chunks rather than 1GB\\nchunks. If no new slab can be allocated because maintenance_work_mem\\nis completely exhausted (or the remaining space isn't enough for the\\nTIDs that would need to be moved immediately), then stop and do an\\nindex vacuum cycle.\\n\\n5. When we write a large enough number of TIDs for 1GB chunk that the\\nbitmap would be smaller, check whether sufficient maintenance_work_mem\\nremains to allocate a bitmap for 1GB chunk (~4.5MB). If not, never\\nmind; continue with step 3 as if the bitmap representation did not\\nexist. If so, allocate space for a bitmap, move all of the TIDs for\\nthe current chunk into it, and update the array allocated in step 1 to\\npoint to it. Then, finish scanning the current 1GB chunk, updating\\nthat bitmap rather than inserting TIDs into the slab. Rewind our\\npointer into the slab to where it was at the beginning of the current\\n1GB chunk, so that the memory we consumed for TIDs can be reused now\\nthat those TIDs have been transferred to a bitmap. If, earlier in the\\ncurrent 1GB chunk, we did a memmove-to-next-slab operation as\\ndescribed in step 4, this \\\"rewind\\\" might move our pointer back into\\nthe previous slab, in which case we can free the now-empty slab. (The\\nnext 1GB segment might have few enough TIDs that they will fit into\\nthe leftover space in the previous slab.)\\n\\nWith this algorithm, we never exceed maintenance_work_mem, not even\\ntransiently. When memory is no longer sufficient to convert to the\\nbitmap representation without bursting above maintenance_work_mem, we\\nsimply don't perform the conversion. Also, we do very little memory\\ncopying. An alternative I considered was to do a separate allocation\\nfor each 1GB chunk rather than carving the dead-tuple space out of\\nslabs. But the problem with that is that you'll have to start those\\nout small (in case you don't find many dead tuples) and then grow\\nthem, which means reallocating, which is bad both because it can burst\\nabove maintenance_work_mem while the repalloc is in process and also\\nbecause you have to keep copying the data from the old chunk to the\\nnew, bigger chunk. This algorithm only needs to copy TIDs when it\\nruns off the end of a chunk, and that can't happen more than once\\nevery dozen or so chunks; in contrast, progressively growing the TID\\narrays for a given 1GB chunk would potentially memcpy() multiple times\\nper 1GB chunk, and if you used power-of-two reallocation as we\\nnormally do the waste would be much more than what step 4 of this\\nalgorithm leaves on the table.\\n\\nThere are, nevertheless, corner cases where this can lose: if you had\\na number of TIDs that were going to just BARELY fit within\\nmaintenance_work_mem, and if the bitmap representation never wins for\\nyou, the additional array allocated in step 1 and the end-of-slab\\nwastage in step 4 could push you over the line. We might be able to\\ntweak things here or there to reduce the potential for that, but it's\\npretty well unavoidable; the flat array we're using right now has\\nexactly zero allocator overhead, and anything more complex will have\\nsome.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n[1] Or am I always out to lunch?\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 14 Sep 2016 14:10:05 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 2:40 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 14 September 2016 at 11:19, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n>\\n>>> In\\n>>> theory we could even start with the list of TIDs and switch to the\\n>>> bitmap if the TID list becomes larger than the bitmap would have been,\\n>>> but I don't know if it's worth the effort.\\n>>>\\n>>\\n>> Yes, that works too. Or may be even better because we already know the\\n>> bitmap size requirements, definitely for the tuples collected so far. We\\n>> might need to maintain some more stats to further optimise the\\n>> representation, but that seems like unnecessary detailing at this point.\\n>\\n> That sounds best to me... build the simple representation, but as we\\n> do maintain stats to show to what extent that set of tuples is\\n> compressible.\\n>\\n> When we hit the limit on memory we can then selectively compress\\n> chunks to stay within memory, starting with the most compressible\\n> chunks.\\n>\\n> I think we should use the chunking approach Robert suggests, though\\n> mainly because that allows us to consider how parallel VACUUM should\\n> work - writing the chunks to shmem. That would also allow us to apply\\n> a single global limit for vacuum memory rather than an allocation per\\n> VACUUM.\\n> We can then scan multiple indexes at once in parallel, all accessing\\n> the shmem data structure.\\n>\\n\\nYeah, the chunking approach Robert suggested seems like a good idea\\nbut considering implementing parallel vacuum, it would be more\\ncomplicated IMO.\\nI think It's better the multiple process simply allocate memory space\\nfor its process than that the single process allocate huge memory\\nspace using complicated way.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 16 Sep 2016 00:19:05 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 09/14/2016 07:57 PM, Tom Lane wrote:\\n> Pavan Deolasee <pavan.deolasee@gmail.com> writes:\\n>> On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\\n>> wrote:\\n>>> One thing not quite clear to me is how do we create the bitmap\\n>>> representation starting from the array representation in midflight\\n>>> without using twice as much memory transiently. Are we going to write\\n>>> the array to a temp file, free the array memory, then fill the bitmap by\\n>>> reading the array from disk?\\n>\\n>> We could do that.\\n>\\n> People who are vacuuming because they are out of disk space will be very\\n> very unhappy with that solution.\\n\\nThe people are usually running out of space for data, while these files \\nwould be temporary files placed wherever temp_tablespaces points to. I'd \\nargue if this is a source of problems, the people are already in deep \\ntrouble due to sorts, CREATE INDEX, ... as those commands may also \\ngenerate a lot of temporary files.\\n\\nregards\\nTomas\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 17:50:28 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 09/14/2016 05:17 PM, Robert Haas wrote:\\n> I am kind of doubtful about this whole line of investigation because\\n> we're basically trying pretty hard to fix something that I'm not sure\\n> is broken. I do agree that, all other things being equal, the TID\\n> lookups will probably be faster with a bitmap than with a binary\\n> search, but maybe not if the table is large and the number of dead\\n> TIDs is small, because cache efficiency is pretty important. But even\\n> if it's always faster, does TID lookup speed even really matter to\\n> overall VACUUM performance? Claudio's early results suggest that it\\n> might, but maybe that's just a question of some optimization that\\n> hasn't been done yet.\\n\\nRegarding the lookup performance, I don't think the bitmap alone can \\nsignificantly improve that - it's more efficient memory-wise, no doubt \\nabout that, but it's still likely larger than CPU caches and accessed \\nmostly randomly (when vacuuming the indexes).\\n\\nIMHO the best way to speed-up lookups (if it's really an issue, haven't \\ndone any benchmarks) would be to build a small bloom filter in front of \\nthe TID array / bitmap. It shall be fairly small (depending on the \\nnumber of TIDs, error rate etc.) and likely to fit into L2/L3, and \\neliminate a lot of probes into the much larger array/bitmap.\\n\\nOf course, it's another layer of complexity - the good thing is we don't \\nneed to build the filter until after we collect the TIDs, so we got \\npretty good inputs for the bloom filter parameters.\\n\\nBut all this is based on the assumption that the lookups are actually \\nexpensive, not sure about that.\\n\\nregards\\nTomas\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 18:04:25 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 12:50 PM, Tomas Vondra\\n<tomas.vondra@2ndquadrant.com> wrote:\\n> On 09/14/2016 07:57 PM, Tom Lane wrote:\\n>>\\n>> Pavan Deolasee <pavan.deolasee@gmail.com> writes:\\n>>>\\n>>> On Wed, Sep 14, 2016 at 10:53 PM, Alvaro Herrera\\n>>> <alvherre@2ndquadrant.com>\\n>>> wrote:\\n>>>>\\n>>>> One thing not quite clear to me is how do we create the bitmap\\n>>>> representation starting from the array representation in midflight\\n>>>> without using twice as much memory transiently. Are we going to write\\n>>>> the array to a temp file, free the array memory, then fill the bitmap by\\n>>>> reading the array from disk?\\n>>\\n>>\\n>>> We could do that.\\n>>\\n>>\\n>> People who are vacuuming because they are out of disk space will be very\\n>> very unhappy with that solution.\\n>\\n>\\n> The people are usually running out of space for data, while these files\\n> would be temporary files placed wherever temp_tablespaces points to. I'd\\n> argue if this is a source of problems, the people are already in deep\\n> trouble due to sorts, CREATE INDEX, ... as those commands may also generate\\n> a lot of temporary files.\\n\\nOne would not expect \\\"CREATE INDEX\\\" to succeed when space is tight,\\nbut VACUUM is quite the opposite.\\n\\nStill, temporary storage could be used if available, and gracefully\\nfall back to some other technique (like not using bitmaps) when not.\\n\\nNot sure it's worth the trouble, though.\\n\\n\\nOn Wed, Sep 14, 2016 at 12:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>\\n>> I am kind of doubtful about this whole line of investigation because\\n>> we're basically trying pretty hard to fix something that I'm not sure\\n>> is broken. I do agree that, all other things being equal, the TID\\n>> lookups will probably be faster with a bitmap than with a binary\\n>> search, but maybe not if the table is large and the number of dead\\n>> TIDs is small, because cache efficiency is pretty important. But even\\n>> if it's always faster, does TID lookup speed even really matter to\\n>> overall VACUUM performance? Claudio's early results suggest that it\\n>> might, but maybe that's just a question of some optimization that\\n>> hasn't been done yet.\\n>\\n> FYI, the reported impact was on CPU time, not runtime. There was no\\n> significant difference in runtime (real time), because my test is\\n> heavily I/O bound.\\n>\\n> I tested with a few small tables and there was no significant\\n> difference either, but small tables don't stress the array lookup\\n> anyway so that's expected.\\n>\\n> But on the assumption that some systems may be CPU bound during vacuum\\n> (particularly those able to do more than 300-400MB/s sequential I/O),\\n> in those cases the increased or decreased cost of lazy_tid_reaped will\\n> directly correlate to runtime. It's just none of my systems, which all\\n> run on amazon and is heavily bandwidth constrained (fastest I/O\\n> subsystem I can get my hands on does 200MB/s).\\n\\nAttached is the patch with the multiarray version.\\n\\nThe tests are weird. Best case comparison over several runs, to remove\\nthe impact of concurrent activity on this host (I couldn't remove all\\nbackground activity even when running the tests overnight, the distro\\nadds tons of crons and background cleanup tasks it would seem),\\nthere's only very mild CPU impact. I'd say insignificant, as it's well\\nbelow the mean variance.\\n\\nWorst case:\\n\\nDETAIL: CPU 9.90s/80.94u sec elapsed 1232.42 sec.\\n\\nBest case:\\n\\nDETAIL: CPU 12.10s/63.82u sec elapsed 832.79 sec.\\n\\nThere seems to be more variance with the multiarray approach than the\\nsingle array one, but I could not figure out why. Even I/O seems less\\nstable:\\n\\nWorst case:\\n\\nINFO: \\\"pgbench_accounts\\\": removed 400000000 row versions in 6557382 pages\\nDETAIL: CPU 64.31s/37.60u sec elapsed 2573.88 sec.\\n\\nBest case:\\n\\nINFO: \\\"pgbench_accounts\\\": removed 400000000 row versions in 6557378 pages\\nDETAIL: CPU 54.48s/31.78u sec elapsed 1552.18 sec.\\n\\nSince this test takes several hours to complete, I could only run a\\nfew runs of each version, so the statistical significance of the test\\nisn't very bright.\\n\\nI'll try to compare with smaller pgbench scale numbers and more runs\\nover the weekend (gotta script that). It's certainly puzzling, I\\ncannot explain the increased variance, especially in I/O, since the\\nI/O should be exactly the same. I'm betting it's my system that's\\nunpredictable somehow. So I'm posting the patch in case someone gets\\ninspired and can spot the reason, and because there's been a lot of\\ntalk about this very same approach, so I thought I'd better post the\\ncode ;)\\n\\nI'll also try to get a more predictable system to run the tests on.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 15 Sep 2016 13:16:52 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com> writes:\\n> On 09/14/2016 07:57 PM, Tom Lane wrote:\\n>> People who are vacuuming because they are out of disk space will be very\\n>> very unhappy with that solution.\\n\\n> The people are usually running out of space for data, while these files \\n> would be temporary files placed wherever temp_tablespaces points to. I'd \\n> argue if this is a source of problems, the people are already in deep \\n> trouble due to sorts, CREATE INDEX, ... as those commands may also \\n> generate a lot of temporary files.\\n\\nExcept that if you are trying to recover disk space, VACUUM is what you\\nare doing, not CREATE INDEX. Requiring extra disk space to perform a\\nvacuum successfully is exactly the wrong direction to be going in.\\nSee for example this current commitfest entry:\\nhttps://commitfest.postgresql.org/10/649/\\nRegardless of what you think of the merits of that patch, it's trying\\nto solve a real-world problem. And as Robert has already pointed out,\\nmaking this aspect of VACUUM more complicated is not solving any\\npressing problem. \\\"But we made it faster\\\" is going to be a poor answer\\nfor the next person who finds themselves up against the wall with no\\nrecourse.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 12:22:16 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 12:22 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Tomas Vondra <tomas.vondra@2ndquadrant.com> writes:\\n>> On 09/14/2016 07:57 PM, Tom Lane wrote:\\n>>> People who are vacuuming because they are out of disk space will be very\\n>>> very unhappy with that solution.\\n>\\n>> The people are usually running out of space for data, while these files\\n>> would be temporary files placed wherever temp_tablespaces points to. I'd\\n>> argue if this is a source of problems, the people are already in deep\\n>> trouble due to sorts, CREATE INDEX, ... as those commands may also\\n>> generate a lot of temporary files.\\n>\\n> Except that if you are trying to recover disk space, VACUUM is what you\\n> are doing, not CREATE INDEX. Requiring extra disk space to perform a\\n> vacuum successfully is exactly the wrong direction to be going in.\\n> See for example this current commitfest entry:\\n> https://commitfest.postgresql.org/10/649/\\n> Regardless of what you think of the merits of that patch, it's trying\\n> to solve a real-world problem. And as Robert has already pointed out,\\n> making this aspect of VACUUM more complicated is not solving any\\n> pressing problem. \\\"But we made it faster\\\" is going to be a poor answer\\n> for the next person who finds themselves up against the wall with no\\n> recourse.\\n\\nI very much agree.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 12:40:18 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 09/15/2016 06:40 PM, Robert Haas wrote:\\n> On Thu, Sep 15, 2016 at 12:22 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>> Tomas Vondra <tomas.vondra@2ndquadrant.com> writes:\\n>>> On 09/14/2016 07:57 PM, Tom Lane wrote:\\n>>>> People who are vacuuming because they are out of disk space will be very\\n>>>> very unhappy with that solution.\\n>>\\n>>> The people are usually running out of space for data, while these files\\n>>> would be temporary files placed wherever temp_tablespaces points to. I'd\\n>>> argue if this is a source of problems, the people are already in deep\\n>>> trouble due to sorts, CREATE INDEX, ... as those commands may also\\n>>> generate a lot of temporary files.\\n>>\\n>> Except that if you are trying to recover disk space, VACUUM is what you\\n>> are doing, not CREATE INDEX. Requiring extra disk space to perform a\\n>> vacuum successfully is exactly the wrong direction to be going in.\\n>> See for example this current commitfest entry:\\n>> https://commitfest.postgresql.org/10/649/\\n>> Regardless of what you think of the merits of that patch, it's trying\\n>> to solve a real-world problem. And as Robert has already pointed out,\\n>> making this aspect of VACUUM more complicated is not solving any\\n>> pressing problem. \\\"But we made it faster\\\" is going to be a poor answer\\n>> for the next person who finds themselves up against the wall with no\\n>> recourse.\\n>\\n> I very much agree.\\n>\\n\\nHow does VACUUM alone help with recovering disk space? AFAIK it only \\nmakes the space available for new data, it does not reclaim the disk \\nspace at all. Sure, we truncate empty pages at the end of the last \\nsegment, but how likely is that in practice? What I do see people doing \\nis usually either VACUUM FULL (which is however doomed for obvious \\nreasons) or VACUUM + reindexing to get rid of index bloat (which however \\nleads to CREATE INDEX using temporary files).\\n\\nI'm not sure I agree with your claim there's no pressing problem. We do \\nsee quite a few people having to do VACUUM with multiple index scans \\n(because the TIDs don't fit into m_w_m), which certainly has significant \\nimpact on production systems - both in terms of performance and it also \\nslows down reclaiming the space. Sure, being able to set m_w_m above 1GB \\nis an improvement, but perhaps using a more efficient TID storage would \\nimprove the situation further. Writing the TIDs to a temporary file may \\nnot the right approach, but I don't see why that would make the original \\nproblem less severe?\\n\\nFor example, we always allocate the TID array as large as we can fit \\ninto m_w_m, but maybe we don't need to wait with switching to the bitmap \\nuntil filling the whole array - we could wait as long as the bitmap fits \\ninto the remaining part of the array, build it there and then copy it to \\nthe beginning (and use the bitmap from that point).\\n\\nregards\\nTomas\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 20:48:09 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 3:48 PM, Tomas Vondra\\n<tomas.vondra@2ndquadrant.com> wrote:\\n> For example, we always allocate the TID array as large as we can fit into\\n> m_w_m, but maybe we don't need to wait with switching to the bitmap until\\n> filling the whole array - we could wait as long as the bitmap fits into the\\n> remaining part of the array, build it there and then copy it to the\\n> beginning (and use the bitmap from that point).\\n\\nThe bitmap can be created like that, but grow from the end of the\\nsegment backwards.\\n\\nSo the scan can proceed until the bitmap fills the whole segment\\n(filling backwards), no copy required.\\n\\nI'll try that later, but first I'd like to get multiarray approach\\nright since that's the basis of it.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 15:54:41 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 16, 2016 at 12:24 AM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n> On Thu, Sep 15, 2016 at 3:48 PM, Tomas Vondra\\n> <tomas.vondra@2ndquadrant.com> wrote:\\n> > For example, we always allocate the TID array as large as we can fit into\\n> > m_w_m, but maybe we don't need to wait with switching to the bitmap until\\n> > filling the whole array - we could wait as long as the bitmap fits into\\n> the\\n> > remaining part of the array, build it there and then copy it to the\\n> > beginning (and use the bitmap from that point).\\n>\\n> The bitmap can be created like that, but grow from the end of the\\n> segment backwards.\\n>\\n> So the scan can proceed until the bitmap fills the whole segment\\n> (filling backwards), no copy required.\\n>\\n\\nI thought about those approaches when I suggested starting with half m_w_m.\\nSo you fill in TIDs from one end and upon reaching half point, convert that\\ninto bitmap (assuming stats tell you that there is significant savings with\\nbitmaps) but fill it from the other end. Then reset the TID array and start\\nfilling up again. That guarantees that you can always work within available\\nlimit.\\n\\nBut I actually wonder if we are over engineering things and overestimating\\ncost of memmove etc. How about this simpler approach:\\n\\n1. Divide table in some fixed size chunks like Robert suggested. Say 1GB\\n2. Allocate pointer array to store a pointer to each segment. For 1TB\\ntable, thats about 8192 bytes.\\n3. Allocate a bitmap which can hold MaxHeapTuplesPerPage * chunk size in\\npages. For 8192 block and 1GB chunk, thats about 4.6MB. *Note*: I'm\\nsuggesting to use a bitmap here because provisioning for worst case, fixed\\nsize TID array will cost us 200MB+ where as a bitmap is just 4.6MB.\\n4. Collect dead tuples in that 1GB chunk. Also collect stats so that we\\nknow about the most optimal representation.\\n5. At the end of 1GB scan, if no dead tuples found, set the chunk pointer\\nto NULL, move to next chunk and restart step 4. If dead tuples found, then\\ncheck:\\n a. If bitmap can be further compressed by using less number of bits per\\npage. If so, allocate a new bitmap and compress the bitmap.\\n b. If TID array will be a more compact representation. If so, allocate a\\nTID array of right size and convert bitmap into an array.\\n c. Set chunk pointer to whichever representation we choose (of course\\nadd headers etc to interpret the representation)\\n6. Continue until we consume all m_w_m or end-of-table is reached. If we\\nconsume all m_w_m then do a round of index cleanup and restart.\\n\\nI also realised that we can compact the TID array in step (b) above because\\nwe only need to store 17 bits for block numbers (we already know which 1GB\\nsegment they belong to). Given that usable offsets are also just 13 bits,\\nTID array needs only 4 bytes per TID instead of 6.\\n\\nMany people are working on implementing different ideas, and I can\\nvolunteer to write a patch on these lines unless someone wants to do that.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Fri, Sep 16, 2016 at 12:24 AM, Claudio Freire <klaussfreire@gmail.com> wrote:On Thu, Sep 15, 2016 at 3:48 PM, Tomas Vondra\\n<tomas.vondra@2ndquadrant.com> wrote:\\n> For example, we always allocate the TID array as large as we can fit into\\n> m_w_m, but maybe we don't need to wait with switching to the bitmap until\\n> filling the whole array - we could wait as long as the bitmap fits into the\\n> remaining part of the array, build it there and then copy it to the\\n> beginning (and use the bitmap from that point).\\n\\nThe bitmap can be created like that, but grow from the end of the\\nsegment backwards.\\n\\nSo the scan can proceed until the bitmap fills the whole segment\\n(filling backwards), no copy required.I thought about those approaches when I suggested starting with half m_w_m. So you fill in TIDs from one end and upon reaching half point, convert that into bitmap (assuming stats tell you that there is significant savings with bitmaps) but fill it from the other end. Then reset the TID array and start filling up again. That guarantees that you can always work within available limit.But I actually wonder if we are over engineering things and overestimating cost of memmove etc. How about this simpler approach:1. Divide table in some fixed size chunks like Robert suggested. Say 1GB2. Allocate pointer array to store a pointer to each segment. For 1TB table, thats about 8192 bytes.3. Allocate a bitmap which can hold MaxHeapTuplesPerPage * chunk size in pages. For 8192 block and 1GB chunk, thats about 4.6MB. Note: I'm suggesting to use a bitmap here because provisioning for worst case, fixed size TID array will cost us 200MB+ where as a bitmap is just 4.6MB.4. Collect dead tuples in that 1GB chunk. Also collect stats so that we know about the most optimal representation.5. At the end of 1GB scan, if no dead tuples found, set the chunk pointer to NULL, move to next chunk and restart step 4. If dead tuples found, then check: a. If bitmap can be further compressed by using less number of bits per page. If so, allocate a new bitmap and compress the bitmap. b. If TID array will be a more compact representation. If so, allocate a TID array of right size and convert bitmap into an array. c. Set chunk pointer to whichever representation we choose (of course add headers etc to interpret the representation)6. Continue until we consume all m_w_m or end-of-table is reached. If we consume all m_w_m then do a round of index cleanup and restart.I also realised that we can compact the TID array in step (b) above because we only need to store 17 bits for block numbers (we already know which 1GB segment they belong to). Given that usable offsets are also just 13 bits, TID array needs only 4 bytes per TID instead of 6. Many people are working on implementing different ideas, and I can volunteer to write a patch on these lines unless someone wants to do that.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Fri, 16 Sep 2016 09:09:10 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 16, 2016 at 9:09 AM, Pavan Deolasee <pavan.deolasee@gmail.com>\\nwrote:\\n\\n>\\n> I also realised that we can compact the TID array in step (b) above\\n> because we only need to store 17 bits for block numbers (we already know\\n> which 1GB segment they belong to). Given that usable offsets are also just\\n> 13 bits, TID array needs only 4 bytes per TID instead of 6.\\n>\\n>\\nActually this seems like a clear savings of at least 30% for all use cases,\\nat the cost of allocating in smaller chunks and doing some transformations.\\nBut given the problem we are trying to solve, seems like a small price to\\npay.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Fri, Sep 16, 2016 at 9:09 AM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:I also realised that we can compact the TID array in step (b) above because we only need to store 17 bits for block numbers (we already know which 1GB segment they belong to). Given that usable offsets are also just 13 bits, TID array needs only 4 bytes per TID instead of 6. Actually this seems like a clear savings of at least 30% for all use cases, at the cost of allocating in smaller chunks and doing some transformations. But given the problem we are trying to solve, seems like a small price to pay.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Fri, 16 Sep 2016 10:22:22 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> But I actually wonder if we are over engineering things and overestimating\\n> cost of memmove etc. How about this simpler approach:\\n\\nDon't forget that you need to handle the case where\\nmaintenance_work_mem is quite small.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 16 Sep 2016 09:33:12 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 16, 2016 at 7:03 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n> On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\\n> <pavan.deolasee@gmail.com> wrote:\\n> > But I actually wonder if we are over engineering things and\\n> overestimating\\n> > cost of memmove etc. How about this simpler approach:\\n>\\n> Don't forget that you need to handle the case where\\n> maintenance_work_mem is quite small.\\n>\\n>\\nHow small? The default IIRC these days is 64MB and minimum is 1MB. I think\\nwe can do some special casing for very small values and ensure that things\\nat the very least work and hopefully don't regress for them.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Fri, Sep 16, 2016 at 7:03 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> But I actually wonder if we are over engineering things and overestimating\\n> cost of memmove etc. How about this simpler approach:\\n\\nDon't forget that you need to handle the case where\\nmaintenance_work_mem is quite small.\\nHow small? The default IIRC these days is 64MB and minimum is 1MB. I think we can do some special casing for very small values and ensure that things at the very least work and hopefully don't regress for them. Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Fri, 16 Sep 2016 19:17:14 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 16, 2016 at 9:47 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> On Fri, Sep 16, 2016 at 7:03 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> On Thu, Sep 15, 2016 at 11:39 PM, Pavan Deolasee\\n>> <pavan.deolasee@gmail.com> wrote:\\n>> > But I actually wonder if we are over engineering things and\\n>> > overestimating\\n>> > cost of memmove etc. How about this simpler approach:\\n>>\\n>> Don't forget that you need to handle the case where\\n>> maintenance_work_mem is quite small.\\n>\\n> How small? The default IIRC these days is 64MB and minimum is 1MB. I think\\n> we can do some special casing for very small values and ensure that things\\n> at the very least work and hopefully don't regress for them.\\n\\nSounds like you need to handle values as small as 1MB, then.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 16 Sep 2016 09:59:32 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 1:16 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Sep 14, 2016 at 12:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>>\\n>>> I am kind of doubtful about this whole line of investigation because\\n>>> we're basically trying pretty hard to fix something that I'm not sure\\n>>> is broken. I do agree that, all other things being equal, the TID\\n>>> lookups will probably be faster with a bitmap than with a binary\\n>>> search, but maybe not if the table is large and the number of dead\\n>>> TIDs is small, because cache efficiency is pretty important. But even\\n>>> if it's always faster, does TID lookup speed even really matter to\\n>>> overall VACUUM performance? Claudio's early results suggest that it\\n>>> might, but maybe that's just a question of some optimization that\\n>>> hasn't been done yet.\\n>>\\n>> FYI, the reported impact was on CPU time, not runtime. There was no\\n>> significant difference in runtime (real time), because my test is\\n>> heavily I/O bound.\\n>>\\n>> I tested with a few small tables and there was no significant\\n>> difference either, but small tables don't stress the array lookup\\n>> anyway so that's expected.\\n>>\\n>> But on the assumption that some systems may be CPU bound during vacuum\\n>> (particularly those able to do more than 300-400MB/s sequential I/O),\\n>> in those cases the increased or decreased cost of lazy_tid_reaped will\\n>> directly correlate to runtime. It's just none of my systems, which all\\n>> run on amazon and is heavily bandwidth constrained (fastest I/O\\n>> subsystem I can get my hands on does 200MB/s).\\n>\\n> Attached is the patch with the multiarray version.\\n>\\n> The tests are weird. Best case comparison over several runs, to remove\\n> the impact of concurrent activity on this host (I couldn't remove all\\n> background activity even when running the tests overnight, the distro\\n> adds tons of crons and background cleanup tasks it would seem),\\n> there's only very mild CPU impact. I'd say insignificant, as it's well\\n> below the mean variance.\\n\\nI reran the tests on a really dedicated system, and with a script that\\ncaptured a lot more details about the runs.\\n\\nThe system isn't impressive, an i5 with a single consumer HD and 8GB\\nRAM, but it did the job.\\n\\nThese tests make more sense, so I bet it was the previous tests that\\nwere spoiled by concurrent activity on the host.\\n\\nAttached is the raw output of the test, the script used to create it,\\nand just in case the patch set used. I believe it's the same as the\\nlast one I posted, just rebased.\\n\\nIn the results archive, the .vacuum prefix is the patched version with\\nboth patch 1 and 2, .git.ref is just patch 1 (without which the\\ntruncate takes unholily long).\\n\\nGrepping the results a bit, picking an average run out of all runs on\\neach scale:\\n\\nTimings:\\n\\nPatched:\\n\\ns100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\\ns400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\\ns4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\\n\\nUnpatched:\\n\\ns100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\\ns400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\\ns4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\\n\\nTotal I/O (in MB)\\n\\nPatched:\\n\\ns100: R:2.4 - W:5862\\ns400: R:1337.4 - W:29385.6\\ns4000: R:318631 - W:370154\\n\\nUnpatched:\\n\\ns100: R:1412.4 - W:7644.6\\ns400: R:3180.6 - W:36281.4\\ns4000: R:330683 - W:370391\\n\\n\\nSo, in essence, CPU time didn't get adversely affected. If anything,\\nit got improved by about 20% on the biggest case (scale 4000).\\n\\nWhile total runtime didn't change much, I believe this is only due to\\nthe fact that the index is perfectly correlated (clustered?) since\\nit's a pristine index, so index scans either remove or skip full\\npages, never leaving things half-way. A bloated index would probably\\nshow a substantially different behavior, I'll try to get a script that\\ndoes it by running pgbench a while before the vacuum or something like\\nthat.\\n\\nHowever, the total I/O metric already shows remarkable improvement.\\nThis metric is measuring all the I/O including pgbench init, the\\ninitial vacuum pgbench init does, the delete and the final vacuum. So\\nit's not just the I/O for the vacuum itself, but the whole run. We can\\nsee the patched version reading a lot less (less scans over the\\nindexes will do that), and in some cases writing less too (again, less\\nindex scans may be performing less redundant writes when cleaning\\nup/reclaiming index pages).\\n\\nI'll post when I get the results for the bloated case, but I believe\\nthis already shows substantial improvement as is.\\n\\nThis approach can later be improved upon by turning tid segments into\\nbitmaps if they're packed densely enough, but I believe this patch\\nrepresents a sensible first step before attempting that.\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 26 Oct 2016 17:25:23 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Oct 27, 2016 at 5:25 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Thu, Sep 15, 2016 at 1:16 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Wed, Sep 14, 2016 at 12:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> On Wed, Sep 14, 2016 at 12:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>>>\\n>>>> I am kind of doubtful about this whole line of investigation because\\n>>>> we're basically trying pretty hard to fix something that I'm not sure\\n>>>> is broken. I do agree that, all other things being equal, the TID\\n>>>> lookups will probably be faster with a bitmap than with a binary\\n>>>> search, but maybe not if the table is large and the number of dead\\n>>>> TIDs is small, because cache efficiency is pretty important. But even\\n>>>> if it's always faster, does TID lookup speed even really matter to\\n>>>> overall VACUUM performance? Claudio's early results suggest that it\\n>>>> might, but maybe that's just a question of some optimization that\\n>>>> hasn't been done yet.\\n>>>\\n>>> FYI, the reported impact was on CPU time, not runtime. There was no\\n>>> significant difference in runtime (real time), because my test is\\n>>> heavily I/O bound.\\n>>>\\n>>> I tested with a few small tables and there was no significant\\n>>> difference either, but small tables don't stress the array lookup\\n>>> anyway so that's expected.\\n>>>\\n>>> But on the assumption that some systems may be CPU bound during vacuum\\n>>> (particularly those able to do more than 300-400MB/s sequential I/O),\\n>>> in those cases the increased or decreased cost of lazy_tid_reaped will\\n>>> directly correlate to runtime. It's just none of my systems, which all\\n>>> run on amazon and is heavily bandwidth constrained (fastest I/O\\n>>> subsystem I can get my hands on does 200MB/s).\\n>>\\n>> Attached is the patch with the multiarray version.\\n>>\\n>> The tests are weird. Best case comparison over several runs, to remove\\n>> the impact of concurrent activity on this host (I couldn't remove all\\n>> background activity even when running the tests overnight, the distro\\n>> adds tons of crons and background cleanup tasks it would seem),\\n>> there's only very mild CPU impact. I'd say insignificant, as it's well\\n>> below the mean variance.\\n>\\n> I reran the tests on a really dedicated system, and with a script that\\n> captured a lot more details about the runs.\\n>\\n> The system isn't impressive, an i5 with a single consumer HD and 8GB\\n> RAM, but it did the job.\\n>\\n> These tests make more sense, so I bet it was the previous tests that\\n> were spoiled by concurrent activity on the host.\\n>\\n> Attached is the raw output of the test, the script used to create it,\\n> and just in case the patch set used. I believe it's the same as the\\n> last one I posted, just rebased.\\n\\nI glanced at the patches but the both patches don't obey the coding\\nstyle of PostgreSQL.\\nPlease refer to [1].\\n\\n[1] http://wiki.postgresql.org/wiki/Developer_FAQ#What.27s_the_formatting_style_used_in_PostgreSQL_source_code.3F.\\n\\n>\\n> In the results archive, the .vacuum prefix is the patched version with\\n> both patch 1 and 2, .git.ref is just patch 1 (without which the\\n> truncate takes unholily long).\\n\\nDid you measure the performance benefit of 0001 patch by comparing\\nHEAD with HEAD+0001 patch?\\n\\n> Grepping the results a bit, picking an average run out of all runs on\\n> each scale:\\n>\\n> Timings:\\n>\\n> Patched:\\n>\\n> s100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\\n> s400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\\n> s4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\\n>\\n> Unpatched:\\n>\\n> s100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\\n> s400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\\n> s4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\\n>\\n> Total I/O (in MB)\\n>\\n> Patched:\\n>\\n> s100: R:2.4 - W:5862\\n> s400: R:1337.4 - W:29385.6\\n> s4000: R:318631 - W:370154\\n>\\n> Unpatched:\\n>\\n> s100: R:1412.4 - W:7644.6\\n> s400: R:3180.6 - W:36281.4\\n> s4000: R:330683 - W:370391\\n>\\n>\\n> So, in essence, CPU time didn't get adversely affected. If anything,\\n> it got improved by about 20% on the biggest case (scale 4000).\\n\\nAnd this test case deletes all tuples in relation and then measure\\nduration of vacuum.\\nIt would not be effect much in practical use case.\\n\\n> While total runtime didn't change much, I believe this is only due to\\n> the fact that the index is perfectly correlated (clustered?) since\\n> it's a pristine index, so index scans either remove or skip full\\n> pages, never leaving things half-way. A bloated index would probably\\n> show a substantially different behavior, I'll try to get a script that\\n> does it by running pgbench a while before the vacuum or something like\\n> that.\\n>\\n> However, the total I/O metric already shows remarkable improvement.\\n> This metric is measuring all the I/O including pgbench init, the\\n> initial vacuum pgbench init does, the delete and the final vacuum. So\\n> it's not just the I/O for the vacuum itself, but the whole run. We can\\n> see the patched version reading a lot less (less scans over the\\n> indexes will do that), and in some cases writing less too (again, less\\n> index scans may be performing less redundant writes when cleaning\\n> up/reclaiming index pages).\\n\\nWhat value of maintenance_work_mem did you use for this test? Since\\nDeadTuplesSegment struct still stores array of ItemPointerData(6byte)\\nrepresenting dead tuple I supposed that the frequency of index vacuum\\ndoes not change. But according to the test result, a index vacuum is\\ninvoked once and removes 400000000 rows at the time. It means that the\\nvacuum stored about 2289 MB memory during heap vacuum. On the other\\nside, the result of test without 0002 patch show that a index vacuum\\nremove 178956737 rows at the time, which means 1GB memory was used.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 18 Nov 2016 02:34:50 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 2:34 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> I glanced at the patches but the both patches don't obey the coding\\n> style of PostgreSQL.\\n> Please refer to [1].\\n>\\n> [1] http://wiki.postgresql.org/wiki/Developer_FAQ#What.27s_the_formatting_style_used_in_PostgreSQL_source_code.3F.\\n\\nI thought I had. I'll go through that list to check what I missed.\\n\\n>> In the results archive, the .vacuum prefix is the patched version with\\n>> both patch 1 and 2, .git.ref is just patch 1 (without which the\\n>> truncate takes unholily long).\\n>\\n> Did you measure the performance benefit of 0001 patch by comparing\\n> HEAD with HEAD+0001 patch?\\n\\nNot the whole test, but yes. Without the 0001 patch the backward scan\\nstep during truncate goes between 3 and 5 times slower. I don't have\\ntimings because the test never finished without the patch. It would\\nhave finished, but it would have taken about a day.\\n\\n>> Grepping the results a bit, picking an average run out of all runs on\\n>> each scale:\\n>>\\n>> Timings:\\n>>\\n>> Patched:\\n>>\\n>> s100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\\n>> s400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\\n>> s4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\\n>>\\n>> Unpatched:\\n>>\\n>> s100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\\n>> s400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\\n>> s4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\\n>>\\n>> Total I/O (in MB)\\n>>\\n>> Patched:\\n>>\\n>> s100: R:2.4 - W:5862\\n>> s400: R:1337.4 - W:29385.6\\n>> s4000: R:318631 - W:370154\\n>>\\n>> Unpatched:\\n>>\\n>> s100: R:1412.4 - W:7644.6\\n>> s400: R:3180.6 - W:36281.4\\n>> s4000: R:330683 - W:370391\\n>>\\n>>\\n>> So, in essence, CPU time didn't get adversely affected. If anything,\\n>> it got improved by about 20% on the biggest case (scale 4000).\\n>\\n> And this test case deletes all tuples in relation and then measure\\n> duration of vacuum.\\n> It would not be effect much in practical use case.\\n\\nWell, this patch set started because I had to do exactly that, and\\nrealized just how inefficient vacuum was in that case.\\n\\nBut it doesn't mean it won't benefit more realistic use cases. Almost\\nany big database ends up hitting this 1GB limit because big tables\\ntake very long to vacuum and accumulate a lot of bloat in-between\\nvacuums.\\n\\nIf you have a specific test case in mind I can try to run it.\\n\\n>> While total runtime didn't change much, I believe this is only due to\\n>> the fact that the index is perfectly correlated (clustered?) since\\n>> it's a pristine index, so index scans either remove or skip full\\n>> pages, never leaving things half-way. A bloated index would probably\\n>> show a substantially different behavior, I'll try to get a script that\\n>> does it by running pgbench a while before the vacuum or something like\\n>> that.\\n>>\\n>> However, the total I/O metric already shows remarkable improvement.\\n>> This metric is measuring all the I/O including pgbench init, the\\n>> initial vacuum pgbench init does, the delete and the final vacuum. So\\n>> it's not just the I/O for the vacuum itself, but the whole run. We can\\n>> see the patched version reading a lot less (less scans over the\\n>> indexes will do that), and in some cases writing less too (again, less\\n>> index scans may be performing less redundant writes when cleaning\\n>> up/reclaiming index pages).\\n>\\n> What value of maintenance_work_mem did you use for this test?\\n\\n4GB on both, patched and HEAD.\\n\\n> Since\\n> DeadTuplesSegment struct still stores array of ItemPointerData(6byte)\\n> representing dead tuple I supposed that the frequency of index vacuum\\n> does not change. But according to the test result, a index vacuum is\\n> invoked once and removes 400000000 rows at the time. It means that the\\n> vacuum stored about 2289 MB memory during heap vacuum. On the other\\n> side, the result of test without 0002 patch show that a index vacuum\\n> remove 178956737 rows at the time, which means 1GB memory was used.\\n\\n1GB is a hardcoded limit on HEAD for vacuum work mem. This patch\\nremoves that limit and lets vacuum use all the memory the user gave to\\nvacuum.\\n\\nIn the test, in both cases, 4GB was used as maintenance_work_mem\\nvalue, but HEAD cannot use all the 4GB, and it will limit itself to\\njust 1GB.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Nov 2016 14:51:27 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 2:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Thu, Nov 17, 2016 at 2:34 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> I glanced at the patches but the both patches don't obey the coding\\n>> style of PostgreSQL.\\n>> Please refer to [1].\\n>>\\n>> [1] http://wiki.postgresql.org/wiki/Developer_FAQ#What.27s_the_formatting_style_used_in_PostgreSQL_source_code.3F.\\n>\\n> I thought I had. I'll go through that list to check what I missed.\\n\\nAttached is patch 0002 with pgindent applied over it\\n\\nI don't think there's any other formatting issue, but feel free to\\npoint a finger to it if I missed any\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 17 Nov 2016 15:42:55 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> Attached is patch 0002 with pgindent applied over it\\n>\\n> I don't think there's any other formatting issue, but feel free to\\n> point a finger to it if I missed any\\n\\nHmm, I had imagined making all of the segments the same size rather\\nthan having the size grow exponentially. The whole point of this is\\nto save memory, and even in the worst case you don't end up with that\\nmany segments as long as you pick a reasonable base size (e.g. 64MB).\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Nov 2016 16:34:55 -0500\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> Attached is patch 0002 with pgindent applied over it\\n>\\n> I don't think there's any other formatting issue, but feel free to\\n> point a finger to it if I missed any\\n\\nHmm, I had imagined making all of the segments the same size rather\\nthan having the size grow exponentially. The whole point of this is\\nto save memory, and even in the worst case you don't end up with that\\nmany segments as long as you pick a reasonable base size (e.g. 64MB).\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Nov 2016 16:38:50 -0500\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> Attached is patch 0002 with pgindent applied over it\\n>>\\n>> I don't think there's any other formatting issue, but feel free to\\n>> point a finger to it if I missed any\\n>\\n> Hmm, I had imagined making all of the segments the same size rather\\n> than having the size grow exponentially. The whole point of this is\\n> to save memory, and even in the worst case you don't end up with that\\n> many segments as long as you pick a reasonable base size (e.g. 64MB).\\n\\nWastage is bound by a fraction of the total required RAM, that is,\\nit's proportional to the amount of required RAM, not the amount\\nallocated. So it should still be fine, and the exponential strategy\\nshould improve lookup performance considerably.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Nov 2016 18:54:55 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> Attached is patch 0002 with pgindent applied over it\\n>>>\\n>>> I don't think there's any other formatting issue, but feel free to\\n>>> point a finger to it if I missed any\\n>>\\n>> Hmm, I had imagined making all of the segments the same size rather\\n>> than having the size grow exponentially. The whole point of this is\\n>> to save memory, and even in the worst case you don't end up with that\\n>> many segments as long as you pick a reasonable base size (e.g. 64MB).\\n>\\n> Wastage is bound by a fraction of the total required RAM, that is,\\n> it's proportional to the amount of required RAM, not the amount\\n> allocated. So it should still be fine, and the exponential strategy\\n> should improve lookup performance considerably.\\n\\nI'm concerned that it could use repalloc for large memory area when\\nvacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\\nand slow. What about using semi-fixed memroy space without repalloc;\\nAllocate the array of ItemPointerData array, and each ItemPointerData\\narray stores the dead tuple locations. The size of ItemPointerData\\narray starts with small size (e.g. 16MB or 32MB). After we used an\\narray up, we then allocate next segment with twice size as previous\\nsegment. But to prevent over allocating memory, it would be better to\\nset a limit of allocating size of ItemPointerData array to 512MB or\\n1GB. We could expand array of array using repalloc if needed, but it\\nwould not be happend much. Other design is similar to current your\\npatch; the offset of the array of array and the offset of a\\nItemPointerData array control current location, which are cleared\\nafter finished reclaiming garbage on heap and index. And allocated\\narray is re-used by subsequent scanning heap.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 22 Nov 2016 02:15:20 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Nov 21, 2016 at 2:15 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>>> Attached is patch 0002 with pgindent applied over it\\n>>>>\\n>>>> I don't think there's any other formatting issue, but feel free to\\n>>>> point a finger to it if I missed any\\n>>>\\n>>> Hmm, I had imagined making all of the segments the same size rather\\n>>> than having the size grow exponentially. The whole point of this is\\n>>> to save memory, and even in the worst case you don't end up with that\\n>>> many segments as long as you pick a reasonable base size (e.g. 64MB).\\n>>\\n>> Wastage is bound by a fraction of the total required RAM, that is,\\n>> it's proportional to the amount of required RAM, not the amount\\n>> allocated. So it should still be fine, and the exponential strategy\\n>> should improve lookup performance considerably.\\n>\\n> I'm concerned that it could use repalloc for large memory area when\\n> vacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\\n> and slow.\\n\\nHow large?\\n\\nThat array cannot be very large. It contains pointers to\\nexponentially-growing arrays, but the repalloc'd array itself is\\nsmall: one struct per segment, each segment starts at 128MB and grows\\nexponentially.\\n\\nIn fact, IIRC, it can be proven that such a repalloc strategy has an\\namortized cost of O(log log n) per tuple. If it repallocd the whole\\ntid array it would be O(log n), but since it handles only pointers to\\nsegments of exponentially growing tuples it becomes O(log log n).\\n\\nFurthermore, n there is still limited to MAX_INT, which means the cost\\nper tuple is bound by O(log log 2^32) = 5. And that's an absolute\\nworst case that's ignoring the 128MB constant factor which is indeed\\nrelevant.\\n\\n> What about using semi-fixed memroy space without repalloc;\\n> Allocate the array of ItemPointerData array, and each ItemPointerData\\n> array stores the dead tuple locations. The size of ItemPointerData\\n> array starts with small size (e.g. 16MB or 32MB). After we used an\\n> array up, we then allocate next segment with twice size as previous\\n> segment.\\n\\nThat's what the patch does.\\n\\n> But to prevent over allocating memory, it would be better to\\n> set a limit of allocating size of ItemPointerData array to 512MB or\\n> 1GB.\\n\\nThere already is a limit to 1GB (the maximum amount palloc can allocate)\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 21 Nov 2016 14:53:59 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Nov 22, 2016 at 4:53 AM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n> On Mon, Nov 21, 2016 at 2:15 PM, Masahiko Sawada <sawada.mshk@gmail.com>\\n> wrote:\\n> > On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com>\\n> wrote:\\n> >> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com>\\n> wrote:\\n> >>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <\\n> klaussfreire@gmail.com> wrote:\\n> >>>> Attached is patch 0002 with pgindent applied over it\\n> >>>>\\n> >>>> I don't think there's any other formatting issue, but feel free to\\n> >>>> point a finger to it if I missed any\\n> >>>\\n> >>> Hmm, I had imagined making all of the segments the same size rather\\n> >>> than having the size grow exponentially. The whole point of this is\\n> >>> to save memory, and even in the worst case you don't end up with that\\n> >>> many segments as long as you pick a reasonable base size (e.g. 64MB).\\n> >>\\n> >> Wastage is bound by a fraction of the total required RAM, that is,\\n> >> it's proportional to the amount of required RAM, not the amount\\n> >> allocated. So it should still be fine, and the exponential strategy\\n> >> should improve lookup performance considerably.\\n> >\\n> > I'm concerned that it could use repalloc for large memory area when\\n> > vacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\\n> > and slow.\\n>\\n> How large?\\n>\\n> That array cannot be very large. It contains pointers to\\n> exponentially-growing arrays, but the repalloc'd array itself is\\n> small: one struct per segment, each segment starts at 128MB and grows\\n> exponentially.\\n>\\n> In fact, IIRC, it can be proven that such a repalloc strategy has an\\n> amortized cost of O(log log n) per tuple. If it repallocd the whole\\n> tid array it would be O(log n), but since it handles only pointers to\\n> segments of exponentially growing tuples it becomes O(log log n).\\n>\\n> Furthermore, n there is still limited to MAX_INT, which means the cost\\n> per tuple is bound by O(log log 2^32) = 5. And that's an absolute\\n> worst case that's ignoring the 128MB constant factor which is indeed\\n> relevant.\\n>\\n> > What about using semi-fixed memroy space without repalloc;\\n> > Allocate the array of ItemPointerData array, and each ItemPointerData\\n> > array stores the dead tuple locations. The size of ItemPointerData\\n> > array starts with small size (e.g. 16MB or 32MB). After we used an\\n> > array up, we then allocate next segment with twice size as previous\\n> > segment.\\n>\\n> That's what the patch does.\\n>\\n> > But to prevent over allocating memory, it would be better to\\n> > set a limit of allocating size of ItemPointerData array to 512MB or\\n> > 1GB.\\n>\\n> There already is a limit to 1GB (the maximum amount palloc can allocate)\\n>\\n>\\nMoved to next CF with \\\"needs review\\\" status.\\n\\nRegards,\\nHari Babu\\nFujitsu Australia\\n\\nOn Tue, Nov 22, 2016 at 4:53 AM, Claudio Freire <klaussfreire@gmail.com> wrote:On Mon, Nov 21, 2016 at 2:15 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> On Fri, Nov 18, 2016 at 6:54 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Thu, Nov 17, 2016 at 6:34 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>> On Thu, Nov 17, 2016 at 1:42 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>>> Attached is patch 0002 with pgindent applied over it\\n>>>>\\n>>>> I don't think there's any other formatting issue, but feel free to\\n>>>> point a finger to it if I missed any\\n>>>\\n>>> Hmm, I had imagined making all of the segments the same size rather\\n>>> than having the size grow exponentially. The whole point of this is\\n>>> to save memory, and even in the worst case you don't end up with that\\n>>> many segments as long as you pick a reasonable base size (e.g. 64MB).\\n>>\\n>> Wastage is bound by a fraction of the total required RAM, that is,\\n>> it's proportional to the amount of required RAM, not the amount\\n>> allocated. So it should still be fine, and the exponential strategy\\n>> should improve lookup performance considerably.\\n>\\n> I'm concerned that it could use repalloc for large memory area when\\n> vacrelstats->dead_tuples.dead_tuple is bloated. It would be overhead\\n> and slow.\\n\\nHow large?\\n\\nThat array cannot be very large. It contains pointers to\\nexponentially-growing arrays, but the repalloc'd array itself is\\nsmall: one struct per segment, each segment starts at 128MB and grows\\nexponentially.\\n\\nIn fact, IIRC, it can be proven that such a repalloc strategy has an\\namortized cost of O(log log n) per tuple. If it repallocd the whole\\ntid array it would be O(log n), but since it handles only pointers to\\nsegments of exponentially growing tuples it becomes O(log log n).\\n\\nFurthermore, n there is still limited to MAX_INT, which means the cost\\nper tuple is bound by O(log log 2^32) = 5. And that's an absolute\\nworst case that's ignoring the 128MB constant factor which is indeed\\nrelevant.\\n\\n> What about using semi-fixed memroy space without repalloc;\\n> Allocate the array of ItemPointerData array, and each ItemPointerData\\n> array stores the dead tuple locations. The size of ItemPointerData\\n> array starts with small size (e.g. 16MB or 32MB). After we used an\\n> array up, we then allocate next segment with twice size as previous\\n> segment.\\n\\nThat's what the patch does.\\n\\n> But to prevent over allocating memory, it would be better to\\n> set a limit of allocating size of ItemPointerData array to 512MB or\\n> 1GB.\\n\\nThere already is a limit to 1GB (the maximum amount palloc can allocate)\\nMoved to next CF with \\\"needs review\\\" status.Regards,Hari BabuFujitsu Australia\",\n \"msg_date\": \"Mon, 5 Dec 2016 13:29:01 +1100\",\n \"msg_from\": \"Haribabu Kommi <kommi.haribabu@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"The following review has been posted through the commitfest application:\\nmake installcheck-world: tested, failed\\nImplements feature: not tested\\nSpec compliant: not tested\\nDocumentation: not tested\\n\\nHi,\\r\\nI haven't read through the thread yet, just tried to apply the patch and run tests.\\r\\nAnd it seems that the last attached version is outdated now. It doesn't apply to the master\\r\\nand after I've tried to fix merge conflict, it segfaults at initdb. \\r\\n\\r\\nSo, looking forward to a new version for review.\\n\\nThe new status of this patch is: Waiting on Author\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 22 Dec 2016 15:15:27 +0000\",\n \"msg_from\": \"Anastasia Lubennikova <lubennikovaav@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\\n<lubennikovaav@gmail.com> wrote:\\n> The following review has been posted through the commitfest application:\\n> make installcheck-world: tested, failed\\n> Implements feature: not tested\\n> Spec compliant: not tested\\n> Documentation: not tested\\n>\\n> Hi,\\n> I haven't read through the thread yet, just tried to apply the patch and run tests.\\n> And it seems that the last attached version is outdated now. It doesn't apply to the master\\n> and after I've tried to fix merge conflict, it segfaults at initdb.\\n\\n\\nI'll rebase when I get some time to do it and post an updated version\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 22 Dec 2016 12:22:25 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Dec 22, 2016 at 12:22 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\\n> <lubennikovaav@gmail.com> wrote:\\n>> The following review has been posted through the commitfest application:\\n>> make installcheck-world: tested, failed\\n>> Implements feature: not tested\\n>> Spec compliant: not tested\\n>> Documentation: not tested\\n>>\\n>> Hi,\\n>> I haven't read through the thread yet, just tried to apply the patch and run tests.\\n>> And it seems that the last attached version is outdated now. It doesn't apply to the master\\n>> and after I've tried to fix merge conflict, it segfaults at initdb.\\n>\\n>\\n> I'll rebase when I get some time to do it and post an updated version\\n\\nAttached rebased patches. I called them both v3 to be consistent.\\n\\nI'm not sure how you ran it, but this works fine for me:\\n\\n./configure --enable-debug --enable-cassert\\nmake clean\\nmake check\\n\\n... after a while ...\\n\\n=======================\\n All 168 tests passed.\\n=======================\\n\\nI reckon the above is equivalent to installcheck, but doesn't require\\nsudo or actually installing the server, so installcheck should work\\nassuming the install went ok.\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 22 Dec 2016 15:18:07 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"22.12.2016 21:18, Claudio Freire:\\n> On Thu, Dec 22, 2016 at 12:22 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\\n>> <lubennikovaav@gmail.com> wrote:\\n>>> The following review has been posted through the commitfest application:\\n>>> make installcheck-world: tested, failed\\n>>> Implements feature: not tested\\n>>> Spec compliant: not tested\\n>>> Documentation: not tested\\n>>>\\n>>> Hi,\\n>>> I haven't read through the thread yet, just tried to apply the patch and run tests.\\n>>> And it seems that the last attached version is outdated now. It doesn't apply to the master\\n>>> and after I've tried to fix merge conflict, it segfaults at initdb.\\n>>\\n>> I'll rebase when I get some time to do it and post an updated version\\n> Attached rebased patches. I called them both v3 to be consistent.\\n>\\n> I'm not sure how you ran it, but this works fine for me:\\n>\\n> ./configure --enable-debug --enable-cassert\\n> make clean\\n> make check\\n>\\n> ... after a while ...\\n>\\n> =======================\\n> All 168 tests passed.\\n> =======================\\n>\\n> I reckon the above is equivalent to installcheck, but doesn't require\\n> sudo or actually installing the server, so installcheck should work\\n> assuming the install went ok.\\n\\nI found the reason. I configure postgres with CFLAGS=\\\"-O0\\\" and it causes \\nSegfault on initdb.\\nIt works fine and passes tests with default configure flags, but I'm \\npretty sure that we should fix segfault before testing the feature.\\nIf you need it, I'll send a core dump.\\n\\n-- \\nAnastasia Lubennikova\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 23 Dec 2016 19:39:02 +0300\",\n \"msg_from\": \"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n>> On Thu, Dec 22, 2016 at 12:22 PM, Claudio Freire <klaussfreire@gmail.com>\\n>> wrote:\\n>>>\\n>>> On Thu, Dec 22, 2016 at 12:15 PM, Anastasia Lubennikova\\n>>> <lubennikovaav@gmail.com> wrote:\\n>>>>\\n>>>> The following review has been posted through the commitfest application:\\n>>>> make installcheck-world: tested, failed\\n>>>> Implements feature: not tested\\n>>>> Spec compliant: not tested\\n>>>> Documentation: not tested\\n>>>>\\n>>>> Hi,\\n>>>> I haven't read through the thread yet, just tried to apply the patch and\\n>>>> run tests.\\n>>>> And it seems that the last attached version is outdated now. It doesn't\\n>>>> apply to the master\\n>>>> and after I've tried to fix merge conflict, it segfaults at initdb.\\n>>>\\n>>>\\n>>> I'll rebase when I get some time to do it and post an updated version\\n>>\\n>> Attached rebased patches. I called them both v3 to be consistent.\\n>>\\n>> I'm not sure how you ran it, but this works fine for me:\\n>>\\n>> ./configure --enable-debug --enable-cassert\\n>> make clean\\n>> make check\\n>>\\n>> ... after a while ...\\n>>\\n>> =======================\\n>> All 168 tests passed.\\n>> =======================\\n>>\\n>> I reckon the above is equivalent to installcheck, but doesn't require\\n>> sudo or actually installing the server, so installcheck should work\\n>> assuming the install went ok.\\n>\\n>\\n> I found the reason. I configure postgres with CFLAGS=\\\"-O0\\\" and it causes\\n> Segfault on initdb.\\n> It works fine and passes tests with default configure flags, but I'm pretty\\n> sure that we should fix segfault before testing the feature.\\n> If you need it, I'll send a core dump.\\n\\nI just ran it with CFLAGS=\\\"-O0\\\" and it passes all checks too:\\n\\nCFLAGS='-O0' ./configure --enable-debug --enable-cassert\\nmake clean && make -j8 && make check-world\\n\\nA stacktrace and a thorough description of your build environment\\nwould be helpful to understand why it breaks on your system.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 23 Dec 2016 16:54:27 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"23.12.2016 22:54, Claudio Freire:\\n> On Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\\n> <a.lubennikova@postgrespro.ru> wrote:\\n>> I found the reason. I configure postgres with CFLAGS=\\\"-O0\\\" and it causes\\n>> Segfault on initdb.\\n>> It works fine and passes tests with default configure flags, but I'm pretty\\n>> sure that we should fix segfault before testing the feature.\\n>> If you need it, I'll send a core dump.\\n> I just ran it with CFLAGS=\\\"-O0\\\" and it passes all checks too:\\n>\\n> CFLAGS='-O0' ./configure --enable-debug --enable-cassert\\n> make clean && make -j8 && make check-world\\n>\\n> A stacktrace and a thorough description of your build environment\\n> would be helpful to understand why it breaks on your system.\\n\\nI ran configure using following set of flags:\\n ./configure --enable-tap-tests --enable-cassert --enable-debug \\n--enable-depend CFLAGS=\\\"-O0 -g3 -fno-omit-frame-pointer\\\"\\nAnd then ran make check. Here is the stacktrace:\\n\\nProgram terminated with signal SIGSEGV, Segmentation fault.\\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360, \\nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n1417 tblk = \\nItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n(gdb) bt\\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360, \\nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n#1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9, \\nvacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\\\001')\\n at vacuumlazy.c:1337\\n#2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9, \\nparams=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\\n#3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, \\noptions=9, params=0x7ffe0f866310) at vacuum.c:1418\\n#4 0x0000000000690122 in vacuum (options=9, relation=0x0, relid=0, \\nparams=0x7ffe0f866310, va_cols=0x0, bstrategy=0x1f1c4a8,\\n isTopLevel=1 '\\\\001') at vacuum.c:320\\n#5 0x000000000068fd0b in vacuum (options=-1652367447, relation=0x0, \\nrelid=3324614038, params=0x1f11bf0, va_cols=0xb59f63,\\n bstrategy=0x1f1c620, isTopLevel=0 '\\\\000') at vacuum.c:150\\n#6 0x0000000000852993 in standard_ProcessUtility (parsetree=0x1f07e60, \\nqueryString=0x1f07468 \\\"VACUUM FREEZE;\\\\n\\\",\\n context=PROCESS_UTILITY_TOPLEVEL, params=0x0, dest=0xea5cc0 \\n<debugtupDR>, completionTag=0x7ffe0f866750 \\\"\\\") at utility.c:669\\n#7 0x00000000008520da in standard_ProcessUtility \\n(parsetree=0x401ef6cd8, queryString=0x18 <error: Cannot access memory at \\naddress 0x18>,\\n context=PROCESS_UTILITY_TOPLEVEL, params=0x68, dest=0x9e5d62 \\n<AllocSetFree+60>, completionTag=0x7ffe0f8663f0 \\\"`~\\\\360\\\\001\\\")\\n at utility.c:360\\n#8 0x0000000000851161 in PortalRunMulti (portal=0x7ffe0f866750, \\nisTopLevel=0 '\\\\000', setHoldSnapshot=-39 '\\\\331',\\n dest=0x851161 <PortalRunMulti+19>, altdest=0x7ffe0f8664f0, \\ncompletionTag=0x1f07e60 \\\"\\\\341\\\\002\\\") at pquery.c:1219\\n#9 0x0000000000851374 in PortalRunMulti (portal=0x1f0a488, isTopLevel=1 \\n'\\\\001', setHoldSnapshot=0 '\\\\000', dest=0xea5cc0 <debugtupDR>,\\n altdest=0xea5cc0 <debugtupDR>, completionTag=0x7ffe0f866750 \\\"\\\") at \\npquery.c:1345\\n#10 0x0000000000850889 in PortalRun (portal=0x1f0a488, \\ncount=9223372036854775807, isTopLevel=1 '\\\\001', dest=0xea5cc0 <debugtupDR>,\\n altdest=0xea5cc0 <debugtupDR>, completionTag=0x7ffe0f866750 \\\"\\\") at \\npquery.c:824\\n#11 0x000000000084a4dc in exec_simple_query (query_string=0x1f07468 \\n\\\"VACUUM FREEZE;\\\\n\\\") at postgres.c:1113\\n#12 0x000000000084e960 in PostgresMain (argc=10, argv=0x1e60a50, \\ndbname=0x1e823b0 \\\"template1\\\", username=0x1e672a0 \\\"anastasia\\\")\\n at postgres.c:4091\\n#13 0x00000000006f967e in init_locale (categoryname=0x100000000000000 \\n<error: Cannot access memory at address 0x100000000000000>,\\n category=32766, locale=0xa004692f0 <error: Cannot access memory at \\naddress 0xa004692f0>) at main.c:310\\n#14 0x00007f1e5f463830 in __libc_start_main (main=0x6f93e1 <main+85>, \\nargc=10, argv=0x7ffe0f866a78, init=<optimized out>,\\n fini=<optimized out>, rtld_fini=<optimized out>, \\nstack_end=0x7ffe0f866a68) at ../csu/libc-start.c:291\\n#15 0x0000000000469319 in _start ()\\n\\ncore file is quite big, so I didn't attach it to the mail. You can \\ndownload it here: core dump file \\n<https://drive.google.com/open?id=0B-7gUWL5Lg_gX3VlSXBaZzlKTlk>.\\n\\nHere are some notes about the first patch:\\n\\n1. prefetchBlkno = blkno & ~0x1f;\\n prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\\n\\nI didn't get it what for we need these tricks. How does it differ from:\\nprefetchBlkno = (blkno > 32) ? blkno - 32 : 0;\\n\\n2. Why do we decrease prefetchBlckno twice?\\n\\nHere:\\n+ prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\\nAnd here:\\nif (prefetchBlkno >= 32)\\n+ prefetchBlkno -= 32;\\n\\n\\nI'll inspect second patch in a few days and write questions about it.\\n\\n-- \\nAnastasia Lubennikova\\nPostgres Professional:http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n\\n\\n\\n\\n\\n 23.12.2016 22:54, Claudio Freire:\\n\\nOn Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n\\n\\nI found the reason. I configure postgres with CFLAGS=\\\"-O0\\\" and it causes\\nSegfault on initdb.\\nIt works fine and passes tests with default configure flags, but I'm pretty\\nsure that we should fix segfault before testing the feature.\\nIf you need it, I'll send a core dump.\\n\\n\\nI just ran it with CFLAGS=\\\"-O0\\\" and it passes all checks too:\\n\\nCFLAGS='-O0' ./configure --enable-debug --enable-cassert\\nmake clean && make -j8 && make check-world\\n\\nA stacktrace and a thorough description of your build environment\\nwould be helpful to understand why it breaks on your system.\\n\\n\\n\\n I ran configure using following set of flags:\\n ./configure --enable-tap-tests --enable-cassert --enable-debug\\n --enable-depend CFLAGS=\\\"-O0 -g3 -fno-omit-frame-pointer\\\"\\n And then ran make check. Here is the stacktrace:\\n\\n Program terminated with signal SIGSEGV, Segmentation fault.\\n #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n 1417 tblk =\\n ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n (gdb) bt\\n #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360,\\n options=9, vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2,\\n aggressive=1 '\\\\001')\\n at vacuumlazy.c:1337\\n #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360,\\n options=9, params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at\\n vacuumlazy.c:290\\n #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0,\\n options=9, params=0x7ffe0f866310) at vacuum.c:1418\\n #4 0x0000000000690122 in vacuum (options=9, relation=0x0, relid=0,\\n params=0x7ffe0f866310, va_cols=0x0, bstrategy=0x1f1c4a8, \\n isTopLevel=1 '\\\\001') at vacuum.c:320\\n #5 0x000000000068fd0b in vacuum (options=-1652367447, relation=0x0,\\n relid=3324614038, params=0x1f11bf0, va_cols=0xb59f63, \\n bstrategy=0x1f1c620, isTopLevel=0 '\\\\000') at vacuum.c:150\\n #6 0x0000000000852993 in standard_ProcessUtility\\n (parsetree=0x1f07e60, queryString=0x1f07468 \\\"VACUUM FREEZE;\\\\n\\\", \\n context=PROCESS_UTILITY_TOPLEVEL, params=0x0, dest=0xea5cc0\\n <debugtupDR>, completionTag=0x7ffe0f866750 \\\"\\\") at\\n utility.c:669\\n #7 0x00000000008520da in standard_ProcessUtility\\n (parsetree=0x401ef6cd8, queryString=0x18 <error: Cannot access\\n memory at address 0x18>, \\n context=PROCESS_UTILITY_TOPLEVEL, params=0x68, dest=0x9e5d62\\n <AllocSetFree+60>, completionTag=0x7ffe0f8663f0 \\\"`~\\\\360\\\\001\\\")\\n at utility.c:360\\n #8 0x0000000000851161 in PortalRunMulti (portal=0x7ffe0f866750,\\n isTopLevel=0 '\\\\000', setHoldSnapshot=-39 '\\\\331', \\n dest=0x851161 <PortalRunMulti+19>, altdest=0x7ffe0f8664f0,\\n completionTag=0x1f07e60 \\\"\\\\341\\\\002\\\") at pquery.c:1219\\n #9 0x0000000000851374 in PortalRunMulti (portal=0x1f0a488,\\n isTopLevel=1 '\\\\001', setHoldSnapshot=0 '\\\\000', dest=0xea5cc0\\n <debugtupDR>, \\n altdest=0xea5cc0 <debugtupDR>,\\n completionTag=0x7ffe0f866750 \\\"\\\") at pquery.c:1345\\n #10 0x0000000000850889 in PortalRun (portal=0x1f0a488,\\n count=9223372036854775807, isTopLevel=1 '\\\\001', dest=0xea5cc0\\n <debugtupDR>, \\n altdest=0xea5cc0 <debugtupDR>,\\n completionTag=0x7ffe0f866750 \\\"\\\") at pquery.c:824\\n #11 0x000000000084a4dc in exec_simple_query (query_string=0x1f07468\\n \\\"VACUUM FREEZE;\\\\n\\\") at postgres.c:1113\\n #12 0x000000000084e960 in PostgresMain (argc=10, argv=0x1e60a50,\\n dbname=0x1e823b0 \\\"template1\\\", username=0x1e672a0 \\\"anastasia\\\")\\n at postgres.c:4091\\n #13 0x00000000006f967e in init_locale\\n (categoryname=0x100000000000000 <error: Cannot access memory at\\n address 0x100000000000000>, \\n category=32766, locale=0xa004692f0 <error: Cannot access\\n memory at address 0xa004692f0>) at main.c:310\\n #14 0x00007f1e5f463830 in __libc_start_main (main=0x6f93e1\\n <main+85>, argc=10, argv=0x7ffe0f866a78, init=<optimized\\n out>, \\n fini=<optimized out>, rtld_fini=<optimized out>,\\n stack_end=0x7ffe0f866a68) at ../csu/libc-start.c:291\\n #15 0x0000000000469319 in _start ()\\n\\n core file is quite big, so I didn't attach it to the mail. You can\\n download it here: core\\n dump file.\\n\\n Here are some notes about the first patch:\\n\\n 1. prefetchBlkno = blkno & ~0x1f;\\n prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 :\\n 0;\\n\\n I didn't get it what for we need these tricks. How does it differ\\n from:\\n prefetchBlkno = (blkno > 32) ? blkno - 32 : 0;\\n\\n 2. Why do we decrease prefetchBlckno twice?\\n\\n Here:\\n + prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 :\\n 0;\\n And here:\\n if (prefetchBlkno >= 32)\\n + prefetchBlkno -= 32;\\n \\n\\n I'll inspect second patch in a few days and write questions about\\n it.\\n\\n-- \\nAnastasia Lubennikova\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\",\n \"msg_date\": \"Tue, 27 Dec 2016 16:41:45 +0300\",\n \"msg_from\": \"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Anastasia Lubennikova wrote:\\n\\n> I ran configure using following set of flags:\\n> ./configure --enable-tap-tests --enable-cassert --enable-debug\\n> --enable-depend CFLAGS=\\\"-O0 -g3 -fno-omit-frame-pointer\\\"\\n> And then ran make check. Here is the stacktrace:\\n> \\n> Program terminated with signal SIGSEGV, Segmentation fault.\\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n> 1417 tblk =\\n> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n\\nThis doesn't make sense, since the patch removes the \\\"tupindex\\\"\\nvariable in that function.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 27 Dec 2016 10:54:42 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Dec 27, 2016 at 10:54 AM, Alvaro Herrera\\n<alvherre@2ndquadrant.com> wrote:\\n> Anastasia Lubennikova wrote:\\n>\\n>> I ran configure using following set of flags:\\n>> ./configure --enable-tap-tests --enable-cassert --enable-debug\\n>> --enable-depend CFLAGS=\\\"-O0 -g3 -fno-omit-frame-pointer\\\"\\n>> And then ran make check. Here is the stacktrace:\\n>>\\n>> Program terminated with signal SIGSEGV, Segmentation fault.\\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n>> 1417 tblk =\\n>> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n>\\n> This doesn't make sense, since the patch removes the \\\"tupindex\\\"\\n> variable in that function.\\n\\nThe variable is still there. It just has a slightly different meaning\\n(index within the current segment, rather than global index).\\n\\n\\nOn Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n> 23.12.2016 22:54, Claudio Freire:\\n>\\n> On Fri, Dec 23, 2016 at 1:39 PM, Anastasia Lubennikova\\n> <a.lubennikova@postgrespro.ru> wrote:\\n>\\n> I found the reason. I configure postgres with CFLAGS=\\\"-O0\\\" and it causes\\n> Segfault on initdb.\\n> It works fine and passes tests with default configure flags, but I'm pretty\\n> sure that we should fix segfault before testing the feature.\\n> If you need it, I'll send a core dump.\\n>\\n> I just ran it with CFLAGS=\\\"-O0\\\" and it passes all checks too:\\n>\\n> CFLAGS='-O0' ./configure --enable-debug --enable-cassert\\n> make clean && make -j8 && make check-world\\n>\\n> A stacktrace and a thorough description of your build environment\\n> would be helpful to understand why it breaks on your system.\\n>\\n>\\n> I ran configure using following set of flags:\\n> ./configure --enable-tap-tests --enable-cassert --enable-debug\\n> --enable-depend CFLAGS=\\\"-O0 -g3 -fno-omit-frame-pointer\\\"\\n> And then ran make check. Here is the stacktrace:\\n\\nSame procedure runs fine on my end.\\n\\n> core file is quite big, so I didn't attach it to the mail. You can download it here: core dump file.\\n\\nCan you attach your binary as well? (it needs to be identical to be\\nable to inspect the core dump, and quite clearly my build is\\ndifferent)\\n\\nI'll keep looking for ways it could crash there, but being unable to\\nreproduce the crash is a big hindrance, so if you can send the binary\\nthat could help speed things up.\\n\\n\\nOn Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n> 1. prefetchBlkno = blkno & ~0x1f;\\n> prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\\n>\\n> I didn't get it what for we need these tricks. How does it differ from:\\n> prefetchBlkno = (blkno > 32) ? blkno - 32 : 0;\\n\\nIt makes all prefetches ranges of 32 blocks aligned to 32-block boundaries.\\n\\nIt helps since it's at 32 block boundaries that the truncate stops to\\ncheck for locking conflicts and abort, guaranteeing no prefetch will\\nbe needless (if it goes into that code it *will* read the next 32\\nblocks).\\n\\n> 2. Why do we decrease prefetchBlckno twice?\\n>\\n> Here:\\n> + prefetchBlkno = (prefetchBlkno > 32) ? prefetchBlkno - 32 : 0;\\n> And here:\\n> if (prefetchBlkno >= 32)\\n> + prefetchBlkno -= 32;\\n\\nThe first one is outside the loop, it's finding the first prefetch\\nrange that is boundary aligned, taking care not to cause underflow.\\n\\nThe second one is inside the loop, it's moving the prefetch window\\ndown as the truncate moves along. Since it's already aligned, it\\ndoesn't need to be realigned, just clamped to zero if it happens to\\nreach the bottom.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 27 Dec 2016 14:04:12 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n> Program terminated with signal SIGSEGV, Segmentation fault.\\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n> 1417 tblk =\\n> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n> (gdb) bt\\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n> #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\\n> vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\\\001')\\n> at vacuumlazy.c:1337\\n> #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\\n> params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\\n> #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\\n> params=0x7ffe0f866310) at vacuum.c:1418\\n\\n\\nThose line numbers don't match my code.\\n\\nWhich commit are you based on?\\n\\nMy tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 27 Dec 2016 14:14:39 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"27.12.2016 16:54, Alvaro Herrera:\\n> Anastasia Lubennikova wrote:\\n>\\n>> I ran configure using following set of flags:\\n>> ./configure --enable-tap-tests --enable-cassert --enable-debug\\n>> --enable-depend CFLAGS=\\\"-O0 -g3 -fno-omit-frame-pointer\\\"\\n>> And then ran make check. Here is the stacktrace:\\n>>\\n>> Program terminated with signal SIGSEGV, Segmentation fault.\\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n>> 1417 tblk =\\n>> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n> This doesn't make sense, since the patch removes the \\\"tupindex\\\"\\n> variable in that function.\\n>\\n\\nSorry, I didn't get what you mean.\\n\\nIn 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\\n\\n- tupindex = 0;\\n- while (tupindex < vacrelstats->num_dead_tuples)\\n+ segindex = 0;\\n+ tottuples = 0;\\n+ for (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; \\ntupindex = 0, segindex++)\\n {\\n\\nvariable is still there, it was just moved to the loop.\\n\\n-- \\nAnastasia Lubennikova\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 28 Dec 2016 15:37:04 +0300\",\n \"msg_from\": \"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"27.12.2016 20:14, Claudio Freire:\\n> On Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\\n> <a.lubennikova@postgrespro.ru> wrote:\\n>> Program terminated with signal SIGSEGV, Segmentation fault.\\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n>> 1417 tblk =\\n>> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n>> (gdb) bt\\n>> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n>> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n>> #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\\n>> vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\\\001')\\n>> at vacuumlazy.c:1337\\n>> #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\\n>> params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\\n>> #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\\n>> params=0x7ffe0f866310) at vacuum.c:1418\\n> Those line numbers don't match my code.\\n>\\n> Which commit are you based on?\\n>\\n> My tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\\n\\nHm, my branch is based on 71f996d22125eb6cfdbee6094f44370aa8dec610 as well.\\nI merely applied patches \\n0001-Vacuum-prefetch-buffers-on-backward-scan-v3.patch\\nand 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\\nthen ran configure and make as usual.\\nAm I doing something wrong?\\n\\nAnyway, I found the problem that had caused segfault.\\n\\nfor (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; \\ntupindex = 0, segindex++)\\n{\\n DeadTuplesSegment *seg = \\n&(vacrelstats->dead_tuples.dead_tuples[segindex]);\\n int num_dead_tuples = seg->num_dead_tuples;\\n\\n while (tupindex < num_dead_tuples)\\n ...\\n\\nYou rely on the value of tupindex here, while during the very first pass \\nthe 'tupindex' variable\\nmay contain any garbage. And it happend that on my system there was \\nnegative value\\nas I found inspecting core dump:\\n\\n(gdb) info locals\\nnum_dead_tuples = 5\\ntottuples = 0\\ntupindex = -1819017215\\n\\nWhich leads to failure in the next line\\n tblk = ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n\\nThe solution is to move this assignment inside the cycle.\\n\\nI've read the second patch.\\n\\n1. What is the reason to inline vac_cmp_itemptr() ?\\n\\n2. +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage, (128<<20) / \\nsizeof(ItemPointerData))\\nWhat does 128<<20 mean? Why not 1<<27? I'd ask you to replace it with \\nnamed constant,\\nor at least add a comment.\\n\\nI'll share my results of performance testing it in a few days.\\n\\n-- \\nAnastasia Lubennikova\\nPostgres Professional:http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n\\n\\n\\n\\n\\n 27.12.2016 20:14, Claudio Freire:\\n\\nOn Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n\\n\\nProgram terminated with signal SIGSEGV, Segmentation fault.\\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n1417 tblk =\\nItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n(gdb) bt\\n#0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\nvacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n#1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\\nvacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\\\001')\\n at vacuumlazy.c:1337\\n#2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\\nparams=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\\n#3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\\nparams=0x7ffe0f866310) at vacuum.c:1418\\n\\n\\n\\nThose line numbers don't match my code.\\n\\nWhich commit are you based on?\\n\\nMy tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\\n\\n\\n\\n Hm, my branch is based on 71f996d22125eb6cfdbee6094f44370aa8dec610\\n as well.\\n I merely applied patches\\n 0001-Vacuum-prefetch-buffers-on-backward-scan-v3.patch\\n and 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\\n then ran configure and make as usual.\\n Am I doing something wrong?\\n\\n Anyway, I found the problem that had caused segfault.\\n\\n for (segindex = 0; segindex <=\\n vacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\\n {\\n DeadTuplesSegment *seg =\\n &(vacrelstats->dead_tuples.dead_tuples[segindex]);\\n int num_dead_tuples = seg->num_dead_tuples;\\n\\n while (tupindex < num_dead_tuples)\\n ...\\n\\n You rely on the value of tupindex here, while during the very first\\n pass the 'tupindex' variable\\n may contain any garbage. And it happend that on my system there was\\n negative value\\n as I found inspecting core dump:\\n\\n (gdb) info locals \\n num_dead_tuples = 5\\n tottuples = 0\\n tupindex = -1819017215\\n\\n Which leads to failure in the next line\\n tblk =\\n ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n\\n The solution is to move this assignment inside the cycle.\\n\\n I've read the second patch. \\n\\n 1. What is the reason to inline vac_cmp_itemptr() ?\\n\\n 2. +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage,\\n (128<<20) / sizeof(ItemPointerData))\\n What does 128<<20 mean? Why not 1<<27? I'd ask you to\\n replace it with named constant,\\n or at least add a comment.\\n\\n I'll share my results of performance testing it in a few days.\\n-- \\nAnastasia Lubennikova\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\",\n \"msg_date\": \"Wed, 28 Dec 2016 16:26:54 +0300\",\n \"msg_from\": \"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Dec 28, 2016 at 10:26 AM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n> 27.12.2016 20:14, Claudio Freire:\\n>\\n> On Tue, Dec 27, 2016 at 10:41 AM, Anastasia Lubennikova\\n> <a.lubennikova@postgrespro.ru> wrote:\\n>\\n> Program terminated with signal SIGSEGV, Segmentation fault.\\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n> 1417 tblk =\\n> ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n> (gdb) bt\\n> #0 0x00000000006941e7 in lazy_vacuum_heap (onerel=0x1ec2360,\\n> vacrelstats=0x1ef6e00) at vacuumlazy.c:1417\\n> #1 0x0000000000693dfe in lazy_scan_heap (onerel=0x1ec2360, options=9,\\n> vacrelstats=0x1ef6e00, Irel=0x1ef7168, nindexes=2, aggressive=1 '\\\\001')\\n> at vacuumlazy.c:1337\\n> #2 0x0000000000691e66 in lazy_vacuum_rel (onerel=0x1ec2360, options=9,\\n> params=0x7ffe0f866310, bstrategy=0x1f1c4a8) at vacuumlazy.c:290\\n> #3 0x000000000069191f in vacuum_rel (relid=1247, relation=0x0, options=9,\\n> params=0x7ffe0f866310) at vacuum.c:1418\\n>\\n> Those line numbers don't match my code.\\n>\\n> Which commit are you based on?\\n>\\n> My tree is (currently) based on 71f996d22125eb6cfdbee6094f44370aa8dec610\\n>\\n>\\n> Hm, my branch is based on 71f996d22125eb6cfdbee6094f44370aa8dec610 as well.\\n> I merely applied patches\\n> 0001-Vacuum-prefetch-buffers-on-backward-scan-v3.patch\\n> and 0002-Vacuum-allow-using-more-than-1GB-work-mem-v3.patch\\n> then ran configure and make as usual.\\n> Am I doing something wrong?\\n\\nDoesn't sound wrong. Maybe it's my tree the unclean one. I'll have to\\ndo a clean checkout to verify.\\n\\n> Anyway, I found the problem that had caused segfault.\\n>\\n> for (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; tupindex =\\n> 0, segindex++)\\n> {\\n> DeadTuplesSegment *seg =\\n> &(vacrelstats->dead_tuples.dead_tuples[segindex]);\\n> int num_dead_tuples = seg->num_dead_tuples;\\n>\\n> while (tupindex < num_dead_tuples)\\n> ...\\n>\\n> You rely on the value of tupindex here, while during the very first pass the\\n> 'tupindex' variable\\n> may contain any garbage. And it happend that on my system there was negative\\n> value\\n> as I found inspecting core dump:\\n>\\n> (gdb) info locals\\n> num_dead_tuples = 5\\n> tottuples = 0\\n> tupindex = -1819017215\\n>\\n> Which leads to failure in the next line\\n> tblk = ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n>\\n> The solution is to move this assignment inside the cycle.\\n\\nGood catch. I read that line suspecting that very same thing but\\nsomehow I was blind to it.\\n\\n> I've read the second patch.\\n>\\n> 1. What is the reason to inline vac_cmp_itemptr() ?\\n\\nPerformance, mostly. By inlining some transformations can be applied\\nthat wouldn't be possible otherwise. During the binary search, this\\nmatters performance-wise.\\n\\n> 2. +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage, (128<<20) /\\n> sizeof(ItemPointerData))\\n> What does 128<<20 mean? Why not 1<<27? I'd ask you to replace it with named\\n> constant,\\n> or at least add a comment.\\n\\nI tought it was more readable like that, since 1<<20 is known to be\\n\\\"MB\\\", that reads as \\\"128 MB\\\".\\n\\nI guess I can add a comment saying so.\\n\\n> I'll share my results of performance testing it in a few days.\\n\\nThanks\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 28 Dec 2016 15:41:20 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Dec 28, 2016 at 3:41 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> Anyway, I found the problem that had caused segfault.\\n>>\\n>> for (segindex = 0; segindex <= vacrelstats->dead_tuples.last_seg; tupindex =\\n>> 0, segindex++)\\n>> {\\n>> DeadTuplesSegment *seg =\\n>> &(vacrelstats->dead_tuples.dead_tuples[segindex]);\\n>> int num_dead_tuples = seg->num_dead_tuples;\\n>>\\n>> while (tupindex < num_dead_tuples)\\n>> ...\\n>>\\n>> You rely on the value of tupindex here, while during the very first pass the\\n>> 'tupindex' variable\\n>> may contain any garbage. And it happend that on my system there was negative\\n>> value\\n>> as I found inspecting core dump:\\n>>\\n>> (gdb) info locals\\n>> num_dead_tuples = 5\\n>> tottuples = 0\\n>> tupindex = -1819017215\\n>>\\n>> Which leads to failure in the next line\\n>> tblk = ItemPointerGetBlockNumber(&seg->dead_tuples[tupindex]);\\n>>\\n>> The solution is to move this assignment inside the cycle.\\n>\\n> Good catch. I read that line suspecting that very same thing but\\n> somehow I was blind to it.\\n\\nAttached v4 patches with the requested fixes.\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 28 Dec 2016 17:43:21 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"28.12.2016 23:43, Claudio Freire:\\n> Attached v4 patches with the requested fixes.\\n\\nSorry for being late, but the tests took a lot of time.\\n\\ncreate table t1 as select i, md5(random()::text) from generate_series(0,400000000) as i;\\ncreate index md5_idx ON t1(md5);\\nupdate t1 set md5 = md5((random() * (100 + 500))::text);\\nvacuum;\\n\\nPatched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\\nwhile for old version it took three passes (1GB+1GB+0.9GB).\\nVacuum duration results:\\n\\nvanilla:\\nLOG: duration: 4359006.327 ms statement: vacuum verbose t1;\\npatched:\\nLOG: duration: 3076827.378 ms statement: vacuum verbose t1;\\n\\nWe can see 30% vacuum speedup. I should note that this case can be \\nconsidered\\nas favorable to vanilla vacuum: the table is not that big, it has just \\none index\\nand disk used is a fast fusionIO. We can expect even more gain on slower \\ndisks.\\n\\nThank you again for the patch. Hope to see it in 10.0.\\n\\n-- \\nAnastasia Lubennikova\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n\\n\\n\\n\\n\\n 28.12.2016 23:43, Claudio Freire:\\n\\nAttached v4 patches with the requested fixes.\\n\\n\\n\\n Sorry for being late, but the tests took a lot of time.\\ncreate table t1 as select i, md5(random()::text) from generate_series(0,400000000) as i;\\ncreate index md5_idx ON t1(md5);\\nupdate t1 set md5 = md5((random() * (100 + 500))::text);\\nvacuum;\\n\\n Patched vacuum used 2.9Gb of memory and vacuumed the index in one\\n pass,\\n while for old version it took three passes (1GB+1GB+0.9GB).\\n Vacuum duration results:\\nvanilla:\\nLOG: duration: 4359006.327 ms statement: vacuum verbose t1;\\npatched:\\nLOG: duration: 3076827.378 ms statement: vacuum verbose t1;\\n\\n\\n We can see 30% vacuum speedup. I should note that this case can be\\n considered\\n as favorable to vanilla vacuum: the table is not that big, it has\\n just one index\\n and disk used is a fast fusionIO. We can expect even more gain on\\n slower disks.\\n\\n Thank you again for the patch. Hope to see it in 10.0.\\n-- \\nAnastasia Lubennikova\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\",\n \"msg_date\": \"Thu, 19 Jan 2017 12:33:57 +0300\",\n \"msg_from\": \"Anastasia Lubennikova <a.lubennikova@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\\n<a.lubennikova@postgrespro.ru> wrote:\\n> 28.12.2016 23:43, Claudio Freire:\\n>\\n> Attached v4 patches with the requested fixes.\\n>\\n>\\n> Sorry for being late, but the tests took a lot of time.\\n\\nI know. Takes me several days to run my test scripts once.\\n\\n> create table t1 as select i, md5(random()::text) from\\n> generate_series(0,400000000) as i;\\n> create index md5_idx ON t1(md5);\\n> update t1 set md5 = md5((random() * (100 + 500))::text);\\n> vacuum;\\n>\\n> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\\n> while for old version it took three passes (1GB+1GB+0.9GB).\\n> Vacuum duration results:\\n>\\n> vanilla:\\n> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\\n> patched:\\n> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\\n>\\n> We can see 30% vacuum speedup. I should note that this case can be\\n> considered\\n> as favorable to vanilla vacuum: the table is not that big, it has just one\\n> index\\n> and disk used is a fast fusionIO. We can expect even more gain on slower\\n> disks.\\n>\\n> Thank you again for the patch. Hope to see it in 10.0.\\n\\nCool. Thanks for the review and the tests.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 19 Jan 2017 08:31:54 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jan 19, 2017 at 8:31 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\\n> <a.lubennikova@postgrespro.ru> wrote:\\n>> 28.12.2016 23:43, Claudio Freire:\\n>>\\n>> Attached v4 patches with the requested fixes.\\n>>\\n>>\\n>> Sorry for being late, but the tests took a lot of time.\\n>\\n> I know. Takes me several days to run my test scripts once.\\n>\\n>> create table t1 as select i, md5(random()::text) from\\n>> generate_series(0,400000000) as i;\\n>> create index md5_idx ON t1(md5);\\n>> update t1 set md5 = md5((random() * (100 + 500))::text);\\n>> vacuum;\\n>>\\n>> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\\n>> while for old version it took three passes (1GB+1GB+0.9GB).\\n>> Vacuum duration results:\\n>>\\n>> vanilla:\\n>> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\\n>> patched:\\n>> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\\n>>\\n>> We can see 30% vacuum speedup. I should note that this case can be\\n>> considered\\n>> as favorable to vanilla vacuum: the table is not that big, it has just one\\n>> index\\n>> and disk used is a fast fusionIO. We can expect even more gain on slower\\n>> disks.\\n>>\\n>> Thank you again for the patch. Hope to see it in 10.0.\\n>\\n> Cool. Thanks for the review and the tests.\\n>\\n\\nI encountered a bug with following scenario.\\n1. Create table and disable autovacuum on that table.\\n2. Make about 200000 dead tuples on the table.\\n3. SET maintenance_work_mem TO 1024\\n4. VACUUM\\n\\n@@ -729,7 +759,7 @@ lazy_scan_heap(Relation onerel, int options,\\nLVRelStats *vacrelstats,\\n * not to reset latestRemovedXid since we want\\nthat value to be\\n * valid.\\n */\\n- vacrelstats->num_dead_tuples = 0;\\n+ lazy_clear_dead_tuples(vacrelstats);\\n vacrelstats->num_index_scans++;\\n\\n /* Report that we are once again scanning the heap */\\n\\nI think that we should do vacrelstats->dead_tuples.num_entries = 0 as\\nwell in lazy_clear_dead_tuples(). Once the amount of dead tuples\\nreached to maintenance_work_mem, lazy_scan_heap can never finish.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 20 Jan 2017 18:24:58 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"You posted two patches with this preamble:\\n\\nClaudio Freire wrote:\\n\\n> Attached is the raw output of the test, the script used to create it,\\n> and just in case the patch set used. I believe it's the same as the\\n> last one I posted, just rebased.\\n\\nThere was no discussion whatsoever of the \\\"prefetch\\\" patch in this\\nthread; and as far as I can see, nobody even mentioned such an idea in\\nthe thread. This prefetch patch appeared out of the blue and there was\\nno discussion about it that I can see. Now I was about to push it after\\nsome minor tweaks, and went to search where was its justification, only\\nto see that there was none. Did anybody run tests with this patch?\\n\\nI attach it now one more time. My version is based on the latest\\nClaudio posted at\\nhttps://postgr.es/m/CAGTBQpa464RugxYwxLTtDi=Syv9GnGFcJK8uZb2fR6NDDqULaw@mail.gmail.com\\nI don't know if there are differences to the version first posted.\\nI only changed the magic number 32 to a #define, and added a\\nCHECK_FOR_INTERRUPTS in the prefetching loop.\\n\\nFWIW, I think this patch is completely separate from the maint_work_mem\\npatch and should have had its own thread and its own commitfest entry.\\nI intend to get a look at the other patch next week, after pushing this\\none.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 20 Jan 2017 18:25:18 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Alvaro Herrera wrote:\\n\\n> There was no discussion whatsoever of the \\\"prefetch\\\" patch in this\\n> thread; and as far as I can see, nobody even mentioned such an idea in\\n> the thread. This prefetch patch appeared out of the blue and there was\\n> no discussion about it that I can see. Now I was about to push it after\\n> some minor tweaks, and went to search where was its justification, only\\n> to see that there was none. Did anybody run tests with this patch?\\n> \\n> I attach it now one more time. My version is based on the latest\\n> Claudio posted at\\n> https://postgr.es/m/CAGTBQpa464RugxYwxLTtDi=Syv9GnGFcJK8uZb2fR6NDDqULaw@mail.gmail.com\\n> I don't know if there are differences to the version first posted.\\n> I only changed the magic number 32 to a #define, and added a\\n> CHECK_FOR_INTERRUPTS in the prefetching loop.\\n\\nAh, I found the justification here:\\nhttps://www.postgresql.org/message-id/flat/CAGTBQpa464RugxYwxLTtDi%3DSyv9GnGFcJK8uZb2fR6NDDqULaw%40mail.gmail.com#CAGTBQpbayY-t5-ySW19yQs1dBqvV6dm8dmdpTv_FWXmDC0A0cQ%40mail.gmail.com\\napparently the truncate scan is 4x-6x faster with this prefetching.\\nNice!\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 20 Jan 2017 18:34:14 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"I pushed this patch after rewriting it rather completely. I added\\ntracing notices to inspect the blocks it was prefetching and observed\\nthat the original coding was failing to prefetch the final streak of\\nblocks in the table, which is an important oversight considering that it\\nmay very well be that those are the only blocks to read at all.\\n\\nI timed vacuuming a 4000-block table in my laptop (single SSD disk;\\ndropped FS caches after deleting all rows in table, so that vacuum has\\nto read all blocks from disk); it changes from 387ms without patch to\\n155ms with patch. I didn't measure how much it takes to run the other\\nsteps in the vacuum, but it's clear that the speedup for the truncation\\nphase is considerable.\\n\\n�Thanks, Claudio!\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 23 Jan 2017 13:06:01 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"I think this patch no longer applies because of conflicts with the one I\\njust pushed. Please rebase.\\n\\nThanks\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 23 Jan 2017 13:07:44 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Jan 20, 2017 at 6:24 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> On Thu, Jan 19, 2017 at 8:31 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\\n>> <a.lubennikova@postgrespro.ru> wrote:\\n>>> 28.12.2016 23:43, Claudio Freire:\\n>>>\\n>>> Attached v4 patches with the requested fixes.\\n>>>\\n>>>\\n>>> Sorry for being late, but the tests took a lot of time.\\n>>\\n>> I know. Takes me several days to run my test scripts once.\\n>>\\n>>> create table t1 as select i, md5(random()::text) from\\n>>> generate_series(0,400000000) as i;\\n>>> create index md5_idx ON t1(md5);\\n>>> update t1 set md5 = md5((random() * (100 + 500))::text);\\n>>> vacuum;\\n>>>\\n>>> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\\n>>> while for old version it took three passes (1GB+1GB+0.9GB).\\n>>> Vacuum duration results:\\n>>>\\n>>> vanilla:\\n>>> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\\n>>> patched:\\n>>> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\\n>>>\\n>>> We can see 30% vacuum speedup. I should note that this case can be\\n>>> considered\\n>>> as favorable to vanilla vacuum: the table is not that big, it has just one\\n>>> index\\n>>> and disk used is a fast fusionIO. We can expect even more gain on slower\\n>>> disks.\\n>>>\\n>>> Thank you again for the patch. Hope to see it in 10.0.\\n>>\\n>> Cool. Thanks for the review and the tests.\\n>>\\n>\\n> I encountered a bug with following scenario.\\n> 1. Create table and disable autovacuum on that table.\\n> 2. Make about 200000 dead tuples on the table.\\n> 3. SET maintenance_work_mem TO 1024\\n> 4. VACUUM\\n>\\n> @@ -729,7 +759,7 @@ lazy_scan_heap(Relation onerel, int options,\\n> LVRelStats *vacrelstats,\\n> * not to reset latestRemovedXid since we want\\n> that value to be\\n> * valid.\\n> */\\n> - vacrelstats->num_dead_tuples = 0;\\n> + lazy_clear_dead_tuples(vacrelstats);\\n> vacrelstats->num_index_scans++;\\n>\\n> /* Report that we are once again scanning the heap */\\n>\\n> I think that we should do vacrelstats->dead_tuples.num_entries = 0 as\\n> well in lazy_clear_dead_tuples(). Once the amount of dead tuples\\n> reached to maintenance_work_mem, lazy_scan_heap can never finish.\\n\\nThat's right.\\n\\nI added a test for it in the attached patch set, which uncovered\\nanother bug in lazy_clear_dead_tuples, and took the opportunity to\\nrebase.\\n\\nOn Mon, Jan 23, 2017 at 1:06 PM, Alvaro Herrera\\n<alvherre@2ndquadrant.com> wrote:\\n> I pushed this patch after rewriting it rather completely. I added\\n> tracing notices to inspect the blocks it was prefetching and observed\\n> that the original coding was failing to prefetch the final streak of\\n> blocks in the table, which is an important oversight considering that it\\n> may very well be that those are the only blocks to read at all.\\n>\\n> I timed vacuuming a 4000-block table in my laptop (single SSD disk;\\n> dropped FS caches after deleting all rows in table, so that vacuum has\\n> to read all blocks from disk); it changes from 387ms without patch to\\n> 155ms with patch. I didn't measure how much it takes to run the other\\n> steps in the vacuum, but it's clear that the speedup for the truncation\\n> phase is considerable.\\n>\\n> ĄThanks, Claudio!\\n\\nCool.\\n\\nThough it wasn't the first time this idea has been floating around, I\\ncan't take all the credit.\\n\\n\\nOn Fri, Jan 20, 2017 at 6:25 PM, Alvaro Herrera\\n<alvherre@2ndquadrant.com> wrote:\\n> FWIW, I think this patch is completely separate from the maint_work_mem\\n> patch and should have had its own thread and its own commitfest entry.\\n> I intend to get a look at the other patch next week, after pushing this\\n> one.\\n\\nThat's because it did have it, and was left in limbo due to lack of\\ntesting on SSDs. I just had to adopt it here because otherwise tests\\ntook way too long.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 23 Jan 2017 13:49:03 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Jan 24, 2017 at 1:49 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Fri, Jan 20, 2017 at 6:24 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> On Thu, Jan 19, 2017 at 8:31 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> On Thu, Jan 19, 2017 at 6:33 AM, Anastasia Lubennikova\\n>>> <a.lubennikova@postgrespro.ru> wrote:\\n>>>> 28.12.2016 23:43, Claudio Freire:\\n>>>>\\n>>>> Attached v4 patches with the requested fixes.\\n>>>>\\n>>>>\\n>>>> Sorry for being late, but the tests took a lot of time.\\n>>>\\n>>> I know. Takes me several days to run my test scripts once.\\n>>>\\n>>>> create table t1 as select i, md5(random()::text) from\\n>>>> generate_series(0,400000000) as i;\\n>>>> create index md5_idx ON t1(md5);\\n>>>> update t1 set md5 = md5((random() * (100 + 500))::text);\\n>>>> vacuum;\\n>>>>\\n>>>> Patched vacuum used 2.9Gb of memory and vacuumed the index in one pass,\\n>>>> while for old version it took three passes (1GB+1GB+0.9GB).\\n>>>> Vacuum duration results:\\n>>>>\\n>>>> vanilla:\\n>>>> LOG: duration: 4359006.327 ms statement: vacuum verbose t1;\\n>>>> patched:\\n>>>> LOG: duration: 3076827.378 ms statement: vacuum verbose t1;\\n>>>>\\n>>>> We can see 30% vacuum speedup. I should note that this case can be\\n>>>> considered\\n>>>> as favorable to vanilla vacuum: the table is not that big, it has just one\\n>>>> index\\n>>>> and disk used is a fast fusionIO. We can expect even more gain on slower\\n>>>> disks.\\n>>>>\\n>>>> Thank you again for the patch. Hope to see it in 10.0.\\n>>>\\n>>> Cool. Thanks for the review and the tests.\\n>>>\\n>>\\n>> I encountered a bug with following scenario.\\n>> 1. Create table and disable autovacuum on that table.\\n>> 2. Make about 200000 dead tuples on the table.\\n>> 3. SET maintenance_work_mem TO 1024\\n>> 4. VACUUM\\n>>\\n>> @@ -729,7 +759,7 @@ lazy_scan_heap(Relation onerel, int options,\\n>> LVRelStats *vacrelstats,\\n>> * not to reset latestRemovedXid since we want\\n>> that value to be\\n>> * valid.\\n>> */\\n>> - vacrelstats->num_dead_tuples = 0;\\n>> + lazy_clear_dead_tuples(vacrelstats);\\n>> vacrelstats->num_index_scans++;\\n>>\\n>> /* Report that we are once again scanning the heap */\\n>>\\n>> I think that we should do vacrelstats->dead_tuples.num_entries = 0 as\\n>> well in lazy_clear_dead_tuples(). Once the amount of dead tuples\\n>> reached to maintenance_work_mem, lazy_scan_heap can never finish.\\n>\\n> That's right.\\n>\\n> I added a test for it in the attached patch set, which uncovered\\n> another bug in lazy_clear_dead_tuples, and took the opportunity to\\n> rebase.\\n>\\n> On Mon, Jan 23, 2017 at 1:06 PM, Alvaro Herrera\\n> <alvherre@2ndquadrant.com> wrote:\\n>> I pushed this patch after rewriting it rather completely. I added\\n>> tracing notices to inspect the blocks it was prefetching and observed\\n>> that the original coding was failing to prefetch the final streak of\\n>> blocks in the table, which is an important oversight considering that it\\n>> may very well be that those are the only blocks to read at all.\\n>>\\n>> I timed vacuuming a 4000-block table in my laptop (single SSD disk;\\n>> dropped FS caches after deleting all rows in table, so that vacuum has\\n>> to read all blocks from disk); it changes from 387ms without patch to\\n>> 155ms with patch. I didn't measure how much it takes to run the other\\n>> steps in the vacuum, but it's clear that the speedup for the truncation\\n>> phase is considerable.\\n>>\\n>> ĄThanks, Claudio!\\n>\\n> Cool.\\n>\\n> Though it wasn't the first time this idea has been floating around, I\\n> can't take all the credit.\\n>\\n>\\n> On Fri, Jan 20, 2017 at 6:25 PM, Alvaro Herrera\\n> <alvherre@2ndquadrant.com> wrote:\\n>> FWIW, I think this patch is completely separate from the maint_work_mem\\n>> patch and should have had its own thread and its own commitfest entry.\\n>> I intend to get a look at the other patch next week, after pushing this\\n>> one.\\n>\\n> That's because it did have it, and was left in limbo due to lack of\\n> testing on SSDs. I just had to adopt it here because otherwise tests\\n> took way too long.\\n\\nThank you for updating the patch!\\n\\n+ /*\\n+ * Quickly rule out by lower bound (should happen a lot) Upper bound was\\n+ * already checked by segment search\\n+ */\\n+ if (vac_cmp_itemptr((void *) itemptr, (void *) rseg->dead_tuples) < 0)\\n+ return false;\\n\\nI think that if the above result is 0, we can return true as itemptr\\nmatched lower bound item pointer in rseg->dead_tuples.\\n\\n +typedef struct DeadTuplesSegment\\n+{\\n+ int num_dead_tuples; /* # of\\nentries in the segment */\\n+ int max_dead_tuples; /* # of\\nentries allocated in the segment */\\n+ ItemPointerData last_dead_tuple; /* Copy of the last\\ndead tuple (unset\\n+\\n * until the segment is fully\\n+\\n * populated) */\\n+ unsigned short padding;\\n+ ItemPointer dead_tuples; /* Array of dead tuples */\\n+} DeadTuplesSegment;\\n+\\n+typedef struct DeadTuplesMultiArray\\n+{\\n+ int num_entries; /* current # of entries */\\n+ int max_entries; /* total # of slots\\nthat can be allocated in\\n+ * array */\\n+ int num_segs; /* number of\\ndead tuple segments allocated */\\n+ int last_seg; /* last dead\\ntuple segment with data (or 0) */\\n+ DeadTuplesSegment *dead_tuples; /* array of num_segs segments */\\n+} DeadTuplesMultiArray;\\n\\nIt's a matter of personal preference but some same dead_tuples\\nvariables having different meaning confused me.\\nIf we want to access first dead tuple location of first segment, we\\nneed to do 'vacrelstats->dead_tuples.dead_tuples.dead_tuples'. For\\nexample, 'vacrelstats->dead_tuples.dt_segment.dt_array' is better to\\nme.\\n\\n\\n+ nseg->num_dead_tuples = 0;\\n+ nseg->max_dead_tuples = 0;\\n+ nseg->dead_tuples = NULL;\\n+ vacrelstats->dead_tuples.num_segs++;\\n+ }\\n+ seg = DeadTuplesCurrentSegment(vacrelstats);\\n+ }\\n+ vacrelstats->dead_tuples.last_seg++;\\n+ seg = DeadTuplesCurrentSegment(vacrelstats);\\n\\nBecause seg is always set later I think the first line starting with\\n\\\"seg = ...\\\" is not necessary. Thought?\\n\\n-- \\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 26 Jan 2017 01:54:08 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Jan 25, 2017 at 1:54 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> Thank you for updating the patch!\\n>\\n> + /*\\n> + * Quickly rule out by lower bound (should happen a lot) Upper bound was\\n> + * already checked by segment search\\n> + */\\n> + if (vac_cmp_itemptr((void *) itemptr, (void *) rseg->dead_tuples) < 0)\\n> + return false;\\n>\\n> I think that if the above result is 0, we can return true as itemptr\\n> matched lower bound item pointer in rseg->dead_tuples.\\n\\nThat's right. Possibly not a great speedup but... why not?\\n\\n>\\n> +typedef struct DeadTuplesSegment\\n> +{\\n> + int num_dead_tuples; /* # of\\n> entries in the segment */\\n> + int max_dead_tuples; /* # of\\n> entries allocated in the segment */\\n> + ItemPointerData last_dead_tuple; /* Copy of the last\\n> dead tuple (unset\\n> +\\n> * until the segment is fully\\n> +\\n> * populated) */\\n> + unsigned short padding;\\n> + ItemPointer dead_tuples; /* Array of dead tuples */\\n> +} DeadTuplesSegment;\\n> +\\n> +typedef struct DeadTuplesMultiArray\\n> +{\\n> + int num_entries; /* current # of entries */\\n> + int max_entries; /* total # of slots\\n> that can be allocated in\\n> + * array */\\n> + int num_segs; /* number of\\n> dead tuple segments allocated */\\n> + int last_seg; /* last dead\\n> tuple segment with data (or 0) */\\n> + DeadTuplesSegment *dead_tuples; /* array of num_segs segments */\\n> +} DeadTuplesMultiArray;\\n>\\n> It's a matter of personal preference but some same dead_tuples\\n> variables having different meaning confused me.\\n> If we want to access first dead tuple location of first segment, we\\n> need to do 'vacrelstats->dead_tuples.dead_tuples.dead_tuples'. For\\n> example, 'vacrelstats->dead_tuples.dt_segment.dt_array' is better to\\n> me.\\n\\nYes, I can see how that could be confusing.\\n\\nI went for vacrelstats->dead_tuples.dt_segments[i].dt_tids[j]\\n\\n> + nseg->num_dead_tuples = 0;\\n> + nseg->max_dead_tuples = 0;\\n> + nseg->dead_tuples = NULL;\\n> + vacrelstats->dead_tuples.num_segs++;\\n> + }\\n> + seg = DeadTuplesCurrentSegment(vacrelstats);\\n> + }\\n> + vacrelstats->dead_tuples.last_seg++;\\n> + seg = DeadTuplesCurrentSegment(vacrelstats);\\n>\\n> Because seg is always set later I think the first line starting with\\n> \\\"seg = ...\\\" is not necessary. Thought?\\n\\nThat's correct.\\n\\nAttached a v6 with those changes (and rebased).\\n\\nMake check still passes.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 25 Jan 2017 17:11:13 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jan 26, 2017 at 5:11 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Jan 25, 2017 at 1:54 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> Thank you for updating the patch!\\n>>\\n>> + /*\\n>> + * Quickly rule out by lower bound (should happen a lot) Upper bound was\\n>> + * already checked by segment search\\n>> + */\\n>> + if (vac_cmp_itemptr((void *) itemptr, (void *) rseg->dead_tuples) < 0)\\n>> + return false;\\n>>\\n>> I think that if the above result is 0, we can return true as itemptr\\n>> matched lower bound item pointer in rseg->dead_tuples.\\n>\\n> That's right. Possibly not a great speedup but... why not?\\n>\\n>>\\n>> +typedef struct DeadTuplesSegment\\n>> +{\\n>> + int num_dead_tuples; /* # of\\n>> entries in the segment */\\n>> + int max_dead_tuples; /* # of\\n>> entries allocated in the segment */\\n>> + ItemPointerData last_dead_tuple; /* Copy of the last\\n>> dead tuple (unset\\n>> +\\n>> * until the segment is fully\\n>> +\\n>> * populated) */\\n>> + unsigned short padding;\\n>> + ItemPointer dead_tuples; /* Array of dead tuples */\\n>> +} DeadTuplesSegment;\\n>> +\\n>> +typedef struct DeadTuplesMultiArray\\n>> +{\\n>> + int num_entries; /* current # of entries */\\n>> + int max_entries; /* total # of slots\\n>> that can be allocated in\\n>> + * array */\\n>> + int num_segs; /* number of\\n>> dead tuple segments allocated */\\n>> + int last_seg; /* last dead\\n>> tuple segment with data (or 0) */\\n>> + DeadTuplesSegment *dead_tuples; /* array of num_segs segments */\\n>> +} DeadTuplesMultiArray;\\n>>\\n>> It's a matter of personal preference but some same dead_tuples\\n>> variables having different meaning confused me.\\n>> If we want to access first dead tuple location of first segment, we\\n>> need to do 'vacrelstats->dead_tuples.dead_tuples.dead_tuples'. For\\n>> example, 'vacrelstats->dead_tuples.dt_segment.dt_array' is better to\\n>> me.\\n>\\n> Yes, I can see how that could be confusing.\\n>\\n> I went for vacrelstats->dead_tuples.dt_segments[i].dt_tids[j]\\n\\nThank you for updating.\\nLooks good to me.\\n\\n>> + nseg->num_dead_tuples = 0;\\n>> + nseg->max_dead_tuples = 0;\\n>> + nseg->dead_tuples = NULL;\\n>> + vacrelstats->dead_tuples.num_segs++;\\n>> + }\\n>> + seg = DeadTuplesCurrentSegment(vacrelstats);\\n>> + }\\n>> + vacrelstats->dead_tuples.last_seg++;\\n>> + seg = DeadTuplesCurrentSegment(vacrelstats);\\n>>\\n>> Because seg is always set later I think the first line starting with\\n>> \\\"seg = ...\\\" is not necessary. Thought?\\n>\\n> That's correct.\\n>\\n> Attached a v6 with those changes (and rebased).\\n>\\n> Make check still passes.\\n\\nHere is review comment of v6 patch.\\n\\n----\\n * We are willing to use at most maintenance_work_mem (or perhaps\\n * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n * initially allocate an array of TIDs of that size, with an upper limit that\\n * depends on table size (this limit ensures we don't allocate a huge area\\n * uselessly for vacuuming small tables). If the array threatens to overflow,\\n\\nI think that we need to update the above paragraph comment at top of\\nvacuumlazy.c file.\\n\\n----\\n+ numtuples = Max(numtuples,\\nMaxHeapTuplesPerPage);\\n+ numtuples = Min(numtuples, INT_MAX / 2);\\n+ numtuples = Min(numtuples, 2 *\\npseg->max_dead_tuples);\\n+ numtuples = Min(numtuples,\\nMaxAllocSize / sizeof(ItemPointerData));\\n+ seg->dt_tids = (ItemPointer)\\npalloc(sizeof(ItemPointerData) * numtuples);\\n\\nWhy numtuples is limited to \\\"INT_MAX / 2\\\" but not INT_MAX?\\n\\n----\\n@@ -1376,35 +1411,43 @@ lazy_vacuum_heap(Relation onerel, LVRelStats\\n*vacrelstats)\\n pg_rusage_init(&ru0);\\n npages = 0;\\n\\n- tupindex = 0;\\n- while (tupindex < vacrelstats->num_dead_tuples)\\n+ segindex = 0;\\n+ tottuples = 0;\\n+ for (segindex = tupindex = 0; segindex <=\\nvacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\\n {\\n- BlockNumber tblk;\\n- Buffer buf;\\n- Page page;\\n- Size freespace;\\n\\nThis is a minute thing but tupindex can be define inside of for loop.\\n\\n----\\n@@ -1129,10 +1159,13 @@ lazy_scan_heap(Relation onerel, int options,\\nLVRelStats *vacrelstats,\\n * instead of doing a second scan.\\n */\\n if (nindexes == 0 &&\\n- vacrelstats->num_dead_tuples > 0)\\n+ vacrelstats->dead_tuples.num_entries > 0)\\n {\\n /* Remove tuples from heap */\\n- lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);\\n+ Assert(vacrelstats->dead_tuples.last_seg == 0); /*\\nShould not need more\\n+ *\\nthan one segment per\\n+ * page */\\n\\nI'm not sure we need to add Assert() here but it seems to me that the\\ncomment and code is not properly correspond and the comment for\\nAssert() should be wrote above of Assert() line.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 30 Jan 2017 17:51:52 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Jan 30, 2017 at 5:51 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> ----\\n> * We are willing to use at most maintenance_work_mem (or perhaps\\n> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n> * initially allocate an array of TIDs of that size, with an upper limit that\\n> * depends on table size (this limit ensures we don't allocate a huge area\\n> * uselessly for vacuuming small tables). If the array threatens to overflow,\\n>\\n> I think that we need to update the above paragraph comment at top of\\n> vacuumlazy.c file.\\n\\nIndeed, I missed that one. Fixing.\\n\\n>\\n> ----\\n> + numtuples = Max(numtuples,\\n> MaxHeapTuplesPerPage);\\n> + numtuples = Min(numtuples, INT_MAX / 2);\\n> + numtuples = Min(numtuples, 2 *\\n> pseg->max_dead_tuples);\\n> + numtuples = Min(numtuples,\\n> MaxAllocSize / sizeof(ItemPointerData));\\n> + seg->dt_tids = (ItemPointer)\\n> palloc(sizeof(ItemPointerData) * numtuples);\\n>\\n> Why numtuples is limited to \\\"INT_MAX / 2\\\" but not INT_MAX?\\n\\nI forgot to mention this one in the OP.\\n\\nGoogling around, I found out some implemetations of bsearch break with\\narray sizes beyond INT_MAX/2 [1] (they'd overflow when computing the\\nmidpoint).\\n\\nBefore this patch, this bsearch call had no way of reaching that size.\\nAn initial version of the patch (the one that allocated a big array\\nwith huge allocation) could reach that point, though, so I reduced the\\nlimit to play it safe. This latest version is back to the starting\\npoint, since it cannot allocate segments bigger than 1GB, but I opted\\nto keep playing it safe and leave the reduced limit just in case.\\n\\n> ----\\n> @@ -1376,35 +1411,43 @@ lazy_vacuum_heap(Relation onerel, LVRelStats\\n> *vacrelstats)\\n> pg_rusage_init(&ru0);\\n> npages = 0;\\n>\\n> - tupindex = 0;\\n> - while (tupindex < vacrelstats->num_dead_tuples)\\n> + segindex = 0;\\n> + tottuples = 0;\\n> + for (segindex = tupindex = 0; segindex <=\\n> vacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\\n> {\\n> - BlockNumber tblk;\\n> - Buffer buf;\\n> - Page page;\\n> - Size freespace;\\n>\\n> This is a minute thing but tupindex can be define inside of for loop.\\n\\nRight, changing.\\n\\n>\\n> ----\\n> @@ -1129,10 +1159,13 @@ lazy_scan_heap(Relation onerel, int options,\\n> LVRelStats *vacrelstats,\\n> * instead of doing a second scan.\\n> */\\n> if (nindexes == 0 &&\\n> - vacrelstats->num_dead_tuples > 0)\\n> + vacrelstats->dead_tuples.num_entries > 0)\\n> {\\n> /* Remove tuples from heap */\\n> - lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);\\n> + Assert(vacrelstats->dead_tuples.last_seg == 0); /*\\n> Should not need more\\n> + *\\n> than one segment per\\n> + * page */\\n>\\n> I'm not sure we need to add Assert() here but it seems to me that the\\n> comment and code is not properly correspond and the comment for\\n> Assert() should be wrote above of Assert() line.\\n\\nWell, that assert is the one that found the second bug in\\nlazy_clear_dead_tuples, so clearly it's not without merit.\\n\\nI'll rearrange the comments as you ask though.\\n\\n\\nUpdated and rebased v7 attached.\\n\\n\\n[1] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=776671\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 30 Jan 2017 23:05:28 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Jan 31, 2017 at 11:05 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> Updated and rebased v7 attached.\\n\\nMoved to CF 2017-03.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 1 Feb 2017 14:22:22 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Jan 31, 2017 at 3:05 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Mon, Jan 30, 2017 at 5:51 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> ----\\n>> * We are willing to use at most maintenance_work_mem (or perhaps\\n>> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n>> * initially allocate an array of TIDs of that size, with an upper limit that\\n>> * depends on table size (this limit ensures we don't allocate a huge area\\n>> * uselessly for vacuuming small tables). If the array threatens to overflow,\\n>>\\n>> I think that we need to update the above paragraph comment at top of\\n>> vacuumlazy.c file.\\n>\\n> Indeed, I missed that one. Fixing.\\n>\\n>>\\n>> ----\\n>> + numtuples = Max(numtuples,\\n>> MaxHeapTuplesPerPage);\\n>> + numtuples = Min(numtuples, INT_MAX / 2);\\n>> + numtuples = Min(numtuples, 2 *\\n>> pseg->max_dead_tuples);\\n>> + numtuples = Min(numtuples,\\n>> MaxAllocSize / sizeof(ItemPointerData));\\n>> + seg->dt_tids = (ItemPointer)\\n>> palloc(sizeof(ItemPointerData) * numtuples);\\n>>\\n>> Why numtuples is limited to \\\"INT_MAX / 2\\\" but not INT_MAX?\\n>\\n> I forgot to mention this one in the OP.\\n>\\n> Googling around, I found out some implemetations of bsearch break with\\n> array sizes beyond INT_MAX/2 [1] (they'd overflow when computing the\\n> midpoint).\\n>\\n> Before this patch, this bsearch call had no way of reaching that size.\\n> An initial version of the patch (the one that allocated a big array\\n> with huge allocation) could reach that point, though, so I reduced the\\n> limit to play it safe. This latest version is back to the starting\\n> point, since it cannot allocate segments bigger than 1GB, but I opted\\n> to keep playing it safe and leave the reduced limit just in case.\\n>\\n\\nThanks, I understood.\\n\\n>> ----\\n>> @@ -1376,35 +1411,43 @@ lazy_vacuum_heap(Relation onerel, LVRelStats\\n>> *vacrelstats)\\n>> pg_rusage_init(&ru0);\\n>> npages = 0;\\n>>\\n>> - tupindex = 0;\\n>> - while (tupindex < vacrelstats->num_dead_tuples)\\n>> + segindex = 0;\\n>> + tottuples = 0;\\n>> + for (segindex = tupindex = 0; segindex <=\\n>> vacrelstats->dead_tuples.last_seg; tupindex = 0, segindex++)\\n>> {\\n>> - BlockNumber tblk;\\n>> - Buffer buf;\\n>> - Page page;\\n>> - Size freespace;\\n>>\\n>> This is a minute thing but tupindex can be define inside of for loop.\\n>\\n> Right, changing.\\n>\\n>>\\n>> ----\\n>> @@ -1129,10 +1159,13 @@ lazy_scan_heap(Relation onerel, int options,\\n>> LVRelStats *vacrelstats,\\n>> * instead of doing a second scan.\\n>> */\\n>> if (nindexes == 0 &&\\n>> - vacrelstats->num_dead_tuples > 0)\\n>> + vacrelstats->dead_tuples.num_entries > 0)\\n>> {\\n>> /* Remove tuples from heap */\\n>> - lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);\\n>> + Assert(vacrelstats->dead_tuples.last_seg == 0); /*\\n>> Should not need more\\n>> + *\\n>> than one segment per\\n>> + * page */\\n>>\\n>> I'm not sure we need to add Assert() here but it seems to me that the\\n>> comment and code is not properly correspond and the comment for\\n>> Assert() should be wrote above of Assert() line.\\n>\\n> Well, that assert is the one that found the second bug in\\n> lazy_clear_dead_tuples, so clearly it's not without merit.\\n>\\n> I'll rearrange the comments as you ask though.\\n>\\n>\\n> Updated and rebased v7 attached.\\n>\\n>\\n> [1] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=776671\\n\\nThank you for updating the patch.\\n\\nWhole patch looks good to me except for the following one comment.\\nThis is the final comment from me.\\n\\n/*\\n * lazy_tid_reaped() -- is a particular tid deletable?\\n *\\n * This has the right signature to be an IndexBulkDeleteCallback.\\n *\\n * Assumes dead_tuples array is in sorted order.\\n */\\nstatic bool\\nlazy_tid_reaped(ItemPointer itemptr, void *state)\\n{\\n LVRelStats *vacrelstats = (LVRelStats *) state;\\n\\nYou might want to update the comment of lazy_tid_reaped() as well.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 1 Feb 2017 21:47:16 +0100\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> Thank you for updating the patch.\\n>\\n> Whole patch looks good to me except for the following one comment.\\n> This is the final comment from me.\\n>\\n> /*\\n> * lazy_tid_reaped() -- is a particular tid deletable?\\n> *\\n> * This has the right signature to be an IndexBulkDeleteCallback.\\n> *\\n> * Assumes dead_tuples array is in sorted order.\\n> */\\n> static bool\\n> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n> {\\n> LVRelStats *vacrelstats = (LVRelStats *) state;\\n>\\n> You might want to update the comment of lazy_tid_reaped() as well.\\n\\nI don't see the mismatch with reality there (if you consider\\n\\\"dead_tples array\\\" in the proper context, that is, the multiarray).\\n\\nWhat in particular do you find out of sync there?\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 1 Feb 2017 18:02:07 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> Thank you for updating the patch.\\n>>\\n>> Whole patch looks good to me except for the following one comment.\\n>> This is the final comment from me.\\n>>\\n>> /*\\n>> * lazy_tid_reaped() -- is a particular tid deletable?\\n>> *\\n>> * This has the right signature to be an IndexBulkDeleteCallback.\\n>> *\\n>> * Assumes dead_tuples array is in sorted order.\\n>> */\\n>> static bool\\n>> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n>> {\\n>> LVRelStats *vacrelstats = (LVRelStats *) state;\\n>>\\n>> You might want to update the comment of lazy_tid_reaped() as well.\\n>\\n> I don't see the mismatch with reality there (if you consider\\n> \\\"dead_tples array\\\" in the proper context, that is, the multiarray).\\n>\\n> What in particular do you find out of sync there?\\n\\nThe current lazy_tid_reaped just find a tid from a tid array using\\nbsearch but in your patch lazy_tid_reaped handles multiple tid arrays\\nand processing method become complicated. So I thought it's better to\\nadd the description of this function.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 1 Feb 2017 22:13:34 +0100\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 1, 2017 at 6:13 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>>> Thank you for updating the patch.\\n>>>\\n>>> Whole patch looks good to me except for the following one comment.\\n>>> This is the final comment from me.\\n>>>\\n>>> /*\\n>>> * lazy_tid_reaped() -- is a particular tid deletable?\\n>>> *\\n>>> * This has the right signature to be an IndexBulkDeleteCallback.\\n>>> *\\n>>> * Assumes dead_tuples array is in sorted order.\\n>>> */\\n>>> static bool\\n>>> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n>>> {\\n>>> LVRelStats *vacrelstats = (LVRelStats *) state;\\n>>>\\n>>> You might want to update the comment of lazy_tid_reaped() as well.\\n>>\\n>> I don't see the mismatch with reality there (if you consider\\n>> \\\"dead_tples array\\\" in the proper context, that is, the multiarray).\\n>>\\n>> What in particular do you find out of sync there?\\n>\\n> The current lazy_tid_reaped just find a tid from a tid array using\\n> bsearch but in your patch lazy_tid_reaped handles multiple tid arrays\\n> and processing method become complicated. So I thought it's better to\\n> add the description of this function.\\n\\nAlright, updated with some more remarks that seemed relevant\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 1 Feb 2017 19:55:16 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 1, 2017 at 11:55 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Feb 1, 2017 at 6:13 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>>>> Thank you for updating the patch.\\n>>>>\\n>>>> Whole patch looks good to me except for the following one comment.\\n>>>> This is the final comment from me.\\n>>>>\\n>>>> /*\\n>>>> * lazy_tid_reaped() -- is a particular tid deletable?\\n>>>> *\\n>>>> * This has the right signature to be an IndexBulkDeleteCallback.\\n>>>> *\\n>>>> * Assumes dead_tuples array is in sorted order.\\n>>>> */\\n>>>> static bool\\n>>>> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n>>>> {\\n>>>> LVRelStats *vacrelstats = (LVRelStats *) state;\\n>>>>\\n>>>> You might want to update the comment of lazy_tid_reaped() as well.\\n>>>\\n>>> I don't see the mismatch with reality there (if you consider\\n>>> \\\"dead_tples array\\\" in the proper context, that is, the multiarray).\\n>>>\\n>>> What in particular do you find out of sync there?\\n>>\\n>> The current lazy_tid_reaped just find a tid from a tid array using\\n>> bsearch but in your patch lazy_tid_reaped handles multiple tid arrays\\n>> and processing method become complicated. So I thought it's better to\\n>> add the description of this function.\\n>\\n> Alright, updated with some more remarks that seemed relevant\\n\\nThank you for updating the patch.\\n\\nThe patch looks good to me. There is no review comment from me.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 4 Feb 2017 16:43:04 +0100\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 1, 2017 at 7:55 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Feb 1, 2017 at 6:13 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>> On Wed, Feb 1, 2017 at 10:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> On Wed, Feb 1, 2017 at 5:47 PM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n>>>> Thank you for updating the patch.\\n>>>>\\n>>>> Whole patch looks good to me except for the following one comment.\\n>>>> This is the final comment from me.\\n>>>>\\n>>>> /*\\n>>>> * lazy_tid_reaped() -- is a particular tid deletable?\\n>>>> *\\n>>>> * This has the right signature to be an IndexBulkDeleteCallback.\\n>>>> *\\n>>>> * Assumes dead_tuples array is in sorted order.\\n>>>> */\\n>>>> static bool\\n>>>> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n>>>> {\\n>>>> LVRelStats *vacrelstats = (LVRelStats *) state;\\n>>>>\\n>>>> You might want to update the comment of lazy_tid_reaped() as well.\\n>>>\\n>>> I don't see the mismatch with reality there (if you consider\\n>>> \\\"dead_tples array\\\" in the proper context, that is, the multiarray).\\n>>>\\n>>> What in particular do you find out of sync there?\\n>>\\n>> The current lazy_tid_reaped just find a tid from a tid array using\\n>> bsearch but in your patch lazy_tid_reaped handles multiple tid arrays\\n>> and processing method become complicated. So I thought it's better to\\n>> add the description of this function.\\n>\\n> Alright, updated with some more remarks that seemed relevant\\n\\nI just realized I never updated the early free patch after the\\nmultiarray version.\\n\\nSo attached is a patch that frees the multiarray as early as possible\\n(just after finishing with index bulk deletes, right before doing\\nindex cleanup and attempting truncation).\\n\\nThis should make the possibly big amount of memory available to other\\nprocesses for the duration of those tasks, which could be a long time\\nin some cases.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 28 Mar 2017 22:46:12 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nI've *not* read the history of this thread. So I really might be\\nmissing some context.\\n\\n\\n> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\\n> From: Claudio Freire <klaussfreire@gmail.com>\\n> Date: Mon, 12 Sep 2016 23:36:42 -0300\\n> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\\n> \\n> Turn the dead_tuples array into a structure composed of several\\n> exponentially bigger arrays, to enable usage of more than 1GB\\n> of work mem during vacuum and thus reduce the number of full\\n> index scans necessary to remove all dead tids when the memory is\\n> available.\\n\\n> * We are willing to use at most maintenance_work_mem (or perhaps\\n> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n> - * initially allocate an array of TIDs of that size, with an upper limit that\\n> + * initially allocate an array of TIDs of 128MB, or an upper limit that\\n> * depends on table size (this limit ensures we don't allocate a huge area\\n> - * uselessly for vacuuming small tables). If the array threatens to overflow,\\n> - * we suspend the heap scan phase and perform a pass of index cleanup and page\\n> - * compaction, then resume the heap scan with an empty TID array.\\n> + * uselessly for vacuuming small tables). Additional arrays of increasingly\\n> + * large sizes are allocated as they become necessary.\\n> + *\\n> + * The TID array is thus represented as a list of multiple segments of\\n> + * varying size, beginning with the initial size of up to 128MB, and growing\\n> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\\n> + * is used up.\\n\\nWhen the chunk size is 128MB, I'm a bit unconvinced that using\\nexponential growth is worth it. The allocator overhead can't be\\nmeaningful in comparison to collecting 128MB dead tuples, the potential\\nwaste is pretty big, and it increases memory fragmentation.\\n\\n\\n> + * Lookup in that structure proceeds sequentially in the list of segments,\\n> + * and with a binary search within each segment. Since segment's size grows\\n> + * exponentially, this retains O(N log N) lookup complexity.\\n\\nN log N is a horrible lookup complexity. That's the complexity of\\n*sorting* an entire array. I think you might be trying to argue that\\nit's log(N) * log(N)? Once log(n) for the exponentially growing size of\\nsegments, one for the binary search?\\n\\nAfaics you could quite easily make it O(2 log(N)) by simply also doing\\nbinary search over the segments. Might not be worth it due to the small\\nconstant involved normally.\\n\\n\\n> + * If the array threatens to overflow, we suspend the heap scan phase and\\n> + * perform a pass of index cleanup and page compaction, then resume the heap\\n> + * scan with an array of logically empty but already preallocated TID segments\\n> + * to be refilled with more dead tuple TIDs.\\n\\nHm, it's not really the array that overflows, it's m_w_m that'd be\\nexceeded, right?\\n\\n\\n> /*\\n> + * Minimum (starting) size of the dead_tuples array segments. Will allocate\\n> + * space for 128MB worth of tid pointers in the first segment, further segments\\n> + * will grow in size exponentially. Don't make it too small or the segment list\\n> + * will grow bigger than the sweetspot for search efficiency on big vacuums.\\n> + */\\n> +#define LAZY_MIN_TUPLES\\t\\tMax(MaxHeapTuplesPerPage, (128<<20) / sizeof(ItemPointerData))\\n\\nThat's not really the minimum, no? s/MIN/INIT/?\\n\\n\\n> +typedef struct DeadTuplesSegment\\n> +{\\n> +\\tint\\t\\t\\tnum_dead_tuples;\\t/* # of entries in the segment */\\n> +\\tint\\t\\t\\tmax_dead_tuples;\\t/* # of entries allocated in the segment */\\n> +\\tItemPointerData last_dead_tuple;\\t/* Copy of the last dead tuple (unset\\n> +\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t * until the segment is fully\\n> +\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t * populated) */\\n> +\\tunsigned short padding;\\n> +\\tItemPointer dt_tids;\\t/* Array of dead tuples */\\n> +}\\tDeadTuplesSegment;\\n\\nWhenever padding is needed, it should have an explanatory comment. It's\\ncertainly not obvious to me wh it's neede here.\\n\\n\\n> @@ -1598,6 +1657,11 @@ lazy_vacuum_index(Relation indrel,\\n> \\tivinfo.num_heap_tuples = vacrelstats->old_rel_tuples;\\n> \\tivinfo.strategy = vac_strategy;\\n> \\n> +\\t/* Finalize the current segment by setting its upper bound dead tuple */\\n> +\\tseg = DeadTuplesCurrentSegment(vacrelstats);\\n> +\\tif (seg->num_dead_tuples > 0)\\n> +\\t\\tseg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\\n\\nWhy don't we just maintain this here, for all of the segments? Seems a\\nbit easier.\\n\\n\\n> @@ -1973,7 +2037,8 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)\\n> static void\\n> lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\\n> {\\n> -\\tlong\\t\\tmaxtuples;\\n> +\\tlong\\t\\tmaxtuples,\\n> +\\t\\t\\t\\tmintuples;\\n> \\tint\\t\\t\\tvac_work_mem = IsAutoVacuumWorkerProcess() &&\\n> \\tautovacuum_work_mem != -1 ?\\n> \\tautovacuum_work_mem : maintenance_work_mem;\\n> @@ -1982,7 +2047,6 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\\n> \\t{\\n> \\t\\tmaxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\\n> \\t\\tmaxtuples = Min(maxtuples, INT_MAX);\\n> -\\t\\tmaxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\\n> \\n> \\t\\t/* curious coding here to ensure the multiplication can't overflow */\\n> \\t\\tif ((BlockNumber) (maxtuples / LAZY_ALLOC_TUPLES) > relblocks)\\n> @@ -1996,10 +2060,18 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\\n> \\t\\tmaxtuples = MaxHeapTuplesPerPage;\\n> \\t}\\n> \\n> -\\tvacrelstats->num_dead_tuples = 0;\\n> -\\tvacrelstats->max_dead_tuples = (int) maxtuples;\\n> -\\tvacrelstats->dead_tuples = (ItemPointer)\\n> -\\t\\tpalloc(maxtuples * sizeof(ItemPointerData));\\n> +\\tmintuples = Min(LAZY_MIN_TUPLES, maxtuples);\\n> +\\n> +\\tvacrelstats->dead_tuples.num_entries = 0;\\n> +\\tvacrelstats->dead_tuples.max_entries = (int) maxtuples;\\n> +\\tvacrelstats->dead_tuples.num_segs = 1;\\n> +\\tvacrelstats->dead_tuples.last_seg = 0;\\n> +\\tvacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *)\\n> +\\t\\tpalloc(sizeof(DeadTuplesSegment));\\n> +\\tvacrelstats->dead_tuples.dt_segments[0].dt_tids = (ItemPointer)\\n> +\\t\\tpalloc(mintuples * sizeof(ItemPointerData));\\n> +\\tvacrelstats->dead_tuples.dt_segments[0].max_dead_tuples = mintuples;\\n> +\\tvacrelstats->dead_tuples.dt_segments[0].num_dead_tuples = 0;\\n> }\\n\\nHm. Why don't we delay allocating dt_segments[0] till we actually need\\nit? It's not uncommon for vacuums not to be able to find any dead\\ntuples, and it'd not change code in lazy_record_dead_tuple() much.\\n\\n\\n> @@ -2014,31 +2086,147 @@ lazy_record_dead_tuple(LVRelStats *vacrelstats,\\n> \\t * could if we are given a really small maintenance_work_mem. In that\\n> \\t * case, just forget the last few tuples (we'll get 'em next time).\\n> \\t */\\n> -\\tif (vacrelstats->num_dead_tuples < vacrelstats->max_dead_tuples)\\n> +\\tif (vacrelstats->dead_tuples.num_entries < vacrelstats->dead_tuples.max_entries)\\n> \\t{\\n> -\\t\\tvacrelstats->dead_tuples[vacrelstats->num_dead_tuples] = *itemptr;\\n> -\\t\\tvacrelstats->num_dead_tuples++;\\n> +\\t\\tDeadTuplesSegment *seg = DeadTuplesCurrentSegment(vacrelstats);\\n> +\\n> +\\t\\tif (seg->num_dead_tuples >= seg->max_dead_tuples)\\n> +\\t\\t{\\n> +\\t\\t\\t/*\\n> +\\t\\t\\t * The segment is overflowing, so we must allocate a new segment.\\n> +\\t\\t\\t * We could have a preallocated segment descriptor already, in\\n> +\\t\\t\\t * which case we just reinitialize it, or we may need to repalloc\\n> +\\t\\t\\t * the vacrelstats->dead_tuples array. In that case, seg will no\\n> +\\t\\t\\t * longer be valid, so we must be careful about that. In any case,\\n> +\\t\\t\\t * we must update the last_dead_tuple copy in the overflowing\\n> +\\t\\t\\t * segment descriptor.\\n> +\\t\\t\\t */\\n> +\\t\\t\\tAssert(seg->num_dead_tuples == seg->max_dead_tuples);\\n> +\\t\\t\\tseg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\\n> +\\t\\t\\tif (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\\n> +\\t\\t\\t{\\n> +\\t\\t\\t\\tint\\t\\t\\tnew_num_segs = vacrelstats->dead_tuples.num_segs * 2;\\n> +\\n> +\\t\\t\\t\\tvacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\\n> +\\t\\t\\t\\t\\t\\t\\t (void *) vacrelstats->dead_tuples.dt_segments,\\n> +\\t\\t\\t\\t\\t\\t\\t\\t new_num_segs * sizeof(DeadTuplesSegment));\\n\\nMight be worth breaking this into some sub-statements, it's quite hard\\nto read.\\n\\n\\n> +\\t\\t\\t\\twhile (vacrelstats->dead_tuples.num_segs < new_num_segs)\\n> +\\t\\t\\t\\t{\\n> +\\t\\t\\t\\t\\t/* Initialize as \\\"unallocated\\\" */\\n> +\\t\\t\\t\\t\\tDeadTuplesSegment *nseg = &(vacrelstats->dead_tuples.dt_segments[\\n> +\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t vacrelstats->dead_tuples.num_segs]);\\n\\ndito.\\n\\n\\n> +/*\\n> *\\tlazy_tid_reaped() -- is a particular tid deletable?\\n> *\\n> *\\t\\tThis has the right signature to be an IndexBulkDeleteCallback.\\n> *\\n> - *\\t\\tAssumes dead_tuples array is in sorted order.\\n> + *\\t\\tAssumes the dead_tuples multiarray is in sorted order, both\\n> + *\\t\\tthe segment list and each segment itself, and that all segments'\\n> + *\\t\\tlast_dead_tuple fields up to date\\n> */\\n> static bool\\n> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n\\nHave you done performance evaluation about potential performance\\nregressions in big indexes here? IIRC this can be quite frequently\\ncalled?\\n\\n\\nI think this is reasonably close to commit, but unfortunately not quite\\nthere yet. I.e. I personally won't polish this up & commit in the next\\ncouple hours, but if somebody else wants to take that on...\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 13:05:09 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\\n> Hi,\\n>\\n> I've *not* read the history of this thread. So I really might be\\n> missing some context.\\n>\\n>\\n>> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\\n>> From: Claudio Freire <klaussfreire@gmail.com>\\n>> Date: Mon, 12 Sep 2016 23:36:42 -0300\\n>> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\\n>>\\n>> Turn the dead_tuples array into a structure composed of several\\n>> exponentially bigger arrays, to enable usage of more than 1GB\\n>> of work mem during vacuum and thus reduce the number of full\\n>> index scans necessary to remove all dead tids when the memory is\\n>> available.\\n>\\n>> * We are willing to use at most maintenance_work_mem (or perhaps\\n>> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n>> - * initially allocate an array of TIDs of that size, with an upper limit that\\n>> + * initially allocate an array of TIDs of 128MB, or an upper limit that\\n>> * depends on table size (this limit ensures we don't allocate a huge area\\n>> - * uselessly for vacuuming small tables). If the array threatens to overflow,\\n>> - * we suspend the heap scan phase and perform a pass of index cleanup and page\\n>> - * compaction, then resume the heap scan with an empty TID array.\\n>> + * uselessly for vacuuming small tables). Additional arrays of increasingly\\n>> + * large sizes are allocated as they become necessary.\\n>> + *\\n>> + * The TID array is thus represented as a list of multiple segments of\\n>> + * varying size, beginning with the initial size of up to 128MB, and growing\\n>> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\\n>> + * is used up.\\n>\\n> When the chunk size is 128MB, I'm a bit unconvinced that using\\n> exponential growth is worth it. The allocator overhead can't be\\n> meaningful in comparison to collecting 128MB dead tuples, the potential\\n> waste is pretty big, and it increases memory fragmentation.\\n\\nThe exponential strategy is mainly to improve lookup time (ie: to\\navoid large segment lists).\\n\\n>> + * Lookup in that structure proceeds sequentially in the list of segments,\\n>> + * and with a binary search within each segment. Since segment's size grows\\n>> + * exponentially, this retains O(N log N) lookup complexity.\\n>\\n> N log N is a horrible lookup complexity. That's the complexity of\\n> *sorting* an entire array. I think you might be trying to argue that\\n> it's log(N) * log(N)? Once log(n) for the exponentially growing size of\\n> segments, one for the binary search?\\n>\\n> Afaics you could quite easily make it O(2 log(N)) by simply also doing\\n> binary search over the segments. Might not be worth it due to the small\\n> constant involved normally.\\n\\nIt's a typo, yes, I meant O(log N) (which is equivalent to O(2 log N))\\n\\n>> + * If the array threatens to overflow, we suspend the heap scan phase and\\n>> + * perform a pass of index cleanup and page compaction, then resume the heap\\n>> + * scan with an array of logically empty but already preallocated TID segments\\n>> + * to be refilled with more dead tuple TIDs.\\n>\\n> Hm, it's not really the array that overflows, it's m_w_m that'd be\\n> exceeded, right?\\n\\nYes, will rephrase. Although that's how the original comment expressed\\nthe same concept.\\n\\n>> /*\\n>> + * Minimum (starting) size of the dead_tuples array segments. Will allocate\\n>> + * space for 128MB worth of tid pointers in the first segment, further segments\\n>> + * will grow in size exponentially. Don't make it too small or the segment list\\n>> + * will grow bigger than the sweetspot for search efficiency on big vacuums.\\n>> + */\\n>> +#define LAZY_MIN_TUPLES Max(MaxHeapTuplesPerPage, (128<<20) / sizeof(ItemPointerData))\\n>\\n> That's not really the minimum, no? s/MIN/INIT/?\\n\\nOk\\n\\n>> +typedef struct DeadTuplesSegment\\n>> +{\\n>> + int num_dead_tuples; /* # of entries in the segment */\\n>> + int max_dead_tuples; /* # of entries allocated in the segment */\\n>> + ItemPointerData last_dead_tuple; /* Copy of the last dead tuple (unset\\n>> + * until the segment is fully\\n>> + * populated) */\\n>> + unsigned short padding;\\n>> + ItemPointer dt_tids; /* Array of dead tuples */\\n>> +} DeadTuplesSegment;\\n>\\n> Whenever padding is needed, it should have an explanatory comment. It's\\n> certainly not obvious to me wh it's neede here.\\n\\nOk\\n\\n>> @@ -1598,6 +1657,11 @@ lazy_vacuum_index(Relation indrel,\\n>> ivinfo.num_heap_tuples = vacrelstats->old_rel_tuples;\\n>> ivinfo.strategy = vac_strategy;\\n>>\\n>> + /* Finalize the current segment by setting its upper bound dead tuple */\\n>> + seg = DeadTuplesCurrentSegment(vacrelstats);\\n>> + if (seg->num_dead_tuples > 0)\\n>> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\\n>\\n> Why don't we just maintain this here, for all of the segments? Seems a\\n> bit easier.\\n\\nOriginally, I just wanted to maintain the validity of last_dead_tuple\\nas an invariant at all times. But it may be like you say, that it's\\nsimpler to just maintain the invariant of all segments at finalization\\ntime. I'll explore that possibility.\\n\\n>> @@ -1973,7 +2037,8 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)\\n>> static void\\n>> lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\\n>> {\\n>> - long maxtuples;\\n>> + long maxtuples,\\n>> + mintuples;\\n>> int vac_work_mem = IsAutoVacuumWorkerProcess() &&\\n>> autovacuum_work_mem != -1 ?\\n>> autovacuum_work_mem : maintenance_work_mem;\\n>> @@ -1982,7 +2047,6 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\\n>> {\\n>> maxtuples = (vac_work_mem * 1024L) / sizeof(ItemPointerData);\\n>> maxtuples = Min(maxtuples, INT_MAX);\\n>> - maxtuples = Min(maxtuples, MaxAllocSize / sizeof(ItemPointerData));\\n>>\\n>> /* curious coding here to ensure the multiplication can't overflow */\\n>> if ((BlockNumber) (maxtuples / LAZY_ALLOC_TUPLES) > relblocks)\\n>> @@ -1996,10 +2060,18 @@ lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks)\\n>> maxtuples = MaxHeapTuplesPerPage;\\n>> }\\n>>\\n>> - vacrelstats->num_dead_tuples = 0;\\n>> - vacrelstats->max_dead_tuples = (int) maxtuples;\\n>> - vacrelstats->dead_tuples = (ItemPointer)\\n>> - palloc(maxtuples * sizeof(ItemPointerData));\\n>> + mintuples = Min(LAZY_MIN_TUPLES, maxtuples);\\n>> +\\n>> + vacrelstats->dead_tuples.num_entries = 0;\\n>> + vacrelstats->dead_tuples.max_entries = (int) maxtuples;\\n>> + vacrelstats->dead_tuples.num_segs = 1;\\n>> + vacrelstats->dead_tuples.last_seg = 0;\\n>> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *)\\n>> + palloc(sizeof(DeadTuplesSegment));\\n>> + vacrelstats->dead_tuples.dt_segments[0].dt_tids = (ItemPointer)\\n>> + palloc(mintuples * sizeof(ItemPointerData));\\n>> + vacrelstats->dead_tuples.dt_segments[0].max_dead_tuples = mintuples;\\n>> + vacrelstats->dead_tuples.dt_segments[0].num_dead_tuples = 0;\\n>> }\\n>\\n> Hm. Why don't we delay allocating dt_segments[0] till we actually need\\n> it? It's not uncommon for vacuums not to be able to find any dead\\n> tuples, and it'd not change code in lazy_record_dead_tuple() much.\\n\\nI avoided that because that would make dt_segments[last_seg] invalid\\nfor the case of a just-initialized multiarray.\\n\\nSome places in the code use a macro that references\\ndt_segments[last_seg] (mostly for indexless tables), and having to\\ncheck num_segs and do lazy initialization would have complicated the\\ncode considerably.\\n\\nNonetheless, I'll re-check how viable doing that would be.\\n\\n>> @@ -2014,31 +2086,147 @@ lazy_record_dead_tuple(LVRelStats *vacrelstats,\\n>> * could if we are given a really small maintenance_work_mem. In that\\n>> * case, just forget the last few tuples (we'll get 'em next time).\\n>> */\\n>> - if (vacrelstats->num_dead_tuples < vacrelstats->max_dead_tuples)\\n>> + if (vacrelstats->dead_tuples.num_entries < vacrelstats->dead_tuples.max_entries)\\n>> {\\n>> - vacrelstats->dead_tuples[vacrelstats->num_dead_tuples] = *itemptr;\\n>> - vacrelstats->num_dead_tuples++;\\n>> + DeadTuplesSegment *seg = DeadTuplesCurrentSegment(vacrelstats);\\n>> +\\n>> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\\n>> + {\\n>> + /*\\n>> + * The segment is overflowing, so we must allocate a new segment.\\n>> + * We could have a preallocated segment descriptor already, in\\n>> + * which case we just reinitialize it, or we may need to repalloc\\n>> + * the vacrelstats->dead_tuples array. In that case, seg will no\\n>> + * longer be valid, so we must be careful about that. In any case,\\n>> + * we must update the last_dead_tuple copy in the overflowing\\n>> + * segment descriptor.\\n>> + */\\n>> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\\n>> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\\n>> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\\n>> + {\\n>> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\\n>> +\\n>> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\\n>> + (void *) vacrelstats->dead_tuples.dt_segments,\\n>> + new_num_segs * sizeof(DeadTuplesSegment));\\n>\\n> Might be worth breaking this into some sub-statements, it's quite hard\\n> to read.\\n\\nBreaking what precisely? The comment?\\n\\n>> + while (vacrelstats->dead_tuples.num_segs < new_num_segs)\\n>> + {\\n>> + /* Initialize as \\\"unallocated\\\" */\\n>> + DeadTuplesSegment *nseg = &(vacrelstats->dead_tuples.dt_segments[\\n>> + vacrelstats->dead_tuples.num_segs]);\\n>\\n> dito.\\n\\nI don't really get what you're asking here.\\n\\n>> +/*\\n>> * lazy_tid_reaped() -- is a particular tid deletable?\\n>> *\\n>> * This has the right signature to be an IndexBulkDeleteCallback.\\n>> *\\n>> - * Assumes dead_tuples array is in sorted order.\\n>> + * Assumes the dead_tuples multiarray is in sorted order, both\\n>> + * the segment list and each segment itself, and that all segments'\\n>> + * last_dead_tuple fields up to date\\n>> */\\n>> static bool\\n>> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n>\\n> Have you done performance evaluation about potential performance\\n> regressions in big indexes here? IIRC this can be quite frequently\\n> called?\\n\\nYes, the benchmarks are upthread. The earlier runs were run on my\\nlaptop and made little sense, so I'd ignore them as inaccurate. The\\nlatest run[1] with a pgbench scale of 4000 gave an improvement in CPU\\ntime (ie: faster) of about 20%. Anastasia did another one[2] and saw\\nimprovements as well, roughly 30%, though it's not measuring CPU time\\nbut rather elapsed time.\\n\\nEven small scales (100) saw an improvement as well, although possibly\\nbelow the noise floor. Tests are very slow so I haven't run enough to\\nmeasure variance and statistical significance.\\n\\nI blame the improvement not only on better cache locality (the initial\\nsearch on the segment list usually fits on L1) but also on less\\noverall work due to needing less index scans, and the fact that\\noverall lookup complexity remains O(log N) due to the exponential\\nsegment growth strategy.\\n\\n[1] https://www.postgresql.org/message-id/CAGTBQpa6NFGO_6g_y_7zQx8L9GcHDSQKYdo1tGuh791z6PYgEg%40mail.gmail.com\\n[2] https://www.postgresql.org/message-id/13bee467-bdcf-d3b9-c0ee-e2792fd46839%40postgrespro.ru\\n\\n>\\n>\\n> I think this is reasonably close to commit, but unfortunately not quite\\n> there yet. I.e. I personally won't polish this up & commit in the next\\n> couple hours, but if somebody else wants to take that on...\\n>\\n> Greetings,\\n>\\n> Andres Freund\\n\\nI'll post an updated patch with the requested changes shortly.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 19:43:39 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 7, 2017 at 7:43 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> + * Lookup in that structure proceeds sequentially in the list of segments,\\n>>> + * and with a binary search within each segment. Since segment's size grows\\n>>> + * exponentially, this retains O(N log N) lookup complexity.\\n>>\\n>> N log N is a horrible lookup complexity. That's the complexity of\\n>> *sorting* an entire array. I think you might be trying to argue that\\n>> it's log(N) * log(N)? Once log(n) for the exponentially growing size of\\n>> segments, one for the binary search?\\n>>\\n>> Afaics you could quite easily make it O(2 log(N)) by simply also doing\\n>> binary search over the segments. Might not be worth it due to the small\\n>> constant involved normally.\\n>\\n> It's a typo, yes, I meant O(log N) (which is equivalent to O(2 log N))\\n\\n\\nTo clarify, lookup over the segments is linear, so it's O(M) with M\\nthe number of segments, then the binary search is O(log N) with N the\\nnumber of dead tuples.\\n\\nSo lookup is O(M + log N), but M < log N because of the segment's\\nexponential growth, therefore the lookup is O(2 log N)\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 19:46:06 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\n\\nOn 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\\n> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\\n> > Hi,\\n> >\\n> > I've *not* read the history of this thread. So I really might be\\n> > missing some context.\\n> >\\n> >\\n> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\\n> >> From: Claudio Freire <klaussfreire@gmail.com>\\n> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\\n> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\\n> >>\\n> >> Turn the dead_tuples array into a structure composed of several\\n> >> exponentially bigger arrays, to enable usage of more than 1GB\\n> >> of work mem during vacuum and thus reduce the number of full\\n> >> index scans necessary to remove all dead tids when the memory is\\n> >> available.\\n> >\\n> >> * We are willing to use at most maintenance_work_mem (or perhaps\\n> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n> >> - * initially allocate an array of TIDs of that size, with an upper limit that\\n> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\\n> >> * depends on table size (this limit ensures we don't allocate a huge area\\n> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\\n> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\\n> >> - * compaction, then resume the heap scan with an empty TID array.\\n> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\\n> >> + * large sizes are allocated as they become necessary.\\n> >> + *\\n> >> + * The TID array is thus represented as a list of multiple segments of\\n> >> + * varying size, beginning with the initial size of up to 128MB, and growing\\n> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\\n> >> + * is used up.\\n> >\\n> > When the chunk size is 128MB, I'm a bit unconvinced that using\\n> > exponential growth is worth it. The allocator overhead can't be\\n> > meaningful in comparison to collecting 128MB dead tuples, the potential\\n> > waste is pretty big, and it increases memory fragmentation.\\n> \\n> The exponential strategy is mainly to improve lookup time (ie: to\\n> avoid large segment lists).\\n\\nWell, if we were to do binary search on the segment list, that'd not be\\nnecessary.\\n\\n> >> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\\n> >> + {\\n> >> + /*\\n> >> + * The segment is overflowing, so we must allocate a new segment.\\n> >> + * We could have a preallocated segment descriptor already, in\\n> >> + * which case we just reinitialize it, or we may need to repalloc\\n> >> + * the vacrelstats->dead_tuples array. In that case, seg will no\\n> >> + * longer be valid, so we must be careful about that. In any case,\\n> >> + * we must update the last_dead_tuple copy in the overflowing\\n> >> + * segment descriptor.\\n> >> + */\\n> >> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\\n> >> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\\n> >> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\\n> >> + {\\n> >> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\\n> >> +\\n> >> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\\n> >> + (void *) vacrelstats->dead_tuples.dt_segments,\\n> >> + new_num_segs * sizeof(DeadTuplesSegment));\\n> >\\n> > Might be worth breaking this into some sub-statements, it's quite hard\\n> > to read.\\n> \\n> Breaking what precisely? The comment?\\n\\nNo, the three-line statement computing the new value of\\ndead_tuples.dt_segments. I'd at least assign dead_tuples to a local\\nvariable, to cut the length of the statement down.\\n\\n\\n> >> + while (vacrelstats->dead_tuples.num_segs < new_num_segs)\\n> >> + {\\n> >> + /* Initialize as \\\"unallocated\\\" */\\n> >> + DeadTuplesSegment *nseg = &(vacrelstats->dead_tuples.dt_segments[\\n> >> + vacrelstats->dead_tuples.num_segs]);\\n> >\\n> > dito.\\n> \\n> I don't really get what you're asking here.\\n\\nTrying to simplify/shorten the statement.\\n\\n\\n> >> +/*\\n> >> * lazy_tid_reaped() -- is a particular tid deletable?\\n> >> *\\n> >> * This has the right signature to be an IndexBulkDeleteCallback.\\n> >> *\\n> >> - * Assumes dead_tuples array is in sorted order.\\n> >> + * Assumes the dead_tuples multiarray is in sorted order, both\\n> >> + * the segment list and each segment itself, and that all segments'\\n> >> + * last_dead_tuple fields up to date\\n> >> */\\n> >> static bool\\n> >> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n> >\\n> > Have you done performance evaluation about potential performance\\n> > regressions in big indexes here? IIRC this can be quite frequently\\n> > called?\\n> \\n> Yes, the benchmarks are upthread. The earlier runs were run on my\\n> laptop and made little sense, so I'd ignore them as inaccurate. The\\n> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\\n> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\\n> improvements as well, roughly 30%, though it's not measuring CPU time\\n> but rather elapsed time.\\n\\nI'd be more concerned about cases that'd already fit into memory, not ones\\nwhere we avoid doing another scan - and I think you mostly measured that?\\n\\n- Andres\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 17:56:29 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 7, 2017 at 9:56 PM, Andres Freund <andres@anarazel.de> wrote:\\n> Hi,\\n>\\n>\\n> On 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\\n>> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\\n>> > Hi,\\n>> >\\n>> > I've *not* read the history of this thread. So I really might be\\n>> > missing some context.\\n>> >\\n>> >\\n>> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\\n>> >> From: Claudio Freire <klaussfreire@gmail.com>\\n>> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\\n>> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\\n>> >>\\n>> >> Turn the dead_tuples array into a structure composed of several\\n>> >> exponentially bigger arrays, to enable usage of more than 1GB\\n>> >> of work mem during vacuum and thus reduce the number of full\\n>> >> index scans necessary to remove all dead tids when the memory is\\n>> >> available.\\n>> >\\n>> >> * We are willing to use at most maintenance_work_mem (or perhaps\\n>> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n>> >> - * initially allocate an array of TIDs of that size, with an upper limit that\\n>> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\\n>> >> * depends on table size (this limit ensures we don't allocate a huge area\\n>> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\\n>> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\\n>> >> - * compaction, then resume the heap scan with an empty TID array.\\n>> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\\n>> >> + * large sizes are allocated as they become necessary.\\n>> >> + *\\n>> >> + * The TID array is thus represented as a list of multiple segments of\\n>> >> + * varying size, beginning with the initial size of up to 128MB, and growing\\n>> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\\n>> >> + * is used up.\\n>> >\\n>> > When the chunk size is 128MB, I'm a bit unconvinced that using\\n>> > exponential growth is worth it. The allocator overhead can't be\\n>> > meaningful in comparison to collecting 128MB dead tuples, the potential\\n>> > waste is pretty big, and it increases memory fragmentation.\\n>>\\n>> The exponential strategy is mainly to improve lookup time (ie: to\\n>> avoid large segment lists).\\n>\\n> Well, if we were to do binary search on the segment list, that'd not be\\n> necessary.\\n\\nTrue, but the initial lookup might be slower in the end, since the\\narray would be bigger and cache locality worse.\\n\\nWhy do you say exponential growth fragments memory? AFAIK, all those\\nallocations are well beyond the point where malloc starts mmaping\\nmemory, so each of those segments should be a mmap segment,\\nindependently freeable.\\n\\n>> >> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\\n>> >> + {\\n>> >> + /*\\n>> >> + * The segment is overflowing, so we must allocate a new segment.\\n>> >> + * We could have a preallocated segment descriptor already, in\\n>> >> + * which case we just reinitialize it, or we may need to repalloc\\n>> >> + * the vacrelstats->dead_tuples array. In that case, seg will no\\n>> >> + * longer be valid, so we must be careful about that. In any case,\\n>> >> + * we must update the last_dead_tuple copy in the overflowing\\n>> >> + * segment descriptor.\\n>> >> + */\\n>> >> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\\n>> >> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\\n>> >> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\\n>> >> + {\\n>> >> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\\n>> >> +\\n>> >> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\\n>> >> + (void *) vacrelstats->dead_tuples.dt_segments,\\n>> >> + new_num_segs * sizeof(DeadTuplesSegment));\\n>> >\\n>> > Might be worth breaking this into some sub-statements, it's quite hard\\n>> > to read.\\n>>\\n>> Breaking what precisely? The comment?\\n>\\n> No, the three-line statement computing the new value of\\n> dead_tuples.dt_segments. I'd at least assign dead_tuples to a local\\n> variable, to cut the length of the statement down.\\n\\nAh, alright. Will try to do that.\\n\\n>> >> +/*\\n>> >> * lazy_tid_reaped() -- is a particular tid deletable?\\n>> >> *\\n>> >> * This has the right signature to be an IndexBulkDeleteCallback.\\n>> >> *\\n>> >> - * Assumes dead_tuples array is in sorted order.\\n>> >> + * Assumes the dead_tuples multiarray is in sorted order, both\\n>> >> + * the segment list and each segment itself, and that all segments'\\n>> >> + * last_dead_tuple fields up to date\\n>> >> */\\n>> >> static bool\\n>> >> lazy_tid_reaped(ItemPointer itemptr, void *state)\\n>> >\\n>> > Have you done performance evaluation about potential performance\\n>> > regressions in big indexes here? IIRC this can be quite frequently\\n>> > called?\\n>>\\n>> Yes, the benchmarks are upthread. The earlier runs were run on my\\n>> laptop and made little sense, so I'd ignore them as inaccurate. The\\n>> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\\n>> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\\n>> improvements as well, roughly 30%, though it's not measuring CPU time\\n>> but rather elapsed time.\\n>\\n> I'd be more concerned about cases that'd already fit into memory, not ones\\n> where we avoid doing another scan - and I think you mostly measured that?\\n>\\n> - Andres\\n\\nWell, scale 400 is pretty much as big as you can get with the old 1GB\\nlimit, and also suffered no significant regression. Although, true, id\\ndidn't significantly improve either.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 22:06:13 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 2017-04-07 22:06:13 -0300, Claudio Freire wrote:\\n> On Fri, Apr 7, 2017 at 9:56 PM, Andres Freund <andres@anarazel.de> wrote:\\n> > Hi,\\n> >\\n> >\\n> > On 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\\n> >> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\\n> >> > Hi,\\n> >> >\\n> >> > I've *not* read the history of this thread. So I really might be\\n> >> > missing some context.\\n> >> >\\n> >> >\\n> >> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\\n> >> >> From: Claudio Freire <klaussfreire@gmail.com>\\n> >> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\\n> >> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\\n> >> >>\\n> >> >> Turn the dead_tuples array into a structure composed of several\\n> >> >> exponentially bigger arrays, to enable usage of more than 1GB\\n> >> >> of work mem during vacuum and thus reduce the number of full\\n> >> >> index scans necessary to remove all dead tids when the memory is\\n> >> >> available.\\n> >> >\\n> >> >> * We are willing to use at most maintenance_work_mem (or perhaps\\n> >> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n> >> >> - * initially allocate an array of TIDs of that size, with an upper limit that\\n> >> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\\n> >> >> * depends on table size (this limit ensures we don't allocate a huge area\\n> >> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\\n> >> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\\n> >> >> - * compaction, then resume the heap scan with an empty TID array.\\n> >> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\\n> >> >> + * large sizes are allocated as they become necessary.\\n> >> >> + *\\n> >> >> + * The TID array is thus represented as a list of multiple segments of\\n> >> >> + * varying size, beginning with the initial size of up to 128MB, and growing\\n> >> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\\n> >> >> + * is used up.\\n> >> >\\n> >> > When the chunk size is 128MB, I'm a bit unconvinced that using\\n> >> > exponential growth is worth it. The allocator overhead can't be\\n> >> > meaningful in comparison to collecting 128MB dead tuples, the potential\\n> >> > waste is pretty big, and it increases memory fragmentation.\\n> >>\\n> >> The exponential strategy is mainly to improve lookup time (ie: to\\n> >> avoid large segment lists).\\n> >\\n> > Well, if we were to do binary search on the segment list, that'd not be\\n> > necessary.\\n> \\n> True, but the initial lookup might be slower in the end, since the\\n> array would be bigger and cache locality worse.\\n> \\n> Why do you say exponential growth fragments memory? AFAIK, all those\\n> allocations are well beyond the point where malloc starts mmaping\\n> memory, so each of those segments should be a mmap segment,\\n> independently freeable.\\n\\nNot all platforms have that, and even on platforms with it, frequent,\\nunevenly sized, very large allocations can lead to enough fragmentation\\nthat further allocations are harder and fragment / enlarge the\\npagetable.\\n\\n\\n> >> Yes, the benchmarks are upthread. The earlier runs were run on my\\n> >> laptop and made little sense, so I'd ignore them as inaccurate. The\\n> >> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\\n> >> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\\n> >> improvements as well, roughly 30%, though it's not measuring CPU time\\n> >> but rather elapsed time.\\n> >\\n> > I'd be more concerned about cases that'd already fit into memory, not ones\\n> > where we avoid doing another scan - and I think you mostly measured that?\\n> >\\n> > - Andres\\n> \\n> Well, scale 400 is pretty much as big as you can get with the old 1GB\\n> limit, and also suffered no significant regression. Although, true, id\\n> didn't significantly improve either.\\n\\nAren't more interesting cases those where not that many dead tuples are\\nfound, but the indexes are pretty large? IIRC the index vacuum scans\\nstill visit every leaf index tuple, no?\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 18:12:52 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 7, 2017 at 10:12 PM, Andres Freund <andres@anarazel.de> wrote:\\n> On 2017-04-07 22:06:13 -0300, Claudio Freire wrote:\\n>> On Fri, Apr 7, 2017 at 9:56 PM, Andres Freund <andres@anarazel.de> wrote:\\n>> > Hi,\\n>> >\\n>> >\\n>> > On 2017-04-07 19:43:39 -0300, Claudio Freire wrote:\\n>> >> On Fri, Apr 7, 2017 at 5:05 PM, Andres Freund <andres@anarazel.de> wrote:\\n>> >> > Hi,\\n>> >> >\\n>> >> > I've *not* read the history of this thread. So I really might be\\n>> >> > missing some context.\\n>> >> >\\n>> >> >\\n>> >> >> From e37d29c26210a0f23cd2e9fe18a264312fecd383 Mon Sep 17 00:00:00 2001\\n>> >> >> From: Claudio Freire <klaussfreire@gmail.com>\\n>> >> >> Date: Mon, 12 Sep 2016 23:36:42 -0300\\n>> >> >> Subject: [PATCH] Vacuum: allow using more than 1GB work mem\\n>> >> >>\\n>> >> >> Turn the dead_tuples array into a structure composed of several\\n>> >> >> exponentially bigger arrays, to enable usage of more than 1GB\\n>> >> >> of work mem during vacuum and thus reduce the number of full\\n>> >> >> index scans necessary to remove all dead tids when the memory is\\n>> >> >> available.\\n>> >> >\\n>> >> >> * We are willing to use at most maintenance_work_mem (or perhaps\\n>> >> >> * autovacuum_work_mem) memory space to keep track of dead tuples. We\\n>> >> >> - * initially allocate an array of TIDs of that size, with an upper limit that\\n>> >> >> + * initially allocate an array of TIDs of 128MB, or an upper limit that\\n>> >> >> * depends on table size (this limit ensures we don't allocate a huge area\\n>> >> >> - * uselessly for vacuuming small tables). If the array threatens to overflow,\\n>> >> >> - * we suspend the heap scan phase and perform a pass of index cleanup and page\\n>> >> >> - * compaction, then resume the heap scan with an empty TID array.\\n>> >> >> + * uselessly for vacuuming small tables). Additional arrays of increasingly\\n>> >> >> + * large sizes are allocated as they become necessary.\\n>> >> >> + *\\n>> >> >> + * The TID array is thus represented as a list of multiple segments of\\n>> >> >> + * varying size, beginning with the initial size of up to 128MB, and growing\\n>> >> >> + * exponentially until the whole budget of (autovacuum_)maintenance_work_mem\\n>> >> >> + * is used up.\\n>> >> >\\n>> >> > When the chunk size is 128MB, I'm a bit unconvinced that using\\n>> >> > exponential growth is worth it. The allocator overhead can't be\\n>> >> > meaningful in comparison to collecting 128MB dead tuples, the potential\\n>> >> > waste is pretty big, and it increases memory fragmentation.\\n>> >>\\n>> >> The exponential strategy is mainly to improve lookup time (ie: to\\n>> >> avoid large segment lists).\\n>> >\\n>> > Well, if we were to do binary search on the segment list, that'd not be\\n>> > necessary.\\n>>\\n>> True, but the initial lookup might be slower in the end, since the\\n>> array would be bigger and cache locality worse.\\n>>\\n>> Why do you say exponential growth fragments memory? AFAIK, all those\\n>> allocations are well beyond the point where malloc starts mmaping\\n>> memory, so each of those segments should be a mmap segment,\\n>> independently freeable.\\n>\\n> Not all platforms have that, and even on platforms with it, frequent,\\n> unevenly sized, very large allocations can lead to enough fragmentation\\n> that further allocations are harder and fragment / enlarge the\\n> pagetable.\\n\\nI wouldn't call this frequent. You can get at most slightly more than\\na dozen such allocations given the current limits.\\nAnd allocation sizes are quite regular - you get 128M or multiples of\\n128M, so each free block can be reused for N smaller allocations if\\nneeded. I don't think it has much potential to fragment memory.\\n\\nThis isn't significantly different from tuplesort or any other code\\nthat can do big allocations, and the differences favor less\\nfragmentation than those, so I don't see why this would need special\\ntreatment.\\n\\nMy point being that it's not been simple getting to a point where this\\nbeats even in CPU time the original single binary search.\\nIf we're to scrap this implementation and go for a double binary\\nsearch, I'd like to have a clear measurable benefit to chase from\\ndoing so. Fragmentation is hard to measure, and I cannot get CPU-bound\\nvacuums on the test hardware I have to test lookup performance at big\\nscales.\\n\\n>> >> Yes, the benchmarks are upthread. The earlier runs were run on my\\n>> >> laptop and made little sense, so I'd ignore them as inaccurate. The\\n>> >> latest run[1] with a pgbench scale of 4000 gave an improvement in CPU\\n>> >> time (ie: faster) of about 20%. Anastasia did another one[2] and saw\\n>> >> improvements as well, roughly 30%, though it's not measuring CPU time\\n>> >> but rather elapsed time.\\n>> >\\n>> > I'd be more concerned about cases that'd already fit into memory, not ones\\n>> > where we avoid doing another scan - and I think you mostly measured that?\\n>> >\\n>> > - Andres\\n>>\\n>> Well, scale 400 is pretty much as big as you can get with the old 1GB\\n>> limit, and also suffered no significant regression. Although, true, id\\n>> didn't significantly improve either.\\n>\\n> Aren't more interesting cases those where not that many dead tuples are\\n> found, but the indexes are pretty large? IIRC the index vacuum scans\\n> still visit every leaf index tuple, no?\\n\\nIndeed they do, and that's what motivated this patch. But I'd need\\nTB-sized tables to set up something like that. I don't have the\\nhardware or time available to do that (vacuum on bloated TB-sized\\ntables can take days in my experience). Scale 4000 is as big as I can\\nget without running out of space for the tests in my test hardware.\\n\\nIf anybody else has the ability, I'd be thankful if they did test it\\nunder those conditions, but I cannot. I think Anastasia's test is\\ncloser to such a test, that's probably why it shows a bigger\\nimprovement in total elapsed time.\\n\\nOur production database could possibly be used, but it can take about\\na week to clone it, upgrade it (it's 9.5 currently), and run the\\nrelevant vacuum.\\n\\nI did perform tests against the same pgbench databases referenced in\\nthe post I linked earlier, but deleting only a fraction of the rows,\\nor on uncorrelated indexes. The benchmarks weren't very interesting,\\nand results were consistent with the linked benchmark (slight CPU time\\nimprovement, just less impactful), so I didn't post them.\\n\\nI think all those tests show that, if there's a workload that\\nregresses, it's a rare one, running on very powerful I/O hardware (to\\nmake vacuum CPU-bound). And even if that were to happen, considering a\\nsingle (or fewer) index scan, even if slower, will cause less WAL\\ntraffic that has to be archived/streamed, it would still most likely\\nbe a win overall.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 22:51:21 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 7, 2017 at 10:06 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> >> + if (seg->num_dead_tuples >= seg->max_dead_tuples)\\n>>> >> + {\\n>>> >> + /*\\n>>> >> + * The segment is overflowing, so we must allocate a new segment.\\n>>> >> + * We could have a preallocated segment descriptor already, in\\n>>> >> + * which case we just reinitialize it, or we may need to repalloc\\n>>> >> + * the vacrelstats->dead_tuples array. In that case, seg will no\\n>>> >> + * longer be valid, so we must be careful about that. In any case,\\n>>> >> + * we must update the last_dead_tuple copy in the overflowing\\n>>> >> + * segment descriptor.\\n>>> >> + */\\n>>> >> + Assert(seg->num_dead_tuples == seg->max_dead_tuples);\\n>>> >> + seg->last_dead_tuple = seg->dt_tids[seg->num_dead_tuples - 1];\\n>>> >> + if (vacrelstats->dead_tuples.last_seg + 1 >= vacrelstats->dead_tuples.num_segs)\\n>>> >> + {\\n>>> >> + int new_num_segs = vacrelstats->dead_tuples.num_segs * 2;\\n>>> >> +\\n>>> >> + vacrelstats->dead_tuples.dt_segments = (DeadTuplesSegment *) repalloc(\\n>>> >> + (void *) vacrelstats->dead_tuples.dt_segments,\\n>>> >> + new_num_segs * sizeof(DeadTuplesSegment));\\n>>> >\\n>>> > Might be worth breaking this into some sub-statements, it's quite hard\\n>>> > to read.\\n>>>\\n>>> Breaking what precisely? The comment?\\n>>\\n>> No, the three-line statement computing the new value of\\n>> dead_tuples.dt_segments. I'd at least assign dead_tuples to a local\\n>> variable, to cut the length of the statement down.\\n>\\n> Ah, alright. Will try to do that.\\n\\nAttached is an updated patch set with the requested changes.\\n\\nSegment allocation still follows the exponential strategy, and segment\\nlookup is still linear.\\n\\nI rebased the early free patch (patch 3) to apply on top of the v9\\npatch 2 (it needed some changes). I recognize the early free patch\\ndidn't get nearly as much scrutiny, so I'm fine with commiting only 2\\nif that one's ready to go but 3 isn't.\\n\\nIf it's decided to go for fixed 128M segments and a binary search of\\nsegments, I don't think I can get that ready and tested before the\\ncommitfest ends.\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 7 Apr 2017 23:19:42 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 4/7/17 10:19 PM, Claudio Freire wrote:\\n> \\n> I rebased the early free patch (patch 3) to apply on top of the v9\\n> patch 2 (it needed some changes). I recognize the early free patch\\n> didn't get nearly as much scrutiny, so I'm fine with commiting only 2\\n> if that one's ready to go but 3 isn't.\\n> \\n> If it's decided to go for fixed 128M segments and a binary search of\\n> segments, I don't think I can get that ready and tested before the\\n> commitfest ends.\\n\\nThis submission has been moved to CF 2017-07.\\n\\n-- \\n-David\\ndavid@pgmasters.net\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 8 Apr 2017 10:10:18 -0400\",\n \"msg_from\": \"David Steele <david@pgmasters.net>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 7, 2017 at 9:12 PM, Andres Freund <andres@anarazel.de> wrote:\\n>> Why do you say exponential growth fragments memory? AFAIK, all those\\n>> allocations are well beyond the point where malloc starts mmaping\\n>> memory, so each of those segments should be a mmap segment,\\n>> independently freeable.\\n>\\n> Not all platforms have that, and even on platforms with it, frequent,\\n> unevenly sized, very large allocations can lead to enough fragmentation\\n> that further allocations are harder and fragment / enlarge the\\n> pagetable.\\n\\nSuch a thing is completely outside my personal experience. I've never\\nheard of a case where a 64-bit platform fails to allocate memory\\nbecause something (what?) is fragmented. Page table memory usage is a\\nconcern at some level, but probably less so for autovacuum workers\\nthan for most backends, because autovacuum workers (where most\\nvacuuming is done) exit after one pass through pg_class. Although I\\nthink our memory footprint is a topic that could use more energy, I\\ndon't really see any reason to think that pagetable bloat caused my\\nunevenly sized allocations in short-lived processes is the place to\\nstart worrying.\\n\\nThat having been said, IIRC, I did propose quite a ways upthread that\\nwe use a fixed chunk size, just because it would use less actual\\nmemory, never mind the size of the page table. I mean, if you\\nallocate in chunks of 64MB, which I think is what I proposed, you'll\\nnever waste more than 64MB. If you allocate in\\nexponentially-increasing chunk sizes starting at 128MB, you could\\neasily waste much more. Let's imagine a 1TB table where 20% of the\\ntuples are dead due to some large bulk operation (a bulk load failed,\\nor a bulk delete succeeded, or a bulk update happened). Back of the\\nenvelope calculation:\\n\\n1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\\nmaintenance_work_mem\\n\\nSo we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\\nenough so we'll allocate another 8GB, for a total of 16256MB, but more\\nthan three-quarters of that last allocation ends up being wasted.\\nI've been told on this list before that doubling is the one true way\\nof increasing the size of an allocated chunk of memory, but I'm still\\na bit unconvinced.\\n\\nOn the other hand, if we did allocate fixed chunks of, say, 64MB, we\\ncould end up with an awful lot of them. For example, in the example\\nabove, 9216MB/64MB = 144 chunks. Is that number of mappings going to\\nmake the VM system unhappy on any of the platforms we care about? Is\\nthat a bigger or smaller problem than what you (Andres) are worrying\\nabout? I don't know.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 11 Apr 2017 14:53:14 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\\n> maintenance_work_mem\\n>\\n> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\\n> enough so we'll allocate another 8GB, for a total of 16256MB, but more\\n> than three-quarters of that last allocation ends up being wasted.\\n> I've been told on this list before that doubling is the one true way\\n> of increasing the size of an allocated chunk of memory, but I'm still\\n> a bit unconvinced.\\n\\nThere you're wrong. The allocation is capped to 1GB, so wastage has an\\nupper bound of 1GB.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 11 Apr 2017 15:59:56 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Apr 11, 2017 at 3:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\\n>> maintenance_work_mem\\n>>\\n>> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\\n>> enough so we'll allocate another 8GB, for a total of 16256MB, but more\\n>> than three-quarters of that last allocation ends up being wasted.\\n>> I've been told on this list before that doubling is the one true way\\n>> of increasing the size of an allocated chunk of memory, but I'm still\\n>> a bit unconvinced.\\n>\\n> There you're wrong. The allocation is capped to 1GB, so wastage has an\\n> upper bound of 1GB.\\n\\nAnd total m_w_m for vacuum is still capped to 12GB (as big you can get\\nwith 32-bit integer indices).\\n\\nSo you can get at most 15 segments (a binary search is thus not worth\\nit), and overallocate by at most 1GB (the maximum segment size).\\n\\nAt least that's my rationale.\\n\\nRemoving the 12GB limit requires a bit of care (there are some 32-bit\\ncounters still around I believe).\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 11 Apr 2017 16:04:44 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Apr 11, 2017 at 2:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\\n>> maintenance_work_mem\\n>>\\n>> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\\n>> enough so we'll allocate another 8GB, for a total of 16256MB, but more\\n>> than three-quarters of that last allocation ends up being wasted.\\n>> I've been told on this list before that doubling is the one true way\\n>> of increasing the size of an allocated chunk of memory, but I'm still\\n>> a bit unconvinced.\\n>\\n> There you're wrong. The allocation is capped to 1GB, so wastage has an\\n> upper bound of 1GB.\\n\\nAh, OK. Sorry, didn't really look at the code. I stand corrected,\\nbut then it seems a bit strange to me that the largest and smallest\\nallocations are only 8x different. I still don't really understand\\nwhat that buys us. What would we lose if we just made 'em all 128MB?\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 11 Apr 2017 15:17:09 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Apr 11, 2017 at 4:17 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Tue, Apr 11, 2017 at 2:59 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Tue, Apr 11, 2017 at 3:53 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>> 1TB / 8kB per page * 60 tuples/page * 20% * 6 bytes/tuple = 9216MB of\\n>>> maintenance_work_mem\\n>>>\\n>>> So we'll allocate 128MB+256MB+512MB+1GB+2GB+4GB which won't be quite\\n>>> enough so we'll allocate another 8GB, for a total of 16256MB, but more\\n>>> than three-quarters of that last allocation ends up being wasted.\\n>>> I've been told on this list before that doubling is the one true way\\n>>> of increasing the size of an allocated chunk of memory, but I'm still\\n>>> a bit unconvinced.\\n>>\\n>> There you're wrong. The allocation is capped to 1GB, so wastage has an\\n>> upper bound of 1GB.\\n>\\n> Ah, OK. Sorry, didn't really look at the code. I stand corrected,\\n> but then it seems a bit strange to me that the largest and smallest\\n> allocations are only 8x different. I still don't really understand\\n> what that buys us.\\n\\nBasically, attacking the problem (that, I think, you mentioned) of\\nvery small systems in which overallocation for small vacuums was an\\nissue.\\n\\nThe \\\"slow start\\\" behavior of starting with smaller segments tries to\\nimprove the situation for small vacuums, not big ones.\\n\\nBy starting at 128M and growing up to 1GB, overallocation is bound to\\nthe range 128M-1GB and is proportional to the amount of dead tuples,\\nnot table size, as it was before. Starting at 128M helps the initial\\nsegment search, but I could readily go for starting at 64M, I don't\\nthink it would make a huge difference. Removing exponential growth,\\nhowever, would.\\n\\nAs the patch stands, small systems (say 32-bit systems) without\\novercommit and with slowly-changing data can now set high m_w_m\\nwithout running into overallocation issues with autovacuum reserving\\ntoo much virtual space, as it will reserve memory only proportional to\\nthe amount of dead tuples. Previously, it would reserve all of m_w_m\\nregardless of whether it was needed or not, with the only exception\\nbeing really small tables, so m_w_m=1GB was unworkable in those cases.\\nNow it should be fine.\\n\\n> What would we lose if we just made 'em all 128MB?\\n\\nTBH, not that much. We'd need 8x compares to find the segment, that\\nforces a switch to binary search of the segments, which is less\\ncache-friendly. So it's more complex code, less cache locality. I'm\\njust not sure what's the benefit given current limits.\\n\\nThe only aim of this multiarray approach was making *virtual address\\nspace reservations* proportional to the amount of actual memory\\nneeded, as opposed to configured limits. It doesn't need to be a tight\\nfit, because calling palloc on its own doesn't actually use that\\nmemory, at least on big allocations like these - the OS will not map\\nthe memory pages until they're first touched. That's true in most\\nmodern systems, and many ancient ones too.\\n\\nIn essence, the patch as it is proposed, doesn't *need* a binary\\nsearch, because the segment list can only grow up to 15 segments at\\nits biggest, and that's a size small enough that linear search will\\noutperform (or at least perform as well as) binary search. Reducing\\nthe initial segment size wouldn't change that. If the 12GB limit is\\nlifted, or the maximum segment size reduced (from 1GB to 128MB for\\nexample), however, that would change.\\n\\nI'd be more in favor of lifting the 12GB limit than of reducing the\\nmaximum segment size, for the reasons above. Raising the 12GB limit\\nhas concrete and readily apparent benefits, whereas using bigger (or\\nsmaller) segments is far more debatable. Yes, that will need a binary\\nsearch. But, I was hoping that could be a second (or third) patch, to\\nkeep things simple, and benefits measurable.\\n\\nAlso, the plan as discussed in this very long thread, was to\\neventually try to turn segments into bitmaps if dead tuple density was\\nbig enough. That benefits considerably from big segments, since lookup\\non a bitmap is O(1) - the bigger the segments, the faster the lookup,\\nas the search on the segment list would be dominant.\\n\\nSo... what shall we do?\\n\\nAt this point, I've given all my arguments for the current design. If\\nthe more senior developers don't agree, I'll be happy to try your way.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 11 Apr 2017 17:38:51 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Apr 11, 2017 at 4:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> In essence, the patch as it is proposed, doesn't *need* a binary\\n> search, because the segment list can only grow up to 15 segments at\\n> its biggest, and that's a size small enough that linear search will\\n> outperform (or at least perform as well as) binary search. Reducing\\n> the initial segment size wouldn't change that. If the 12GB limit is\\n> lifted, or the maximum segment size reduced (from 1GB to 128MB for\\n> example), however, that would change.\\n>\\n> I'd be more in favor of lifting the 12GB limit than of reducing the\\n> maximum segment size, for the reasons above. Raising the 12GB limit\\n> has concrete and readily apparent benefits, whereas using bigger (or\\n> smaller) segments is far more debatable. Yes, that will need a binary\\n> search. But, I was hoping that could be a second (or third) patch, to\\n> keep things simple, and benefits measurable.\\n\\nTo me, it seems a bit short-sighted to say, OK, let's use a linear\\nsearch because there's this 12GB limit so we can limit ourselves to 15\\nsegments. Because somebody will want to remove that 12GB limit, and\\nthen we'll have to revisit the whole thing anyway. I think, anyway.\\n\\nWhat's not clear to me is how sensitive the performance of vacuum is\\nto the number of cycles used here. For a large index, the number of\\nsearches will presumably be quite large, so it does seem worth\\nworrying about performance. But if we just always used a binary\\nsearch, would that lose enough performance with small numbers of\\nsegments that anyone would care? If so, maybe we need to use linear\\nsearch for small numbers of segments and switch to binary search with\\nlarger numbers of segments.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 12 Apr 2017 15:35:28 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Apr 12, 2017 at 4:35 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Tue, Apr 11, 2017 at 4:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> In essence, the patch as it is proposed, doesn't *need* a binary\\n>> search, because the segment list can only grow up to 15 segments at\\n>> its biggest, and that's a size small enough that linear search will\\n>> outperform (or at least perform as well as) binary search. Reducing\\n>> the initial segment size wouldn't change that. If the 12GB limit is\\n>> lifted, or the maximum segment size reduced (from 1GB to 128MB for\\n>> example), however, that would change.\\n>>\\n>> I'd be more in favor of lifting the 12GB limit than of reducing the\\n>> maximum segment size, for the reasons above. Raising the 12GB limit\\n>> has concrete and readily apparent benefits, whereas using bigger (or\\n>> smaller) segments is far more debatable. Yes, that will need a binary\\n>> search. But, I was hoping that could be a second (or third) patch, to\\n>> keep things simple, and benefits measurable.\\n>\\n> To me, it seems a bit short-sighted to say, OK, let's use a linear\\n> search because there's this 12GB limit so we can limit ourselves to 15\\n> segments. Because somebody will want to remove that 12GB limit, and\\n> then we'll have to revisit the whole thing anyway. I think, anyway.\\n\\nOk, attached an updated patch that implements the binary search\\n\\n> What's not clear to me is how sensitive the performance of vacuum is\\n> to the number of cycles used here. For a large index, the number of\\n> searches will presumably be quite large, so it does seem worth\\n> worrying about performance. But if we just always used a binary\\n> search, would that lose enough performance with small numbers of\\n> segments that anyone would care? If so, maybe we need to use linear\\n> search for small numbers of segments and switch to binary search with\\n> larger numbers of segments.\\n\\nI just went and tested.\\n\\nI implemented the hybrid binary search attached, and ran a few tests\\nwith and without the sequential code enabled, at small scales.\\n\\nThe difference is statistically significant, but small (less than 3%).\\nWith proper optimization of the binary search, however, the difference\\nflips:\\n\\nclaudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\\nfullbinary.s100.times\\nvacuum_bench_s100.1.shufp80.log:CPU: user: 6.20 s, system: 1.42 s,\\nelapsed: 18.34 s.\\nvacuum_bench_s100.2.shufp80.log:CPU: user: 6.44 s, system: 1.40 s,\\nelapsed: 19.75 s.\\nvacuum_bench_s100.3.shufp80.log:CPU: user: 6.28 s, system: 1.41 s,\\nelapsed: 18.48 s.\\nvacuum_bench_s100.4.shufp80.log:CPU: user: 6.39 s, system: 1.51 s,\\nelapsed: 20.60 s.\\nvacuum_bench_s100.5.shufp80.log:CPU: user: 6.26 s, system: 1.42 s,\\nelapsed: 19.16 s.\\n\\nclaudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\\nhybridbinary.s100.times\\nvacuum_bench_s100.1.shufp80.log:CPU: user: 6.49 s, system: 1.39 s,\\nelapsed: 19.15 s.\\nvacuum_bench_s100.2.shufp80.log:CPU: user: 6.36 s, system: 1.33 s,\\nelapsed: 18.40 s.\\nvacuum_bench_s100.3.shufp80.log:CPU: user: 6.36 s, system: 1.31 s,\\nelapsed: 18.87 s.\\nvacuum_bench_s100.4.shufp80.log:CPU: user: 6.59 s, system: 1.35 s,\\nelapsed: 26.43 s.\\nvacuum_bench_s100.5.shufp80.log:CPU: user: 6.54 s, system: 1.28 s,\\nelapsed: 20.02 s.\\n\\nThat's after inlining the compare on both the linear and sequential\\ncode, and it seems it lets the compiler optimize the binary search to\\nthe point where it outperforms the sequential search.\\n\\nThat's not the case when the compare isn't inlined.\\n\\nThat seems in line with [1], that show the impact of various\\noptimizations on both algorithms. It's clearly a close enough race\\nthat optimizations play a huge role.\\n\\nSince we're not likely to go and implement SSE2-optimized versions, I\\nbelieve I'll leave the binary search only. That's the attached patch\\nset.\\n\\nI'm running the full test suite, but that takes a very long while.\\nI'll post the results when they're done.\\n\\n[1] https://schani.wordpress.com/2010/04/30/linear-vs-binary-search/\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 20 Apr 2017 18:24:13 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Apr 20, 2017 at 5:24 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> What's not clear to me is how sensitive the performance of vacuum is\\n>> to the number of cycles used here. For a large index, the number of\\n>> searches will presumably be quite large, so it does seem worth\\n>> worrying about performance. But if we just always used a binary\\n>> search, would that lose enough performance with small numbers of\\n>> segments that anyone would care? If so, maybe we need to use linear\\n>> search for small numbers of segments and switch to binary search with\\n>> larger numbers of segments.\\n>\\n> I just went and tested.\\n\\nThanks!\\n\\n> That's after inlining the compare on both the linear and sequential\\n> code, and it seems it lets the compiler optimize the binary search to\\n> the point where it outperforms the sequential search.\\n>\\n> That's not the case when the compare isn't inlined.\\n>\\n> That seems in line with [1], that show the impact of various\\n> optimizations on both algorithms. It's clearly a close enough race\\n> that optimizations play a huge role.\\n>\\n> Since we're not likely to go and implement SSE2-optimized versions, I\\n> believe I'll leave the binary search only. That's the attached patch\\n> set.\\n\\nThat sounds reasonable based on your test results. I guess part of\\nwhat I was wondering is whether a vacuum on a table large enough to\\nrequire multiple gigabytes of work_mem isn't likely to be I/O-bound\\nanyway. If so, a few cycles one way or the other other isn't likely\\nto matter much. If not, where exactly are all of those CPU cycles\\ngoing?\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 23 Apr 2017 11:41:08 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Sun, Apr 23, 2017 at 12:41 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> That's after inlining the compare on both the linear and sequential\\n>> code, and it seems it lets the compiler optimize the binary search to\\n>> the point where it outperforms the sequential search.\\n>>\\n>> That's not the case when the compare isn't inlined.\\n>>\\n>> That seems in line with [1], that show the impact of various\\n>> optimizations on both algorithms. It's clearly a close enough race\\n>> that optimizations play a huge role.\\n>>\\n>> Since we're not likely to go and implement SSE2-optimized versions, I\\n>> believe I'll leave the binary search only. That's the attached patch\\n>> set.\\n>\\n> That sounds reasonable based on your test results. I guess part of\\n> what I was wondering is whether a vacuum on a table large enough to\\n> require multiple gigabytes of work_mem isn't likely to be I/O-bound\\n> anyway. If so, a few cycles one way or the other other isn't likely\\n> to matter much. If not, where exactly are all of those CPU cycles\\n> going?\\n\\nI haven't been able to produce a table large enough to get a CPU-bound\\nvacuum, so such a case is likely to require huge storage and a very\\npowerful I/O system. Mine can only get about 100MB/s tops, and at that\\nspeed, vacuum is I/O bound even for multi-GB work_mem. That's why I've\\nbeen using the reported CPU time as benchmark.\\n\\nBTW, I left the benchmark script running all weekend at the office,\\nand when I got back a power outage had aborted it. In a few days I'll\\nbe out on vacation, so I'm not sure I'll get the benchmark results\\nanytime soon. But this patch moved to 11.0 I guess there's no rush.\\n\\nJust FTR, in case I leave before the script is done, the script got to\\nscale 400 before the outage:\\n\\nINFO: vacuuming \\\"public.pgbench_accounts\\\"\\nINFO: scanned index \\\"pgbench_accounts_pkey\\\" to remove 40000000 row versions\\nDETAIL: CPU: user: 5.94 s, system: 1.26 s, elapsed: 26.77 s.\\nINFO: \\\"pgbench_accounts\\\": removed 40000000 row versions in 655739 pages\\nDETAIL: CPU: user: 3.36 s, system: 2.57 s, elapsed: 61.67 s.\\nINFO: index \\\"pgbench_accounts_pkey\\\" now contains 0 row versions in 109679 pages\\nDETAIL: 40000000 index row versions were removed.\\n109289 index pages have been deleted, 0 are currently reusable.\\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.06 s.\\nINFO: \\\"pgbench_accounts\\\": found 38925546 removable, 0 nonremovable\\nrow versions in 655738 out of 655738 pages\\nDETAIL: 0 dead row versions cannot be removed yet, oldest xmin: 1098\\nThere were 0 unused item pointers.\\nSkipped 0 pages due to buffer pins, 0 frozen pages.\\n0 pages are entirely empty.\\nCPU: user: 15.34 s, system: 6.95 s, elapsed: 126.21 s.\\nINFO: \\\"pgbench_accounts\\\": truncated 655738 to 0 pages\\nDETAIL: CPU: user: 0.22 s, system: 2.10 s, elapsed: 8.10 s.\\n\\nIn summary:\\n\\nbinsrch v10:\\n\\ns100: CPU: user: 3.02 s, system: 1.51 s, elapsed: 16.43 s.\\ns400: CPU: user: 15.34 s, system: 6.95 s, elapsed: 126.21 s.\\n\\nThe old results:\\n\\nOld Patched (sequential search):\\n\\ns100: CPU: user: 3.21 s, system: 1.54 s, elapsed: 18.95 s.\\ns400: CPU: user: 14.03 s, system: 6.35 s, elapsed: 107.71 s.\\ns4000: CPU: user: 228.17 s, system: 108.33 s, elapsed: 3017.30 s.\\n\\nUnpatched:\\n\\ns100: CPU: user: 3.39 s, system: 1.64 s, elapsed: 18.67 s.\\ns400: CPU: user: 15.39 s, system: 7.03 s, elapsed: 114.91 s.\\ns4000: CPU: user: 282.21 s, system: 105.95 s, elapsed: 3017.28 s.\\n\\nI wouldn't fret over the slight slowdown vs the old patch, it could be\\nnoise (the script only completed a single run at scale 400).\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 24 Apr 2017 16:57:24 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Apr 24, 2017 at 3:57 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> I wouldn't fret over the slight slowdown vs the old patch, it could be\\n> noise (the script only completed a single run at scale 400).\\n\\nYeah, seems fine.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 25 Apr 2017 11:20:49 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 21, 2017 at 6:24 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Apr 12, 2017 at 4:35 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> On Tue, Apr 11, 2017 at 4:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> In essence, the patch as it is proposed, doesn't *need* a binary\\n>>> search, because the segment list can only grow up to 15 segments at\\n>>> its biggest, and that's a size small enough that linear search will\\n>>> outperform (or at least perform as well as) binary search. Reducing\\n>>> the initial segment size wouldn't change that. If the 12GB limit is\\n>>> lifted, or the maximum segment size reduced (from 1GB to 128MB for\\n>>> example), however, that would change.\\n>>>\\n>>> I'd be more in favor of lifting the 12GB limit than of reducing the\\n>>> maximum segment size, for the reasons above. Raising the 12GB limit\\n>>> has concrete and readily apparent benefits, whereas using bigger (or\\n>>> smaller) segments is far more debatable. Yes, that will need a binary\\n>>> search. But, I was hoping that could be a second (or third) patch, to\\n>>> keep things simple, and benefits measurable.\\n>>\\n>> To me, it seems a bit short-sighted to say, OK, let's use a linear\\n>> search because there's this 12GB limit so we can limit ourselves to 15\\n>> segments. Because somebody will want to remove that 12GB limit, and\\n>> then we'll have to revisit the whole thing anyway. I think, anyway.\\n>\\n> Ok, attached an updated patch that implements the binary search\\n>\\n>> What's not clear to me is how sensitive the performance of vacuum is\\n>> to the number of cycles used here. For a large index, the number of\\n>> searches will presumably be quite large, so it does seem worth\\n>> worrying about performance. But if we just always used a binary\\n>> search, would that lose enough performance with small numbers of\\n>> segments that anyone would care? If so, maybe we need to use linear\\n>> search for small numbers of segments and switch to binary search with\\n>> larger numbers of segments.\\n>\\n> I just went and tested.\\n>\\n> I implemented the hybrid binary search attached, and ran a few tests\\n> with and without the sequential code enabled, at small scales.\\n>\\n> The difference is statistically significant, but small (less than 3%).\\n> With proper optimization of the binary search, however, the difference\\n> flips:\\n>\\n> claudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\\n> fullbinary.s100.times\\n> vacuum_bench_s100.1.shufp80.log:CPU: user: 6.20 s, system: 1.42 s,\\n> elapsed: 18.34 s.\\n> vacuum_bench_s100.2.shufp80.log:CPU: user: 6.44 s, system: 1.40 s,\\n> elapsed: 19.75 s.\\n> vacuum_bench_s100.3.shufp80.log:CPU: user: 6.28 s, system: 1.41 s,\\n> elapsed: 18.48 s.\\n> vacuum_bench_s100.4.shufp80.log:CPU: user: 6.39 s, system: 1.51 s,\\n> elapsed: 20.60 s.\\n> vacuum_bench_s100.5.shufp80.log:CPU: user: 6.26 s, system: 1.42 s,\\n> elapsed: 19.16 s.\\n>\\n> claudiofreire@klaumpp:~/src/postgresql.vacuum> fgrep shufp80\\n> hybridbinary.s100.times\\n> vacuum_bench_s100.1.shufp80.log:CPU: user: 6.49 s, system: 1.39 s,\\n> elapsed: 19.15 s.\\n> vacuum_bench_s100.2.shufp80.log:CPU: user: 6.36 s, system: 1.33 s,\\n> elapsed: 18.40 s.\\n> vacuum_bench_s100.3.shufp80.log:CPU: user: 6.36 s, system: 1.31 s,\\n> elapsed: 18.87 s.\\n> vacuum_bench_s100.4.shufp80.log:CPU: user: 6.59 s, system: 1.35 s,\\n> elapsed: 26.43 s.\\n> vacuum_bench_s100.5.shufp80.log:CPU: user: 6.54 s, system: 1.28 s,\\n> elapsed: 20.02 s.\\n>\\n> That's after inlining the compare on both the linear and sequential\\n> code, and it seems it lets the compiler optimize the binary search to\\n> the point where it outperforms the sequential search.\\n>\\n> That's not the case when the compare isn't inlined.\\n>\\n> That seems in line with [1], that show the impact of various\\n> optimizations on both algorithms. It's clearly a close enough race\\n> that optimizations play a huge role.\\n>\\n> Since we're not likely to go and implement SSE2-optimized versions, I\\n> believe I'll leave the binary search only. That's the attached patch\\n> set.\\n>\\n> I'm running the full test suite, but that takes a very long while.\\n> I'll post the results when they're done.\\n>\\n> [1] https://schani.wordpress.com/2010/04/30/linear-vs-binary-search/\\n\\nThank you for updating the patch.\\n\\nI've read this patch again and here are some review comments.\\n\\n+ * Lookup in that structure proceeds sequentially in the list of segments,\\n+ * and with a binary search within each segment. Since segment's size grows\\n+ * exponentially, this retains O(log N) lookup complexity (2 log N to be\\n+ * precise).\\n\\nIIUC we now do binary search even over the list of segments.\\n\\n-----\\n\\nWe often fetch a particular dead tuple segment. How about providing a\\nmacro for easier understanding?\\nFor example,\\n\\n #define GetDeadTuplsSegment(lvrelstats, seg) \\\\\\n (&(lvrelstats)->dead_tuples.dt_segments[(seg)])\\n\\n-----\\n\\n+ if (vacrelstats->dead_tuples.num_segs == 0)\\n+ return;\\n+\\n\\n+ /* If uninitialized, we have no tuples to delete from the indexes */\\n+ if (vacrelstats->dead_tuples.num_segs == 0)\\n+ {\\n+ return;\\n+ }\\n\\n+ if (vacrelstats->dead_tuples.num_segs == 0)\\n+ return false;\\n+\\n\\nAs I listed, there is code to check if dead tuple is initialized\\nalready in some places where doing actual vacuum.\\nI guess that it should not happen that we attempt to vacuum a\\ntable/index page while not having any dead tuple. Is it better to have\\nAssert or ereport instead?\\n\\n-----\\n\\n@@ -1915,2 +2002,2 @@ count_nondeletable_pages(Relation onerel,\\nLVRelStats *vacrelstats)\\n- BlockNumber prefetchStart;\\n- BlockNumber pblkno;\\n+ BlockNumber prefetchStart;\\n+ BlockNumber pblkno;\\n\\nI think that it's a unnecessary change.\\n\\n-----\\n\\n+ /* Search for the segment likely to contain the item pointer */\\n+ iseg = vac_itemptr_binsrch(\\n+ (void *) itemptr,\\n+ (void *)\\n&(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\\n+ vacrelstats->dead_tuples.last_seg + 1,\\n+ sizeof(DeadTuplesSegment));\\n+\\n\\nI think that we can change the above to;\\n\\n+ /* Search for the segment likely to contain the item pointer */\\n+ iseg = vac_itemptr_binsrch(\\n+ (void *) itemptr,\\n+ (void *) &(seg->last_dead_tuple),\\n+ vacrelstats->dead_tuples.last_seg + 1,\\n+ sizeof(DeadTuplesSegment));\\n\\nWe set \\\"seg = vacrelstats->dead_tuples.dt_segments\\\" just before this.\\n\\nRegards,\\n\\n--\\nMasahiko Sawada\\nNIPPON TELEGRAPH AND TELEPHONE CORPORATION\\nNTT Open Source Software Center\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 27 Apr 2017 16:25:11 +0900\",\n \"msg_from\": \"Masahiko Sawada <sawada.mshk@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Sorry for the delay, I had extended vacations that kept me away from\\nmy test rigs, and afterward testing too, liteally, a few weeks.\\n\\nI built a more thoroguh test script that produced some interesting\\nresults. Will attach the results.\\n\\nFor now, to the review comments:\\n\\nOn Thu, Apr 27, 2017 at 4:25 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> I've read this patch again and here are some review comments.\\n>\\n> + * Lookup in that structure proceeds sequentially in the list of segments,\\n> + * and with a binary search within each segment. Since segment's size grows\\n> + * exponentially, this retains O(log N) lookup complexity (2 log N to be\\n> + * precise).\\n>\\n> IIUC we now do binary search even over the list of segments.\\n\\nRight\\n\\n>\\n> -----\\n>\\n> We often fetch a particular dead tuple segment. How about providing a\\n> macro for easier understanding?\\n> For example,\\n>\\n> #define GetDeadTuplsSegment(lvrelstats, seg) \\\\\\n> (&(lvrelstats)->dead_tuples.dt_segments[(seg)])\\n>\\n> -----\\n>\\n> + if (vacrelstats->dead_tuples.num_segs == 0)\\n> + return;\\n> +\\n>\\n> + /* If uninitialized, we have no tuples to delete from the indexes */\\n> + if (vacrelstats->dead_tuples.num_segs == 0)\\n> + {\\n> + return;\\n> + }\\n>\\n> + if (vacrelstats->dead_tuples.num_segs == 0)\\n> + return false;\\n> +\\n\\nOk\\n\\n> As I listed, there is code to check if dead tuple is initialized\\n> already in some places where doing actual vacuum.\\n> I guess that it should not happen that we attempt to vacuum a\\n> table/index page while not having any dead tuple. Is it better to have\\n> Assert or ereport instead?\\n\\nI'm not sure. Having a non-empty dead tuples array is not necessary to\\nbe able to honor the contract in the docstring. Most of those functions\\nclean up the heap/index of dead tuples given the array of dead tuples,\\nwhich is a no-op for an empty array.\\n\\nThe code that calls those functions doesn't bother calling if the array\\nis known empty, true, but there's no compelling reason to enforce that at the\\ninterface. Doing so could cause subtle bugs rather than catch them\\n(in the form of unexpected assertion failures, if some caller forgot to\\ncheck the dead tuples array for emptiness).\\n\\nIf you're worried about the possibility that some bugs fails to record\\ndead tuples in the array, and thus makes VACUUM silently ineffective,\\nI instead added a test for that case. This should be a better approach,\\nsince it's more likely to catch unexpected failure modes than an assert.\\n\\n> @@ -1915,2 +2002,2 @@ count_nondeletable_pages(Relation onerel,\\n> LVRelStats *vacrelstats)\\n> - BlockNumber prefetchStart;\\n> - BlockNumber pblkno;\\n> + BlockNumber prefetchStart;\\n> + BlockNumber pblkno;\\n>\\n> I think that it's a unnecessary change.\\n\\nYep. But funnily that's how it's now in master.\\n\\n>\\n> -----\\n>\\n> + /* Search for the segment likely to contain the item pointer */\\n> + iseg = vac_itemptr_binsrch(\\n> + (void *) itemptr,\\n> + (void *)\\n> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\\n> + vacrelstats->dead_tuples.last_seg + 1,\\n> + sizeof(DeadTuplesSegment));\\n> +\\n>\\n> I think that we can change the above to;\\n>\\n> + /* Search for the segment likely to contain the item pointer */\\n> + iseg = vac_itemptr_binsrch(\\n> + (void *) itemptr,\\n> + (void *) &(seg->last_dead_tuple),\\n> + vacrelstats->dead_tuples.last_seg + 1,\\n> + sizeof(DeadTuplesSegment));\\n>\\n> We set \\\"seg = vacrelstats->dead_tuples.dt_segments\\\" just before this.\\n\\nRight\\n\\nAttached is a current version of both patches, rebased since we're at it.\\n\\nI'm also attaching the output from the latest benchmark runs, in raw\\n(tar.bz2) and digested (bench_report) forms, the script used to run\\nthem (vacuumbench.sh) and to produce the reports\\n(vacuum_bench_report.sh).\\n\\nThose are before the changes in the review. While I don't expect any\\nchange, I'll re-run some of them just in case, and try to investigate\\nthe slowdown. But that will take forever. Each run takes about a week\\non my test rig, and I don't have enough hardware to parallelize the\\ntests. I will run a test on a snapshot of a particularly troublesome\\nproduction database we have, that should be interesting.\\n\\nThe benchmarks show a consistent improvement at scale 400, which may\\nbe related to the search implementation being better somehow, and a\\nslowdown at scale 4000 in some variants. I believe this is due to\\nthose variants having highly clustered indexes. While the \\\"shuf\\\"\\n(shuffled) variantes were intended to be the opposite of that, I\\nsuspect I somehow failed to get the desired outcome, so I'll be\\ndouble-checking that.\\n\\nIn any case the slowdown is only materialized when vacuuming with a\\nlarge mwm setting, which is something that shouldn't happen\\nunintentionally.\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 10 Jul 2017 20:04:42 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Resending without the .tar.bz2 that get blocked\\n\\n\\nSorry for the delay, I had extended vacations that kept me away from\\nmy test rigs, and afterward testing too, liteally, a few weeks.\\n\\nI built a more thoroguh test script that produced some interesting\\nresults. Will attach the results.\\n\\nFor now, to the review comments:\\n\\nOn Thu, Apr 27, 2017 at 4:25 AM, Masahiko Sawada <sawada.mshk@gmail.com> wrote:\\n> I've read this patch again and here are some review comments.\\n>\\n> + * Lookup in that structure proceeds sequentially in the list of segments,\\n> + * and with a binary search within each segment. Since segment's size grows\\n> + * exponentially, this retains O(log N) lookup complexity (2 log N to be\\n> + * precise).\\n>\\n> IIUC we now do binary search even over the list of segments.\\n\\nRight\\n\\n>\\n> -----\\n>\\n> We often fetch a particular dead tuple segment. How about providing a\\n> macro for easier understanding?\\n> For example,\\n>\\n> #define GetDeadTuplsSegment(lvrelstats, seg) \\\\\\n> (&(lvrelstats)->dead_tuples.dt_segments[(seg)])\\n>\\n> -----\\n>\\n> + if (vacrelstats->dead_tuples.num_segs == 0)\\n> + return;\\n> +\\n>\\n> + /* If uninitialized, we have no tuples to delete from the indexes */\\n> + if (vacrelstats->dead_tuples.num_segs == 0)\\n> + {\\n> + return;\\n> + }\\n>\\n> + if (vacrelstats->dead_tuples.num_segs == 0)\\n> + return false;\\n> +\\n\\nOk\\n\\n> As I listed, there is code to check if dead tuple is initialized\\n> already in some places where doing actual vacuum.\\n> I guess that it should not happen that we attempt to vacuum a\\n> table/index page while not having any dead tuple. Is it better to have\\n> Assert or ereport instead?\\n\\nI'm not sure. Having a non-empty dead tuples array is not necessary to\\nbe able to honor the contract in the docstring. Most of those functions\\nclean up the heap/index of dead tuples given the array of dead tuples,\\nwhich is a no-op for an empty array.\\n\\nThe code that calls those functions doesn't bother calling if the array\\nis known empty, true, but there's no compelling reason to enforce that at the\\ninterface. Doing so could cause subtle bugs rather than catch them\\n(in the form of unexpected assertion failures, if some caller forgot to\\ncheck the dead tuples array for emptiness).\\n\\nIf you're worried about the possibility that some bugs fails to record\\ndead tuples in the array, and thus makes VACUUM silently ineffective,\\nI instead added a test for that case. This should be a better approach,\\nsince it's more likely to catch unexpected failure modes than an assert.\\n\\n> @@ -1915,2 +2002,2 @@ count_nondeletable_pages(Relation onerel,\\n> LVRelStats *vacrelstats)\\n> - BlockNumber prefetchStart;\\n> - BlockNumber pblkno;\\n> + BlockNumber prefetchStart;\\n> + BlockNumber pblkno;\\n>\\n> I think that it's a unnecessary change.\\n\\nYep. But funnily that's how it's now in master.\\n\\n>\\n> -----\\n>\\n> + /* Search for the segment likely to contain the item pointer */\\n> + iseg = vac_itemptr_binsrch(\\n> + (void *) itemptr,\\n> + (void *)\\n> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\\n> + vacrelstats->dead_tuples.last_seg + 1,\\n> + sizeof(DeadTuplesSegment));\\n> +\\n>\\n> I think that we can change the above to;\\n>\\n> + /* Search for the segment likely to contain the item pointer */\\n> + iseg = vac_itemptr_binsrch(\\n> + (void *) itemptr,\\n> + (void *) &(seg->last_dead_tuple),\\n> + vacrelstats->dead_tuples.last_seg + 1,\\n> + sizeof(DeadTuplesSegment));\\n>\\n> We set \\\"seg = vacrelstats->dead_tuples.dt_segments\\\" just before this.\\n\\nRight\\n\\nAttached is a current version of both patches, rebased since we're at it.\\n\\nI'm also attaching the output from the latest benchmark runs, in raw\\n(tar.bz2) and digested (bench_report) forms, the script used to run\\nthem (vacuumbench.sh) and to produce the reports\\n(vacuum_bench_report.sh).\\n\\nThose are before the changes in the review. While I don't expect any\\nchange, I'll re-run some of them just in case, and try to investigate\\nthe slowdown. But that will take forever. Each run takes about a week\\non my test rig, and I don't have enough hardware to parallelize the\\ntests. I will run a test on a snapshot of a particularly troublesome\\nproduction database we have, that should be interesting.\\n\\nThe benchmarks show a consistent improvement at scale 400, which may\\nbe related to the search implementation being better somehow, and a\\nslowdown at scale 4000 in some variants. I believe this is due to\\nthose variants having highly clustered indexes. While the \\\"shuf\\\"\\n(shuffled) variantes were intended to be the opposite of that, I\\nsuspect I somehow failed to get the desired outcome, so I'll be\\ndouble-checking that.\\n\\nIn any case the slowdown is only materialized when vacuuming with a\\nlarge mwm setting, which is something that shouldn't happen\\nunintentionally.\\n\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 11 Jul 2017 13:51:03 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Fwd: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Thank you for the patch and benchmark results, I have a couple remarks.\\nFirstly, padding in DeadTuplesSegment\\n\\ntypedef struct DeadTuplesSegment\\n\\n{\\n\\n ItemPointerData last_dead_tuple; /* Copy of the last dead tuple \\n(unset\\n\\n * until the segment is fully\\n\\n * populated). Keep it first to \\nsimplify\\n\\n * binary searches */\\n\\n unsigned short padding; /* Align dt_tids to 32-bits,\\n\\n * sizeof(ItemPointerData) is aligned to\\n\\n * short, so add a padding short, to \\nmake the\\n\\n * size of DeadTuplesSegment a multiple of\\n\\n * 32-bits and align integer components \\nfor\\n\\n * better performance during lookups \\ninto the\\n\\n * multiarray */\\n\\n int num_dead_tuples; /* # of entries in the segment */\\n\\n int max_dead_tuples; /* # of entries allocated in the \\nsegment */\\n\\n ItemPointer dt_tids; /* Array of dead tuples */\\n\\n} DeadTuplesSegment;\\n\\nIn the comments to ItemPointerData is written that it is 6 bytes long, \\nbut can be padded to 8 bytes by some compilers, so if we add padding in \\na current way, there is no guaranty that it will be done as it is \\nexpected. The other way to do it with pg_attribute_alligned. But in my \\nopinion, there is no need to do it manually, because the compiler will \\ndo this optimization itself.\\n\\nOn 11.07.2017 19:51, Claudio Freire wrote:\\n>> -----\\n>>\\n>> + /* Search for the segment likely to contain the item pointer */\\n>> + iseg = vac_itemptr_binsrch(\\n>> + (void *) itemptr,\\n>> + (void *)\\n>> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\\n>> + vacrelstats->dead_tuples.last_seg + 1,\\n>> + sizeof(DeadTuplesSegment));\\n>> +\\n>>\\n>> I think that we can change the above to;\\n>>\\n>> + /* Search for the segment likely to contain the item pointer */\\n>> + iseg = vac_itemptr_binsrch(\\n>> + (void *) itemptr,\\n>> + (void *) &(seg->last_dead_tuple),\\n>> + vacrelstats->dead_tuples.last_seg + 1,\\n>> + sizeof(DeadTuplesSegment));\\n>>\\n>> We set \\\"seg = vacrelstats->dead_tuples.dt_segments\\\" just before this.\\n> Right\\nIn my mind, if you change vacrelstats->dead_tuples.last_seg + 1 with \\nGetNumDeadTuplesSegments(vacrelstats), it would be more meaningful.\\nBesides, you can change the vac_itemptr_binsrch within the segment with \\nstdlib bsearch, like:\\n\\n res = (ItemPointer) bsearch((void *) itemptr,\\n\\n (void *) seg->dt_tids,\\n\\n seg->num_dead_tuples,\\n\\n sizeof(ItemPointerData),\\n\\n vac_cmp_itemptr);\\n\\n return (res != NULL);\\n\\n> Those are before the changes in the review. While I don't expect any\\n> change, I'll re-run some of them just in case, and try to investigate\\n> the slowdown. But that will take forever. Each run takes about a week\\n> on my test rig, and I don't have enough hardware to parallelize the\\n> tests. I will run a test on a snapshot of a particularly troublesome\\n> production database we have, that should be interesting.\\nVery interesting, waiting for the results.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 12 Jul 2017 17:48:04 +0300\",\n \"msg_from\": \"Alexey Chernyshov <a.chernyshov@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Jul 12, 2017 at 11:48 AM, Alexey Chernyshov\\n<a.chernyshov@postgrespro.ru> wrote:\\n> Thank you for the patch and benchmark results, I have a couple remarks.\\n> Firstly, padding in DeadTuplesSegment\\n>\\n> typedef struct DeadTuplesSegment\\n>\\n> {\\n>\\n> ItemPointerData last_dead_tuple; /* Copy of the last dead tuple\\n> (unset\\n>\\n> * until the segment is fully\\n>\\n> * populated). Keep it first to\\n> simplify\\n>\\n> * binary searches */\\n>\\n> unsigned short padding; /* Align dt_tids to 32-bits,\\n>\\n> * sizeof(ItemPointerData) is aligned to\\n>\\n> * short, so add a padding short, to make\\n> the\\n>\\n> * size of DeadTuplesSegment a multiple of\\n>\\n> * 32-bits and align integer components for\\n>\\n> * better performance during lookups into\\n> the\\n>\\n> * multiarray */\\n>\\n> int num_dead_tuples; /* # of entries in the segment */\\n>\\n> int max_dead_tuples; /* # of entries allocated in the\\n> segment */\\n>\\n> ItemPointer dt_tids; /* Array of dead tuples */\\n>\\n> } DeadTuplesSegment;\\n>\\n> In the comments to ItemPointerData is written that it is 6 bytes long, but\\n> can be padded to 8 bytes by some compilers, so if we add padding in a\\n> current way, there is no guaranty that it will be done as it is expected.\\n> The other way to do it with pg_attribute_alligned. But in my opinion, there\\n> is no need to do it manually, because the compiler will do this optimization\\n> itself.\\n\\nI'll look into it. But my experience is that compilers won't align\\nstruct size like this, only attributes, and this attribute is composed\\nof 16-bit attributes so it doesn't get aligned by default.\\n\\n> On 11.07.2017 19:51, Claudio Freire wrote:\\n>>>\\n>>> -----\\n>>>\\n>>> + /* Search for the segment likely to contain the item pointer */\\n>>> + iseg = vac_itemptr_binsrch(\\n>>> + (void *) itemptr,\\n>>> + (void *)\\n>>> &(vacrelstats->dead_tuples.dt_segments->last_dead_tuple),\\n>>> + vacrelstats->dead_tuples.last_seg + 1,\\n>>> + sizeof(DeadTuplesSegment));\\n>>> +\\n>>>\\n>>> I think that we can change the above to;\\n>>>\\n>>> + /* Search for the segment likely to contain the item pointer */\\n>>> + iseg = vac_itemptr_binsrch(\\n>>> + (void *) itemptr,\\n>>> + (void *) &(seg->last_dead_tuple),\\n>>> + vacrelstats->dead_tuples.last_seg + 1,\\n>>> + sizeof(DeadTuplesSegment));\\n>>>\\n>>> We set \\\"seg = vacrelstats->dead_tuples.dt_segments\\\" just before this.\\n>>\\n>> Right\\n>\\n> In my mind, if you change vacrelstats->dead_tuples.last_seg + 1 with\\n> GetNumDeadTuplesSegments(vacrelstats), it would be more meaningful.\\n\\nIt's not the same thing. The first run it might, but after a reset of\\nthe multiarray, num segments is the allocated size, while last_seg is\\nthe last one filled with data.\\n\\n> Besides, you can change the vac_itemptr_binsrch within the segment with\\n> stdlib bsearch, like:\\n>\\n> res = (ItemPointer) bsearch((void *) itemptr,\\n>\\n> (void *) seg->dt_tids,\\n>\\n> seg->num_dead_tuples,\\n>\\n> sizeof(ItemPointerData),\\n>\\n> vac_cmp_itemptr);\\n>\\n> return (res != NULL);\\n\\nThe stdlib's bsearch is quite slower. The custom bsearch inlines the\\ncomparison making it able to factor out of the loop quite a bit of\\nlogic, and in general generate far more specialized assembly.\\n\\nFor the compiler to optimize the stdlib's bsearch call, whole-program\\noptimization should be enabled, something that is unlikely. Even then,\\nit may not be able to, due to aliasing rules.\\n\\nThis is what I came up to make the new approach's performance on par\\nor better than the old one, in CPU cycles. In fact, benchmarks show\\nthat time spent on the CPU is lower now, in large part, due to this.\\n\\nIt's not like it's the first custom binary search in postgres, also.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 12 Jul 2017 13:08:12 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Jul 12, 2017 at 1:08 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Jul 12, 2017 at 11:48 AM, Alexey Chernyshov\\n> <a.chernyshov@postgrespro.ru> wrote:\\n>> Thank you for the patch and benchmark results, I have a couple remarks.\\n>> Firstly, padding in DeadTuplesSegment\\n>>\\n>> typedef struct DeadTuplesSegment\\n>>\\n>> {\\n>>\\n>> ItemPointerData last_dead_tuple; /* Copy of the last dead tuple\\n>> (unset\\n>>\\n>> * until the segment is fully\\n>>\\n>> * populated). Keep it first to\\n>> simplify\\n>>\\n>> * binary searches */\\n>>\\n>> unsigned short padding; /* Align dt_tids to 32-bits,\\n>>\\n>> * sizeof(ItemPointerData) is aligned to\\n>>\\n>> * short, so add a padding short, to make\\n>> the\\n>>\\n>> * size of DeadTuplesSegment a multiple of\\n>>\\n>> * 32-bits and align integer components for\\n>>\\n>> * better performance during lookups into\\n>> the\\n>>\\n>> * multiarray */\\n>>\\n>> int num_dead_tuples; /* # of entries in the segment */\\n>>\\n>> int max_dead_tuples; /* # of entries allocated in the\\n>> segment */\\n>>\\n>> ItemPointer dt_tids; /* Array of dead tuples */\\n>>\\n>> } DeadTuplesSegment;\\n>>\\n>> In the comments to ItemPointerData is written that it is 6 bytes long, but\\n>> can be padded to 8 bytes by some compilers, so if we add padding in a\\n>> current way, there is no guaranty that it will be done as it is expected.\\n>> The other way to do it with pg_attribute_alligned. But in my opinion, there\\n>> is no need to do it manually, because the compiler will do this optimization\\n>> itself.\\n>\\n> I'll look into it. But my experience is that compilers won't align\\n> struct size like this, only attributes, and this attribute is composed\\n> of 16-bit attributes so it doesn't get aligned by default.\\n\\nDoing sizeof(DeadTuplesSegment) suggests you were indeed right, at\\nleast in GCC. I'll remove the padding.\\n\\nSeems I just got the wrong impression at some point.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 12 Jul 2017 13:29:21 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Jul 12, 2017 at 1:29 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Jul 12, 2017 at 1:08 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Wed, Jul 12, 2017 at 11:48 AM, Alexey Chernyshov\\n>> <a.chernyshov@postgrespro.ru> wrote:\\n>>> Thank you for the patch and benchmark results, I have a couple remarks.\\n>>> Firstly, padding in DeadTuplesSegment\\n>>>\\n>>> typedef struct DeadTuplesSegment\\n>>>\\n>>> {\\n>>>\\n>>> ItemPointerData last_dead_tuple; /* Copy of the last dead tuple\\n>>> (unset\\n>>>\\n>>> * until the segment is fully\\n>>>\\n>>> * populated). Keep it first to\\n>>> simplify\\n>>>\\n>>> * binary searches */\\n>>>\\n>>> unsigned short padding; /* Align dt_tids to 32-bits,\\n>>>\\n>>> * sizeof(ItemPointerData) is aligned to\\n>>>\\n>>> * short, so add a padding short, to make\\n>>> the\\n>>>\\n>>> * size of DeadTuplesSegment a multiple of\\n>>>\\n>>> * 32-bits and align integer components for\\n>>>\\n>>> * better performance during lookups into\\n>>> the\\n>>>\\n>>> * multiarray */\\n>>>\\n>>> int num_dead_tuples; /* # of entries in the segment */\\n>>>\\n>>> int max_dead_tuples; /* # of entries allocated in the\\n>>> segment */\\n>>>\\n>>> ItemPointer dt_tids; /* Array of dead tuples */\\n>>>\\n>>> } DeadTuplesSegment;\\n>>>\\n>>> In the comments to ItemPointerData is written that it is 6 bytes long, but\\n>>> can be padded to 8 bytes by some compilers, so if we add padding in a\\n>>> current way, there is no guaranty that it will be done as it is expected.\\n>>> The other way to do it with pg_attribute_alligned. But in my opinion, there\\n>>> is no need to do it manually, because the compiler will do this optimization\\n>>> itself.\\n>>\\n>> I'll look into it. But my experience is that compilers won't align\\n>> struct size like this, only attributes, and this attribute is composed\\n>> of 16-bit attributes so it doesn't get aligned by default.\\n>\\n> Doing sizeof(DeadTuplesSegment) suggests you were indeed right, at\\n> least in GCC. I'll remove the padding.\\n>\\n> Seems I just got the wrong impression at some point.\\n\\nUpdated versions of the patches attached.\\n\\nA few runs of the benchmark show no significant difference, as it\\nshould (being all cosmetic changes).\\n\\nThe bigger benchmark will take longer.\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 13 Jul 2017 22:06:52 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Fwd: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> Indeed they do, and that's what motivated this patch. But I'd need\\n> TB-sized tables to set up something like that. I don't have the\\n> hardware or time available to do that (vacuum on bloated TB-sized\\n> tables can take days in my experience). Scale 4000 is as big as I can\\n> get without running out of space for the tests in my test hardware.\\n>\\n> If anybody else has the ability, I'd be thankful if they did test it\\n> under those conditions, but I cannot. I think Anastasia's test is\\n> closer to such a test, that's probably why it shows a bigger\\n> improvement in total elapsed time.\\n>\\n> Our production database could possibly be used, but it can take about\\n> a week to clone it, upgrade it (it's 9.5 currently), and run the\\n> relevant vacuum.\\n\\nIt looks like I won't be able to do that test with a production\\nsnapshot anytime soon.\\n\\nGetting approval for the budget required to do that looks like it's\\ngoing to take far longer than I thought.\\n\\nRegardless of that, I think the patch can move forward. I'm still\\nplanning to do the test at some point, but this patch shouldn't block\\non it.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 18 Aug 2017 08:39:15 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"> On 18 Aug 2017, at 13:39, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> \\n> On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> Indeed they do, and that's what motivated this patch. But I'd need\\n>> TB-sized tables to set up something like that. I don't have the\\n>> hardware or time available to do that (vacuum on bloated TB-sized\\n>> tables can take days in my experience). Scale 4000 is as big as I can\\n>> get without running out of space for the tests in my test hardware.\\n>> \\n>> If anybody else has the ability, I'd be thankful if they did test it\\n>> under those conditions, but I cannot. I think Anastasia's test is\\n>> closer to such a test, that's probably why it shows a bigger\\n>> improvement in total elapsed time.\\n>> \\n>> Our production database could possibly be used, but it can take about\\n>> a week to clone it, upgrade it (it's 9.5 currently), and run the\\n>> relevant vacuum.\\n> \\n> It looks like I won't be able to do that test with a production\\n> snapshot anytime soon.\\n> \\n> Getting approval for the budget required to do that looks like it's\\n> going to take far longer than I thought.\\n> \\n> Regardless of that, I think the patch can move forward. I'm still\\n> planning to do the test at some point, but this patch shouldn't block\\n> on it.\\n\\nThis patch has been marked Ready for committer after review, but wasn’t\\ncommitted in the current commitfest so it will be moved to the next. Since it\\nno longer applies cleanly, it’s being reset to Waiting for author though.\\n\\ncheers ./daniel\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 2 Oct 2017 01:36:17 +0200\",\n \"msg_from\": \"Daniel Gustafsson <daniel@yesql.se>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Sun, Oct 1, 2017 at 8:36 PM, Daniel Gustafsson <daniel@yesql.se> wrote:\\n>> On 18 Aug 2017, at 13:39, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>\\n>> On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> Indeed they do, and that's what motivated this patch. But I'd need\\n>>> TB-sized tables to set up something like that. I don't have the\\n>>> hardware or time available to do that (vacuum on bloated TB-sized\\n>>> tables can take days in my experience). Scale 4000 is as big as I can\\n>>> get without running out of space for the tests in my test hardware.\\n>>>\\n>>> If anybody else has the ability, I'd be thankful if they did test it\\n>>> under those conditions, but I cannot. I think Anastasia's test is\\n>>> closer to such a test, that's probably why it shows a bigger\\n>>> improvement in total elapsed time.\\n>>>\\n>>> Our production database could possibly be used, but it can take about\\n>>> a week to clone it, upgrade it (it's 9.5 currently), and run the\\n>>> relevant vacuum.\\n>>\\n>> It looks like I won't be able to do that test with a production\\n>> snapshot anytime soon.\\n>>\\n>> Getting approval for the budget required to do that looks like it's\\n>> going to take far longer than I thought.\\n>>\\n>> Regardless of that, I think the patch can move forward. I'm still\\n>> planning to do the test at some point, but this patch shouldn't block\\n>> on it.\\n>\\n> This patch has been marked Ready for committer after review, but wasn’t\\n> committed in the current commitfest so it will be moved to the next. Since it\\n> no longer applies cleanly, it’s being reset to Waiting for author though.\\n>\\n> cheers ./daniel\\n\\nRebased version of the patches attached\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 2 Oct 2017 11:02:52 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Oct 2, 2017 at 11:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> Rebased version of the patches attached\\n\\nThe status of the patch is misleading:\\nhttps://commitfest.postgresql.org/15/844/. This was marked as waiting\\non author but a new version has been published. Let's be careful.\\n\\nThe last patches I am aware of, aka those from\\nhttps://www.postgresql.org/message-id/CAGTBQpZHTf2JtShC=ijc9wzEipo3XOKWQhx+8WiP7ZjPC3FBEg@mail.gmail.com,\\ndo not apply. I am moving the patch to the next commit fest with a\\nwaiting on author status, as this should be reviewed, but those need a\\nrebase.\\n-- \\nMichael\\n\\n\",\n \"msg_date\": \"Wed, 29 Nov 2017 10:37:07 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Nov 28, 2017 at 10:37 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> On Mon, Oct 2, 2017 at 11:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> Rebased version of the patches attached\\n>\\n> The status of the patch is misleading:\\n> https://commitfest.postgresql.org/15/844/. This was marked as waiting\\n> on author but a new version has been published. Let's be careful.\\n>\\n> The last patches I am aware of, aka those from\\n> https://www.postgresql.org/message-id/CAGTBQpZHTf2JtShC=ijc9wzEipo3XOKWQhx+8WiP7ZjPC3FBEg@mail.gmail.com,\\n> do not apply. I am moving the patch to the next commit fest with a\\n> waiting on author status, as this should be reviewed, but those need a\\n> rebase.\\n\\nThey did apply at the time, but I think major work on vacuum was\\npushed since then, and also I was traveling so out of reach.\\n\\nIt may take some time to rebase them again. Should I move to needs\\nreview myself after that?\\n\\n\",\n \"msg_date\": \"Mon, 4 Dec 2017 02:38:21 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> They did apply at the time, but I think major work on vacuum was\\n> pushed since then, and also I was traveling so out of reach.\\n>\\n> It may take some time to rebase them again. Should I move to needs\\n> review myself after that?\\n\\nSure, if you can get into this state, please feel free to update the\\nstatus of the patch yourself.\\n-- \\nMichael\\n\\n\",\n \"msg_date\": \"Mon, 4 Dec 2017 14:58:59 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Greetings,\\n\\n* Michael Paquier (michael.paquier@gmail.com) wrote:\\n> On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> > They did apply at the time, but I think major work on vacuum was\\n> > pushed since then, and also I was traveling so out of reach.\\n> >\\n> > It may take some time to rebase them again. Should I move to needs\\n> > review myself after that?\\n> \\n> Sure, if you can get into this state, please feel free to update the\\n> status of the patch yourself.\\n\\nWe're now over a month since this status update- Claudio, for this to\\nhave a chance during this commitfest to be included (which, personally,\\nI think would be great as it solves a pretty serious issue..), we really\\nneed to have it be rebased and updated. Once that's done, as Michael\\nsays, please change the patch status back to 'Needs Review'.\\n\\nThanks!\\n\\nStephen\",\n \"msg_date\": \"Sat, 6 Jan 2018 17:35:59 -0500\",\n \"msg_from\": \"Stephen Frost <sfrost@snowman.net>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Sat, Jan 6, 2018 at 7:35 PM, Stephen Frost <sfrost@snowman.net> wrote:\\n\\n> Greetings,\\n>\\n> * Michael Paquier (michael.paquier@gmail.com) wrote:\\n> > On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com>\\n> wrote:\\n> > > They did apply at the time, but I think major work on vacuum was\\n> > > pushed since then, and also I was traveling so out of reach.\\n> > >\\n> > > It may take some time to rebase them again. Should I move to needs\\n> > > review myself after that?\\n> >\\n> > Sure, if you can get into this state, please feel free to update the\\n> > status of the patch yourself.\\n>\\n> We're now over a month since this status update- Claudio, for this to\\n> have a chance during this commitfest to be included (which, personally,\\n> I think would be great as it solves a pretty serious issue..), we really\\n> need to have it be rebased and updated. Once that's done, as Michael\\n> says, please change the patch status back to 'Needs Review'.\\n>\\n\\nSorry, had tons of other stuff that took priority.\\n\\nI'll get to rebase this patch now.\\n\\nOn Sat, Jan 6, 2018 at 7:35 PM, Stephen Frost <sfrost@snowman.net> wrote:Greetings,\\n\\n* Michael Paquier (michael.paquier@gmail.com) wrote:\\n> On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> > They did apply at the time, but I think major work on vacuum was\\n> > pushed since then, and also I was traveling so out of reach.\\n> >\\n> > It may take some time to rebase them again. Should I move to needs\\n> > review myself after that?\\n>\\n> Sure, if you can get into this state, please feel free to update the\\n> status of the patch yourself.\\n\\nWe're now over a month since this status update- Claudio, for this to\\nhave a chance during this commitfest to be included (which, personally,\\nI think would be great as it solves a pretty serious issue..), we really\\nneed to have it be rebased and updated. Once that's done, as Michael\\nsays, please change the patch status back to 'Needs Review'.Sorry, had tons of other stuff that took priority.I'll get to rebase this patch now.\",\n \"msg_date\": \"Wed, 17 Jan 2018 17:02:37 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Jan 17, 2018 at 5:02 PM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n>\\n>\\n> On Sat, Jan 6, 2018 at 7:35 PM, Stephen Frost <sfrost@snowman.net> wrote:\\n>\\n>> Greetings,\\n>>\\n>> * Michael Paquier (michael.paquier@gmail.com) wrote:\\n>> > On Mon, Dec 4, 2017 at 2:38 PM, Claudio Freire <klaussfreire@gmail.com>\\n>> wrote:\\n>> > > They did apply at the time, but I think major work on vacuum was\\n>> > > pushed since then, and also I was traveling so out of reach.\\n>> > >\\n>> > > It may take some time to rebase them again. Should I move to needs\\n>> > > review myself after that?\\n>> >\\n>> > Sure, if you can get into this state, please feel free to update the\\n>> > status of the patch yourself.\\n>>\\n>> We're now over a month since this status update- Claudio, for this to\\n>> have a chance during this commitfest to be included (which, personally,\\n>> I think would be great as it solves a pretty serious issue..), we really\\n>> need to have it be rebased and updated. Once that's done, as Michael\\n>> says, please change the patch status back to 'Needs Review'.\\n>>\\n>\\n> Sorry, had tons of other stuff that took priority.\\n>\\n> I'll get to rebase this patch now.\\n>\\n>\\n>\\nHuh. That was simpler than I thought.\\n\\nAttached rebased versions.\",\n \"msg_date\": \"Wed, 17 Jan 2018 17:17:29 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"The following review has been posted through the commitfest application:\\nmake installcheck-world: tested, passed\\nImplements feature: tested, passed\\nSpec compliant: tested, passed\\nDocumentation: tested, passed\\n\\nI can confirm that these patches don't break anything; the code is well\\r\\ndocumented, has some tests and doesn't do anything obviously wrong. However\\r\\nI would recommend someone who is more familiar with the VACUUM mechanism than I\\r\\ndo to recheck these patches.\\n\\nThe new status of this patch is: Ready for Committer\\n\",\n \"msg_date\": \"Mon, 22 Jan 2018 15:18:51 +0000\",\n \"msg_from\": \"Aleksander Alekseev <a.alekseev@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jan 18, 2018 at 9:17 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> Huh. That was simpler than I thought.\\n>\\n> Attached rebased versions.\\n\\nHi Claudio,\\n\\nFYI the regression test seems to have some run-to-run variation.\\nThough it usually succeeds, recently I have seen a couple of failures\\nlike this:\\n\\n========= Contents of ./src/test/regress/regression.diffs\\n*** /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/expected/vacuum.out\\n2018-01-24 01:41:28.200454371 +0000\\n--- /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/results/vacuum.out\\n2018-01-24 01:51:07.970049937 +0000\\n***************\\n*** 128,134 ****\\n SELECT pg_relation_size('vactst', 'main');\\n pg_relation_size\\n ------------------\\n! 0\\n (1 row)\\n\\n SELECT count(*) FROM vactst;\\n--- 128,134 ----\\n SELECT pg_relation_size('vactst', 'main');\\n pg_relation_size\\n ------------------\\n! 8192\\n (1 row)\\n\\n SELECT count(*) FROM vactst;\\n======================================================================\\n\\n-- \\nThomas Munro\\nhttp://www.enterprisedb.com\\n\\n\",\n \"msg_date\": \"Thu, 25 Jan 2018 20:11:22 +1300\",\n \"msg_from\": \"Thomas Munro <thomas.munro@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jan 25, 2018 at 4:11 AM, Thomas Munro\\n<thomas.munro@enterprisedb.com> wrote:\\n> On Thu, Jan 18, 2018 at 9:17 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> Huh. That was simpler than I thought.\\n>>\\n>> Attached rebased versions.\\n>\\n> Hi Claudio,\\n>\\n> FYI the regression test seems to have some run-to-run variation.\\n> Though it usually succeeds, recently I have seen a couple of failures\\n> like this:\\n>\\n> ========= Contents of ./src/test/regress/regression.diffs\\n> *** /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/expected/vacuum.out\\n> 2018-01-24 01:41:28.200454371 +0000\\n> --- /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/results/vacuum.out\\n> 2018-01-24 01:51:07.970049937 +0000\\n> ***************\\n> *** 128,134 ****\\n> SELECT pg_relation_size('vactst', 'main');\\n> pg_relation_size\\n> ------------------\\n> ! 0\\n> (1 row)\\n>\\n> SELECT count(*) FROM vactst;\\n> --- 128,134 ----\\n> SELECT pg_relation_size('vactst', 'main');\\n> pg_relation_size\\n> ------------------\\n> ! 8192\\n> (1 row)\\n>\\n> SELECT count(*) FROM vactst;\\n> ======================================================================\\n>\\n> --\\n> Thomas Munro\\n> http://www.enterprisedb.com\\n\\nI'll look into it\\n\\nHowever, shouldn't an empty relation have an initial page anyway? In\\nthat case shouldn't the correct value be 8192?\\n\\n\",\n \"msg_date\": \"Thu, 25 Jan 2018 10:56:08 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Claudio Freire wrote:\\n> On Thu, Jan 25, 2018 at 4:11 AM, Thomas Munro\\n> <thomas.munro@enterprisedb.com> wrote:\\n\\n> > *** 128,134 ****\\n> > SELECT pg_relation_size('vactst', 'main');\\n> > pg_relation_size\\n> > ------------------\\n> > ! 0\\n> > (1 row)\\n> >\\n> > SELECT count(*) FROM vactst;\\n> > --- 128,134 ----\\n> > SELECT pg_relation_size('vactst', 'main');\\n> > pg_relation_size\\n> > ------------------\\n> > ! 8192\\n> > (1 row)\\n\\n> However, shouldn't an empty relation have an initial page anyway? In\\n> that case shouldn't the correct value be 8192?\\n\\nNo, it's legal for an empty table to have size 0 on disk.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Thu, 25 Jan 2018 11:41:38 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jan 25, 2018 at 10:56 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Thu, Jan 25, 2018 at 4:11 AM, Thomas Munro\\n> <thomas.munro@enterprisedb.com> wrote:\\n>> On Thu, Jan 18, 2018 at 9:17 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>> Huh. That was simpler than I thought.\\n>>>\\n>>> Attached rebased versions.\\n>>\\n>> Hi Claudio,\\n>>\\n>> FYI the regression test seems to have some run-to-run variation.\\n>> Though it usually succeeds, recently I have seen a couple of failures\\n>> like this:\\n>>\\n>> ========= Contents of ./src/test/regress/regression.diffs\\n>> *** /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/expected/vacuum.out\\n>> 2018-01-24 01:41:28.200454371 +0000\\n>> --- /home/travis/build/postgresql-cfbot/postgresql/src/test/regress/results/vacuum.out\\n>> 2018-01-24 01:51:07.970049937 +0000\\n>> ***************\\n>> *** 128,134 ****\\n>> SELECT pg_relation_size('vactst', 'main');\\n>> pg_relation_size\\n>> ------------------\\n>> ! 0\\n>> (1 row)\\n>>\\n>> SELECT count(*) FROM vactst;\\n>> --- 128,134 ----\\n>> SELECT pg_relation_size('vactst', 'main');\\n>> pg_relation_size\\n>> ------------------\\n>> ! 8192\\n>> (1 row)\\n>>\\n>> SELECT count(*) FROM vactst;\\n>> ======================================================================\\n>>\\n>> --\\n>> Thomas Munro\\n>> http://www.enterprisedb.com\\n>\\n> I'll look into it\\n\\nI had the tests running in a loop all day long, and I cannot reproduce\\nthat variance.\\n\\nCan you share your steps to reproduce it, including configure flags?\\n\\n\",\n \"msg_date\": \"Thu, 25 Jan 2018 17:38:13 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Jan 26, 2018 at 9:38 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> I had the tests running in a loop all day long, and I cannot reproduce\\n> that variance.\\n>\\n> Can you share your steps to reproduce it, including configure flags?\\n\\nHere are two build logs where it failed:\\n\\nhttps://travis-ci.org/postgresql-cfbot/postgresql/builds/332968819\\nhttps://travis-ci.org/postgresql-cfbot/postgresql/builds/332592511\\n\\nHere's one where it succeeded:\\n\\nhttps://travis-ci.org/postgresql-cfbot/postgresql/builds/333139855\\n\\nThe full build script used is:\\n\\n./configure --enable-debug --enable-cassert --enable-coverage\\n--enable-tap-tests --with-tcl --with-python --with-perl --with-ldap\\n--with-icu && make -j4 all contrib docs && make -Otarget -j3\\ncheck-world\\n\\nThis is a virtualised 4 core system. I wonder if \\\"make -Otarget -j3\\ncheck-world\\\" creates enough load on it to produce some weird timing\\neffect that you don't see on your development system.\\n\\n-- \\nThomas Munro\\nhttp://www.enterprisedb.com\\n\\n\",\n \"msg_date\": \"Fri, 26 Jan 2018 10:21:14 +1300\",\n \"msg_from\": \"Thomas Munro <thomas.munro@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jan 25, 2018 at 6:21 PM, Thomas Munro\\n<thomas.munro@enterprisedb.com> wrote:\\n> On Fri, Jan 26, 2018 at 9:38 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> I had the tests running in a loop all day long, and I cannot reproduce\\n>> that variance.\\n>>\\n>> Can you share your steps to reproduce it, including configure flags?\\n>\\n> Here are two build logs where it failed:\\n>\\n> https://travis-ci.org/postgresql-cfbot/postgresql/builds/332968819\\n> https://travis-ci.org/postgresql-cfbot/postgresql/builds/332592511\\n>\\n> Here's one where it succeeded:\\n>\\n> https://travis-ci.org/postgresql-cfbot/postgresql/builds/333139855\\n>\\n> The full build script used is:\\n>\\n> ./configure --enable-debug --enable-cassert --enable-coverage\\n> --enable-tap-tests --with-tcl --with-python --with-perl --with-ldap\\n> --with-icu && make -j4 all contrib docs && make -Otarget -j3\\n> check-world\\n>\\n> This is a virtualised 4 core system. I wonder if \\\"make -Otarget -j3\\n> check-world\\\" creates enough load on it to produce some weird timing\\n> effect that you don't see on your development system.\\n\\nI can't reproduce it, not even with the same build script.\\n\\nIt's starting to look like a timing effect indeed.\\n\\nI get a similar effect if there's an active snapshot in another\\nsession while vacuum runs. I don't know how the test suite ends up in\\nthat situation, but it seems to be the case.\\n\\nHow do you suggest we go about fixing this? The test in question is\\nimportant, I've caught actual bugs in the implementation with it,\\nbecause it checks that vacuum effectively frees up space.\\n\\nI'm thinking this vacuum test could be put on its own parallel group\\nperhaps? Since I can't reproduce it, I can't know whether that will\\nfix it, but it seems sensible.\\n\\n\",\n \"msg_date\": \"Fri, 2 Feb 2018 19:52:02 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Fri, 2 Feb 2018 19:52:02 -0300, Claudio Freire <klaussfreire@gmail.com> wrote in <CAGTBQpaiNQSNJC8y4w82UBTaPsvSqRRg++yEi5wre1MFE2iD8Q@mail.gmail.com>\\n> On Thu, Jan 25, 2018 at 6:21 PM, Thomas Munro\\n> <thomas.munro@enterprisedb.com> wrote:\\n> > On Fri, Jan 26, 2018 at 9:38 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> >> I had the tests running in a loop all day long, and I cannot reproduce\\n> >> that variance.\\n> >>\\n> >> Can you share your steps to reproduce it, including configure flags?\\n> >\\n> > Here are two build logs where it failed:\\n> >\\n> > https://travis-ci.org/postgresql-cfbot/postgresql/builds/332968819\\n> > https://travis-ci.org/postgresql-cfbot/postgresql/builds/332592511\\n> >\\n> > Here's one where it succeeded:\\n> >\\n> > https://travis-ci.org/postgresql-cfbot/postgresql/builds/333139855\\n> >\\n> > The full build script used is:\\n> >\\n> > ./configure --enable-debug --enable-cassert --enable-coverage\\n> > --enable-tap-tests --with-tcl --with-python --with-perl --with-ldap\\n> > --with-icu && make -j4 all contrib docs && make -Otarget -j3\\n> > check-world\\n> >\\n> > This is a virtualised 4 core system. I wonder if \\\"make -Otarget -j3\\n> > check-world\\\" creates enough load on it to produce some weird timing\\n> > effect that you don't see on your development system.\\n> \\n> I can't reproduce it, not even with the same build script.\\n\\nI had the same error by \\\"make -j3 check-world\\\" but only twice\\nfrom many trials.\\n\\n> It's starting to look like a timing effect indeed.\\n\\nIt seems to be truncation skip, maybe caused by concurrent\\nautovacuum. See lazy_truncate_heap() for details. Updates of\\npg_stat_*_tables can be delayed so looking it also can fail. Even\\nthough I haven't looked the patch closer, the \\\"SELECT\\npg_relation_size()\\\" doesn't seem to give something meaningful\\nanyway.\\n\\n> I get a similar effect if there's an active snapshot in another\\n> session while vacuum runs. I don't know how the test suite ends up in\\n> that situation, but it seems to be the case.\\n> \\n> How do you suggest we go about fixing this? The test in question is\\n> important, I've caught actual bugs in the implementation with it,\\n> because it checks that vacuum effectively frees up space.\\n> \\n> I'm thinking this vacuum test could be put on its own parallel group\\n> perhaps? Since I can't reproduce it, I can't know whether that will\\n> fix it, but it seems sensible.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\",\n \"msg_date\": \"Tue, 06 Feb 2018 16:35:42 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>> It's starting to look like a timing effect indeed.\\n>\\n> It seems to be truncation skip, maybe caused by concurrent\\n> autovacuum.\\n\\nGood point, I'll also disable autovacuum on vactst.\\n\\n> See lazy_truncate_heap() for details. Updates of\\n> pg_stat_*_tables can be delayed so looking it also can fail. Even\\n> though I haven't looked the patch closer, the \\\"SELECT\\n> pg_relation_size()\\\" doesn't seem to give something meaningful\\n> anyway.\\n\\nMaybe then \\\"explain (analyze, buffers, costs off, timing off, summary\\noff) select * from vactst\\\" then.\\n\\nThe point is to check that the relation's heap has 0 pages.\\n\\n\",\n \"msg_date\": \"Tue, 6 Feb 2018 10:18:05 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Feb 6, 2018 at 10:18 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>>> It's starting to look like a timing effect indeed.\\n>>\\n>> It seems to be truncation skip, maybe caused by concurrent\\n>> autovacuum.\\n>\\n> Good point, I'll also disable autovacuum on vactst.\\n>\\n>> See lazy_truncate_heap() for details. Updates of\\n>> pg_stat_*_tables can be delayed so looking it also can fail. Even\\n>> though I haven't looked the patch closer, the \\\"SELECT\\n>> pg_relation_size()\\\" doesn't seem to give something meaningful\\n>> anyway.\\n>\\n> Maybe then \\\"explain (analyze, buffers, costs off, timing off, summary\\n> off) select * from vactst\\\" then.\\n>\\n> The point is to check that the relation's heap has 0 pages.\\n\\nAttached rebased patches with those changes mentioned above, namely:\\n\\n- vacuum test now creates vactst with autovacuum disabled for it\\n- vacuum test on its own parallel group\\n- use explain analyze instead of pg_relation_size to check the\\nrelation is properly truncated\",\n \"msg_date\": \"Tue, 6 Feb 2018 10:41:22 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Tue, 6 Feb 2018 10:41:22 -0300, Claudio Freire <klaussfreire@gmail.com> wrote in <CAGTBQpaufC0o8OikWd8=5biXcbYjT51mPLfmy22NUjX6kUED0A@mail.gmail.com>\\n> On Tue, Feb 6, 2018 at 10:18 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> > On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\\n> > <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> >>> It's starting to look like a timing effect indeed.\\n> >>\\n> >> It seems to be truncation skip, maybe caused by concurrent\\n> >> autovacuum.\\n> >\\n> > Good point, I'll also disable autovacuum on vactst.\\n> >\\n> >> See lazy_truncate_heap() for details. Updates of\\n> >> pg_stat_*_tables can be delayed so looking it also can fail. Even\\n> >> though I haven't looked the patch closer, the \\\"SELECT\\n> >> pg_relation_size()\\\" doesn't seem to give something meaningful\\n> >> anyway.\\n> >\\n> > Maybe then \\\"explain (analyze, buffers, costs off, timing off, summary\\n> > off) select * from vactst\\\" then.\\n\\nAh, sorry. I meant by the above that it gives unstable result\\nwith autovacuum. So pg_relation_size() is usable after you turned\\nof autovacuum on the table.\\n\\n> > The point is to check that the relation's heap has 0 pages.\\n> \\n> Attached rebased patches with those changes mentioned above, namely:\\n> \\n> - vacuum test now creates vactst with autovacuum disabled for it\\n> - vacuum test on its own parallel group\\n> - use explain analyze instead of pg_relation_size to check the\\n> relation is properly truncated\\n\\nThe problematic test was in the 0001..v14 patch. The new\\n0001..v15 is identical to v14 and instead 0003-v8 has additional\\npart that edits the test and expects added by 0001 into the shape\\nas above. It seems that you merged the fixup onto the wrong\\ncommit.\\n\\nAnd may we assume it correct that 0002 is missing in this\\npatchset?\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\",\n \"msg_date\": \"Wed, 07 Feb 2018 12:50:11 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 7, 2018 at 12:50 AM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> Hello,\\n>\\n> At Tue, 6 Feb 2018 10:41:22 -0300, Claudio Freire <klaussfreire@gmail.com> wrote in <CAGTBQpaufC0o8OikWd8=5biXcbYjT51mPLfmy22NUjX6kUED0A@mail.gmail.com>\\n>> On Tue, Feb 6, 2018 at 10:18 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> > On Tue, Feb 6, 2018 at 4:35 AM, Kyotaro HORIGUCHI\\n>> > <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>> >>> It's starting to look like a timing effect indeed.\\n>> >>\\n>> >> It seems to be truncation skip, maybe caused by concurrent\\n>> >> autovacuum.\\n>> >\\n>> > Good point, I'll also disable autovacuum on vactst.\\n>> >\\n>> >> See lazy_truncate_heap() for details. Updates of\\n>> >> pg_stat_*_tables can be delayed so looking it also can fail. Even\\n>> >> though I haven't looked the patch closer, the \\\"SELECT\\n>> >> pg_relation_size()\\\" doesn't seem to give something meaningful\\n>> >> anyway.\\n>> >\\n>> > Maybe then \\\"explain (analyze, buffers, costs off, timing off, summary\\n>> > off) select * from vactst\\\" then.\\n>\\n> Ah, sorry. I meant by the above that it gives unstable result\\n> with autovacuum. So pg_relation_size() is usable after you turned\\n> of autovacuum on the table.\\n\\nYou did mention stats could be delayed\\n\\n>> > The point is to check that the relation's heap has 0 pages.\\n>>\\n>> Attached rebased patches with those changes mentioned above, namely:\\n>>\\n>> - vacuum test now creates vactst with autovacuum disabled for it\\n>> - vacuum test on its own parallel group\\n>> - use explain analyze instead of pg_relation_size to check the\\n>> relation is properly truncated\\n>\\n> The problematic test was in the 0001..v14 patch. The new\\n> 0001..v15 is identical to v14 and instead 0003-v8 has additional\\n> part that edits the test and expects added by 0001 into the shape\\n> as above. It seems that you merged the fixup onto the wrong\\n> commit.\\n>\\n> And may we assume it correct that 0002 is missing in this\\n> patchset?\\n\\nSounds like I botched the rebase. Sorry about that.\\n\\nAttached are corrected versions (1-v16 and 3-v9)\",\n \"msg_date\": \"Wed, 7 Feb 2018 11:36:54 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Claudio Freire wrote:\\n\\n> - vacuum test on its own parallel group\\n\\nHmm, this solution is not very friendly to the goal of reducing test\\nruntime, particularly since the new test creates a nontrivial-sized\\ntable. Maybe we can find a better alternative. Can we use some wait\\nlogic instead? Maybe something like grab a snapshot of running VXIDs\\nand loop waiting until they're all gone before doing the vacuum?\\n\\nAlso, I don't understand why pg_relation_size() is not a better solution\\nto determining the table size compared to explain.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Wed, 7 Feb 2018 19:57:30 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 7, 2018 at 7:57 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n> Claudio Freire wrote:\\n>\\n>> - vacuum test on its own parallel group\\n>\\n> Hmm, this solution is not very friendly to the goal of reducing test\\n> runtime, particularly since the new test creates a nontrivial-sized\\n> table. Maybe we can find a better alternative. Can we use some wait\\n> logic instead? Maybe something like grab a snapshot of running VXIDs\\n> and loop waiting until they're all gone before doing the vacuum?\\n\\nI'm not sure there's any alternative. I did some tests and any active\\nsnapshot on any other table, not necessarily on the one being\\nvacuumed, distorted the test. And it makes sense, since that snapshot\\nmakes those deleted tuples unvacuumable.\\n\\nWaiting as you say would be akin to what the patch does by putting\\nvacuum on its own parallel group.\\n\\nI'm guessing all tests write something to the database, so all tests\\nwill create a snapshot. Maybe if there were read-only tests, those\\nmight be safe to include in vacuum's parallel group, but otherwise I\\ndon't see any alternative.\\n\\n> Also, I don't understand why pg_relation_size() is not a better solution\\n> to determining the table size compared to explain.\\n\\nI was told pg_relation_size can return stale information. I didn't\\ncheck, I took that at face value.\\n\\n\",\n \"msg_date\": \"Wed, 7 Feb 2018 20:45:50 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Claudio Freire wrote:\\n> On Wed, Feb 7, 2018 at 7:57 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n> > Claudio Freire wrote:\\n\\n> > Hmm, this solution is not very friendly to the goal of reducing test\\n> > runtime, particularly since the new test creates a nontrivial-sized\\n> > table. Maybe we can find a better alternative. Can we use some wait\\n> > logic instead? Maybe something like grab a snapshot of running VXIDs\\n> > and loop waiting until they're all gone before doing the vacuum?\\n> \\n> I'm not sure there's any alternative. I did some tests and any active\\n> snapshot on any other table, not necessarily on the one being\\n> vacuumed, distorted the test. And it makes sense, since that snapshot\\n> makes those deleted tuples unvacuumable.\\n\\nSure.\\n\\n> Waiting as you say would be akin to what the patch does by putting\\n> vacuum on its own parallel group.\\n\\nI don't think it's the same. We don't need to wait until all the\\nconcurrent tests are done -- we only need to wait until the transactions\\nthat were current when the delete finished are done, which is very\\ndifferent since each test runs tons of small transactions rather than\\none single big transaction.\\n\\n> > Also, I don't understand why pg_relation_size() is not a better solution\\n> > to determining the table size compared to explain.\\n> \\n> I was told pg_relation_size can return stale information. I didn't\\n> check, I took that at face value.\\n\\nHmm, it uses stat() on the table files. I think those files would be\\ntruncated at the time the transaction commits, so they shouldn't be\\nstale. (I don't think the system waits for a checkpoint to flush a\\ntruncation.) Maybe relying on that is not reliable or future-proof\\nenough. Anyway this is a minor point -- the one above worries me most.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Wed, 7 Feb 2018 20:52:26 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n>> Waiting as you say would be akin to what the patch does by putting\\n>> vacuum on its own parallel group.\\n>\\n> I don't think it's the same. We don't need to wait until all the\\n> concurrent tests are done -- we only need to wait until the transactions\\n> that were current when the delete finished are done, which is very\\n> different since each test runs tons of small transactions rather than\\n> one single big transaction.\\n\\nUm... maybe \\\"lock pg_class\\\" ?\\n\\nThat should conflict with basically any other running transaction and\\nhave pretty much that effect.\\n\\nAttached is a version of patch 1 with that approach.\",\n \"msg_date\": \"Wed, 7 Feb 2018 21:21:29 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Claudio Freire wrote:\\n> On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n> >> Waiting as you say would be akin to what the patch does by putting\\n> >> vacuum on its own parallel group.\\n> >\\n> > I don't think it's the same. We don't need to wait until all the\\n> > concurrent tests are done -- we only need to wait until the transactions\\n> > that were current when the delete finished are done, which is very\\n> > different since each test runs tons of small transactions rather than\\n> > one single big transaction.\\n> \\n> Um... maybe \\\"lock pg_class\\\" ?\\n\\nI was thinking in first doing \\n SELECT array_agg(DISTINCT virtualtransaction) vxids\\n FROM pg_locks \\\\gset\\n\\nand then in a DO block loop until\\n\\n SELECT DISTINCT virtualtransaction\\n FROM pg_locks\\nINTERSECT\\n SELECT (unnest(:'vxids'::text[]));\\n\\nreturns empty; something along those lines.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Wed, 7 Feb 2018 23:29:34 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 7, 2018 at 11:29 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n> Claudio Freire wrote:\\n>> On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n>> >> Waiting as you say would be akin to what the patch does by putting\\n>> >> vacuum on its own parallel group.\\n>> >\\n>> > I don't think it's the same. We don't need to wait until all the\\n>> > concurrent tests are done -- we only need to wait until the transactions\\n>> > that were current when the delete finished are done, which is very\\n>> > different since each test runs tons of small transactions rather than\\n>> > one single big transaction.\\n>>\\n>> Um... maybe \\\"lock pg_class\\\" ?\\n>\\n> I was thinking in first doing\\n> SELECT array_agg(DISTINCT virtualtransaction) vxids\\n> FROM pg_locks \\\\gset\\n>\\n> and then in a DO block loop until\\n>\\n> SELECT DISTINCT virtualtransaction\\n> FROM pg_locks\\n> INTERSECT\\n> SELECT (unnest(:'vxids'::text[]));\\n>\\n> returns empty; something along those lines.\\n\\nIsn't it the same though?\\n\\nI can't think how a transaction wouldn't be holding at least an access\\nshare on pg_class.\\n\\n\",\n \"msg_date\": \"Thu, 8 Feb 2018 00:13:09 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Feb 8, 2018 at 12:13 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Wed, Feb 7, 2018 at 11:29 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n>> Claudio Freire wrote:\\n>>> On Wed, Feb 7, 2018 at 8:52 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n>>> >> Waiting as you say would be akin to what the patch does by putting\\n>>> >> vacuum on its own parallel group.\\n>>> >\\n>>> > I don't think it's the same. We don't need to wait until all the\\n>>> > concurrent tests are done -- we only need to wait until the transactions\\n>>> > that were current when the delete finished are done, which is very\\n>>> > different since each test runs tons of small transactions rather than\\n>>> > one single big transaction.\\n>>>\\n>>> Um... maybe \\\"lock pg_class\\\" ?\\n>>\\n>> I was thinking in first doing\\n>> SELECT array_agg(DISTINCT virtualtransaction) vxids\\n>> FROM pg_locks \\\\gset\\n>>\\n>> and then in a DO block loop until\\n>>\\n>> SELECT DISTINCT virtualtransaction\\n>> FROM pg_locks\\n>> INTERSECT\\n>> SELECT (unnest(:'vxids'::text[]));\\n>>\\n>> returns empty; something along those lines.\\n>\\n> Isn't it the same though?\\n>\\n> I can't think how a transaction wouldn't be holding at least an access\\n> share on pg_class.\\n\\nNever mind, I just saw the error of my ways.\\n\\nI don't like looping, though, seems overly cumbersome. What's worse?\\nmaintaining that fragile weird loop that might break (by causing\\nunexpected output), or a slight slowdown of the test suite? I don't\\nknow how long it might take on slow machines, but in my machine, which\\nisn't a great machine, while the vacuum test isn't fast indeed, it's\\njust a tiny fraction of what a simple \\\"make check\\\" takes. So it's not\\na huge slowdown in any case.\\n\\nI'll give it some thought, maybe there's a simpler way.\\n\\n\",\n \"msg_date\": \"Thu, 8 Feb 2018 00:34:42 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Hello, I looked this a bit closer.\\n\\nIn upthread[1] Robert mentioned the exponentially increasing size\\nof additional segments.\\n\\n>> Hmm, I had imagined making all of the segments the same size rather\\n>> than having the size grow exponentially. The whole point of this is\\n>> to save memory, and even in the worst case you don't end up with that\\n>> many segments as long as you pick a reasonable base size (e.g. 64MB).\\n>\\n> Wastage is bound by a fraction of the total required RAM, that is,\\n> it's proportional to the amount of required RAM, not the amount\\n> allocated. So it should still be fine, and the exponential strategy\\n> should improve lookup performance considerably.\\n\\nIt seems that you are getting him wrong. (Anyway I'm not sure\\nwhat you meant by the above. not-yet-allocated memory won't be a\\nwaste.) The conclusive number of dead tuples in a heap scan is\\nundeteminable until the scan ends. If we had a new dead tuple\\nrequired a, say 512MB new segment and the scan ends just after,\\nthe wastage will be almost the whole of the segment.\\n\\nOn the other hand, I don't think the exponential strategy make\\nthings considerably better. bsearch iterations in\\nlazy_tid_reaped() are distributed between segment search and tid\\nsearch. Intuitively more or less the increased segment size just\\nmoves some iterations of the former to the latter.\\n\\nI made a calculation[2]. With maintemance_work_mem of 4096MB, the\\nnumber of segments is 6 and expected number of bsearch iteration\\nis about 20.8 for the exponential strategy. With 64MB fixed size\\nsegments, we will have 64 segments (that is not so many) and the\\nexpected iteration is 20.4. (I suppose the increase comes from\\nthe imbalanced size among segments.) Addition to that, as Robert\\nmentioned, the possible maximum memory wastage of the exponential\\nstrategy is about 2GB and 64MB in fixed size strategy.\\n\\nSeeing these numbers, I don't tend to take the exponential\\nstrategy.\\n\\n\\n[1] https://www.postgresql.org/message-id/CAGTBQpbZX5S4QrnB6YP-2Nk+A9bxbaVktzKwsGvMeov3MTgdiQ@mail.gmail.com\\n\\n[2] See attached perl script. I hope it is correct.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n#! /usr/bin/perl\\n\\n$maxmem=1024 * 4;\\n#=====\\nprint \\\"exponential sized strategy\\\\n\\\";\\n$ss = 64;\\n$ts = 0;\\n$sumiteritem = 0;\\nfor ($i = 1 ; $ts < $maxmem ; $i++) {\\n\\t$ss = $ss * 2;\\n\\tif ($ts + $ss > $maxmem) {\\n\\t\\t$ss = $maxmem - $ts;\\n\\t}\\n\\t$ts += $ss;\\n\\t$ntups = $ts*1024*1024 / 6;\\n\\t$ntupinseg = $ss*1024*1024 / 6;\\n\\t$npages = $ntups / 291;\\n\\t$tsize = $npages * 8192.0 / 1024 / 1024 / 1024;\\n\\t$sumiteritem += log($ntupinseg) * $ntupinseg; # weight by percentage in all tuples\\n\\tprintf(\\\"#%d : segsize=%dMB total=%dMB, (tuples = %ld, min tsize=%.1fGB), iterseg(%d)=%f, iteritem(%d) = %f, expected iter=%f\\\\n\\\",\\n\\t\\t $i, $ss, $ts, $ntups, $tsize,\\n\\t\\t $i, log($i), $ntupinseg, log($ntupinseg), log($i) + $sumiteritem/$ntups);\\n}\\n\\nprint \\\"\\\\n\\\\nfixed sized strategy\\\\n\\\";\\n$ss = 64;\\n$ts = 0;\\nfor ($i = 1 ; $ts < $maxmem ; $i++) {\\n\\t$ts += $ss;\\n\\t$ntups = $ts*1024*1024 / 6;\\n\\t$ntupinseg = $ss*1024*1024 / 6;\\n\\t$npages = $ntups / 300;\\n\\t$tsize = $npages * 8192.0 / 1024 / 1024 / 1024;\\n\\tprintf(\\\"#%d : segsize=%dMB total=%dMB, (tuples = %ld, min tsize=%.1fGB), interseg(%d)=%f, iteritem(%d) = %f, expected iter=%f\\\\n\\\",\\n\\t\\t $i, $ss, $ts, $ntups, $tsize,\\n\\t\\t$i, log($i), $ntupinseg, log($ntupinseg), log($i) + log($ntupinseg));\\n}\",\n \"msg_date\": \"Thu, 08 Feb 2018 14:44:35 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Feb 8, 2018 at 2:44 AM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> Hello, I looked this a bit closer.\\n>\\n> In upthread[1] Robert mentioned the exponentially increasing size\\n> of additional segments.\\n>\\n>>> Hmm, I had imagined making all of the segments the same size rather\\n>>> than having the size grow exponentially. The whole point of this is\\n>>> to save memory, and even in the worst case you don't end up with that\\n>>> many segments as long as you pick a reasonable base size (e.g. 64MB).\\n>>\\n>> Wastage is bound by a fraction of the total required RAM, that is,\\n>> it's proportional to the amount of required RAM, not the amount\\n>> allocated. So it should still be fine, and the exponential strategy\\n>> should improve lookup performance considerably.\\n>\\n> It seems that you are getting him wrong. (Anyway I'm not sure\\n> what you meant by the above. not-yet-allocated memory won't be a\\n> waste.) The conclusive number of dead tuples in a heap scan is\\n> undeteminable until the scan ends. If we had a new dead tuple\\n> required a, say 512MB new segment and the scan ends just after,\\n> the wastage will be almost the whole of the segment.\\n\\nAnd the segment size is bound by a fraction of total needed memory.\\n\\nWhen I said \\\"allocated\\\", I meant m_w_m. Wastage is not proportional to m_w_m.\\n\\n> On the other hand, I don't think the exponential strategy make\\n> things considerably better. bsearch iterations in\\n> lazy_tid_reaped() are distributed between segment search and tid\\n> search. Intuitively more or less the increased segment size just\\n> moves some iterations of the former to the latter.\\n>\\n> I made a calculation[2]. With maintemance_work_mem of 4096MB, the\\n> number of segments is 6 and expected number of bsearch iteration\\n> is about 20.8 for the exponential strategy. With 64MB fixed size\\n> segments, we will have 64 segments (that is not so many) and the\\n> expected iteration is 20.4. (I suppose the increase comes from\\n> the imbalanced size among segments.) Addition to that, as Robert\\n> mentioned, the possible maximum memory wastage of the exponential\\n> strategy is about 2GB and 64MB in fixed size strategy.\\n\\nThat calculation has a slight bug in that it should be log2, and that\\nsegment size is limited to 1GB at the top end.\\n\\nBut in any case, the biggest issue is that it's ignoring the effect of\\ncache locality. The way in which the exponential strategy helps, is by\\nkeeping the segment list small and comfortably fitting in fast cache\\nmemory, while also keeping wastage at a minimum for small lists. 64MB\\nsegments with 4G mwm would be about 2kb of segment list. It fits in\\nL1, if there's nothing else contending for it, but it's already\\nstarting to get big, and it would be expected settings larger than 4G\\nmwm could be used.\\n\\nI guess I could tune the starting/ending sizes a bit.\\n\\nSay, with an upper limit of 256M (instead of 1G), and after fixing the\\nother issues, we get:\\n\\nexponential sized strategy\\n...\\n#18 : segsize=64MB total=4096MB, (tuples = 715827882, min\\ntsize=18.8GB), iterseg(18)=4.169925, iteritem(11184810) = 23.415037,\\nexpected iter=29.491213\\n\\n\\nfixed sized strategy\\n...\\n#64 : segsize=64MB total=4096MB, (tuples = 715827882, min\\ntsize=18.2GB), interseg(64)=6.000000, iteritem(11184810) = 23.415037,\\nexpected iter=29.415037\\n\\nAlmost identical, and we get all the benefits of cache locality with\\nthe exponential strategy. The fixed strategy might fit in the L1, but\\nit's less likely the bigger the mwm is.\\n\\nThe scaling factor could also be tuned I guess, but I'm wary of using\\nanything other than a doubling strategy, since it might cause memory\\nfragmentation.\\n\\n\",\n \"msg_date\": \"Thu, 8 Feb 2018 04:08:20 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Claudio Freire wrote:\\n\\n> I don't like looping, though, seems overly cumbersome. What's worse?\\n> maintaining that fragile weird loop that might break (by causing\\n> unexpected output), or a slight slowdown of the test suite?\\n>\\n> I don't know how long it might take on slow machines, but in my\\n> machine, which isn't a great machine, while the vacuum test isn't fast\\n> indeed, it's just a tiny fraction of what a simple \\\"make check\\\" takes.\\n> So it's not a huge slowdown in any case.\\n\\nWell, what about a machine running tests under valgrind, or the weird\\ncache-clobbering infuriatingly slow code? Or buildfarm members running\\non really slow hardware? These days, a few people have spent a lot of\\ntime trying to reduce the total test time, and it'd be bad to lose back\\nthe improvements for no good reason.\\n\\nI grant you that the looping I proposed is more complicated, but I don't\\nsee any reason why it would break.\\n\\nAnother argument against the LOCK pg_class idea is that it causes an\\nunnecessary contention point across the whole parallel test group --\\nwith possible weird side effects. How about a deadlock?\\n\\nOther than the wait loop I proposed, I think we can make a couple of\\nvery simple improvements to this test case to avoid a slowdown:\\n\\n1. the DELETE takes about 1/4th of the time and removes about the same\\nnumber of rows as the one using the IN clause:\\n delete from vactst where random() < 3.0 / 4;\\n\\n2. Use a new temp table rather than vactst. Everything is then faster.\\n\\n3. Figure out the minimum size for the table that triggers the behavior\\n you want. Right now you use 400k tuples -- maybe 100k are sufficient?\\n Don't know.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Thu, 8 Feb 2018 20:39:19 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Feb 8, 2018 at 8:39 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n> Claudio Freire wrote:\\n>\\n>> I don't like looping, though, seems overly cumbersome. What's worse?\\n>> maintaining that fragile weird loop that might break (by causing\\n>> unexpected output), or a slight slowdown of the test suite?\\n>>\\n>> I don't know how long it might take on slow machines, but in my\\n>> machine, which isn't a great machine, while the vacuum test isn't fast\\n>> indeed, it's just a tiny fraction of what a simple \\\"make check\\\" takes.\\n>> So it's not a huge slowdown in any case.\\n>\\n> Well, what about a machine running tests under valgrind, or the weird\\n> cache-clobbering infuriatingly slow code? Or buildfarm members running\\n> on really slow hardware? These days, a few people have spent a lot of\\n> time trying to reduce the total test time, and it'd be bad to lose back\\n> the improvements for no good reason.\\n\\nIt's not for no good reason. The old tests were woefully inadequate.\\n\\nDuring the process of developing the patch, I got seriously broken\\ncode that passed the tests nonetheless. The test as it was was very\\nineffective at actually detecting issues.\\n\\nThis new test may be slow, but it's effective. That's a very good\\nreason to make it slower, if you ask me.\\n\\n> I grant you that the looping I proposed is more complicated, but I don't\\n> see any reason why it would break.\\n>\\n> Another argument against the LOCK pg_class idea is that it causes an\\n> unnecessary contention point across the whole parallel test group --\\n> with possible weird side effects. How about a deadlock?\\n\\nThe real issue with lock pg_class is that locks on pg_class are\\nshort-lived, so I'm not waiting for whole transactions.\\n\\n> Other than the wait loop I proposed, I think we can make a couple of\\n> very simple improvements to this test case to avoid a slowdown:\\n>\\n> 1. the DELETE takes about 1/4th of the time and removes about the same\\n> number of rows as the one using the IN clause:\\n> delete from vactst where random() < 3.0 / 4;\\n\\nI did try this at first, but it causes random output, so the test\\nbreaks randomly.\\n\\n> 2. Use a new temp table rather than vactst. Everything is then faster.\\n\\nI might try that.\\n\\n> 3. Figure out the minimum size for the table that triggers the behavior\\n> you want. Right now you use 400k tuples -- maybe 100k are sufficient?\\n> Don't know.\\n\\nFor that test, I need enough *dead* tuples to cause several passes.\\nEven small mwm settings require tons of tuples for this. In fact, I'm\\nthinking that number might be too low for its purpose, even. I'll\\nre-check, but I doubt it's too high. If anything, it's too low.\\n\\n\",\n \"msg_date\": \"Fri, 9 Feb 2018 09:20:32 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Claudio Freire wrote:\\n> On Thu, Feb 8, 2018 at 8:39 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n\\n> During the process of developing the patch, I got seriously broken\\n> code that passed the tests nonetheless. The test as it was was very\\n> ineffective at actually detecting issues.\\n> \\n> This new test may be slow, but it's effective. That's a very good\\n> reason to make it slower, if you ask me.\\n\\nOK, I don't disagree with improving the test, but if we can make it fast\\n*and* effective, that's better than slow and effective.\\n\\n> > Another argument against the LOCK pg_class idea is that it causes an\\n> > unnecessary contention point across the whole parallel test group --\\n> > with possible weird side effects. How about a deadlock?\\n> \\n> The real issue with lock pg_class is that locks on pg_class are\\n> short-lived, so I'm not waiting for whole transactions.\\n\\nDoh.\\n\\n> > Other than the wait loop I proposed, I think we can make a couple of\\n> > very simple improvements to this test case to avoid a slowdown:\\n> >\\n> > 1. the DELETE takes about 1/4th of the time and removes about the same\\n> > number of rows as the one using the IN clause:\\n> > delete from vactst where random() < 3.0 / 4;\\n> \\n> I did try this at first, but it causes random output, so the test\\n> breaks randomly.\\n\\nOK. Still, your query seqscans the table twice. Maybe it's possible to\\nuse a CTID scan to avoid that, but I'm not sure how.\\n\\n> > 3. Figure out the minimum size for the table that triggers the behavior\\n> > you want. Right now you use 400k tuples -- maybe 100k are sufficient?\\n> > Don't know.\\n> \\n> For that test, I need enough *dead* tuples to cause several passes.\\n> Even small mwm settings require tons of tuples for this. In fact, I'm\\n> thinking that number might be too low for its purpose, even. I'll\\n> re-check, but I doubt it's too high. If anything, it's too low.\\n\\nOK.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Fri, 9 Feb 2018 10:32:40 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Feb 9, 2018 at 10:32 AM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n> Claudio Freire wrote:\\n>> On Thu, Feb 8, 2018 at 8:39 PM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n>\\n>> During the process of developing the patch, I got seriously broken\\n>> code that passed the tests nonetheless. The test as it was was very\\n>> ineffective at actually detecting issues.\\n>>\\n>> This new test may be slow, but it's effective. That's a very good\\n>> reason to make it slower, if you ask me.\\n>\\n> OK, I don't disagree with improving the test, but if we can make it fast\\n> *and* effective, that's better than slow and effective.\\n\\nI'd love to have a test that uses multiple segments of dead tuples,\\nbut for that, it needs to use more than 64MB of mwm. That amounts to,\\nbasically, ~12M rows.\\n\\nIs there a \\\"slow test suite\\\" where such a test could be added that\\nwon't bother regular \\\"make check\\\"?\\n\\nThat, or we turn the initial segment size into a GUC, but I don't\\nthink it's a useful GUC outside of the test suite.\\n\\n>> > 3. Figure out the minimum size for the table that triggers the behavior\\n>> > you want. Right now you use 400k tuples -- maybe 100k are sufficient?\\n>> > Don't know.\\n>>\\n>> For that test, I need enough *dead* tuples to cause several passes.\\n>> Even small mwm settings require tons of tuples for this. In fact, I'm\\n>> thinking that number might be too low for its purpose, even. I'll\\n>> re-check, but I doubt it's too high. If anything, it's too low.\\n>\\n> OK.\\n\\nTurns out that it was a tad oversized. 300k tuples seems enough.\\n\\nAttached is a new patch version that:\\n\\n- Uses an unlogged table to make the large mwm test faster\\n- Uses a wait_barrier helper that waits for concurrent transactions\\n to finish before vacuuming tables, to make sure deleted tuples\\n actually are vacuumable\\n- Tweaks the size of the large mwm test to be as small as possible\\n- Optimizes the delete to avoid expensive operations yet attain\\n the same end result\",\n \"msg_date\": \"Fri, 9 Feb 2018 13:05:43 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 18, 2017 at 8:39 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Fri, Apr 7, 2017 at 10:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> Indeed they do, and that's what motivated this patch. But I'd need\\n>> TB-sized tables to set up something like that. I don't have the\\n>> hardware or time available to do that (vacuum on bloated TB-sized\\n>> tables can take days in my experience). Scale 4000 is as big as I can\\n>> get without running out of space for the tests in my test hardware.\\n>>\\n>> If anybody else has the ability, I'd be thankful if they did test it\\n>> under those conditions, but I cannot. I think Anastasia's test is\\n>> closer to such a test, that's probably why it shows a bigger\\n>> improvement in total elapsed time.\\n>>\\n>> Our production database could possibly be used, but it can take about\\n>> a week to clone it, upgrade it (it's 9.5 currently), and run the\\n>> relevant vacuum.\\n>\\n> It looks like I won't be able to do that test with a production\\n> snapshot anytime soon.\\n>\\n> Getting approval for the budget required to do that looks like it's\\n> going to take far longer than I thought.\\n\\nI finally had a chance to test the patch in a production snapshot.\\n\\nActually, I tried to take out 2 birds with one stone, and I'm also\\ntesting the FSM vacuum patch. It shouldn't significantly alter the\\nnumbers anyway.\\n\\nSo, while the whole-db throttled vacuum (as is run in production) is\\nstill ongoing, an interesting case already popped up.\\n\\nTL;DR, without the patch, this particular table took 16 1/2 hours more\\nor less, to vacuum 313M dead tuples. With the patch, it took 6:10h to\\nvacuum 323M dead tuples. That's quite a speedup. It even used\\nsignificantly less CPU time as well.\\n\\nSince vacuum here is throttled (with cost-based delays), this also\\nmeans it generated less I/O.\\n\\nWe have more extreme cases sometimes, so if I see something\\ninteresting in what remains of the test, I'll post those results as\\nwell.\\n\\nThe raw data:\\n\\nPatched\\n\\nINFO: vacuuming \\\"public.aggregated_tracks_hourly_full\\\"\\nINFO: scanned index \\\"aggregated_tracks_hourly_full_pkey_null\\\" to\\nremove 323778164 row versions\\nDETAIL: CPU: user: 111.57 s, system: 31.28 s, elapsed: 2693.67 s\\nINFO: scanned index \\\"ix_aggregated_tracks_hourly_full_action_null\\\" to\\nremove 323778164 row versions\\nDETAIL: CPU: user: 281.89 s, system: 36.32 s, elapsed: 2915.94 s\\nINFO: scanned index \\\"ix_aggregated_tracks_hourly_full_nunq\\\" to remove\\n323778164 row versions\\nDETAIL: CPU: user: 313.35 s, system: 79.22 s, elapsed: 6400.87 s\\nINFO: \\\"aggregated_tracks_hourly_full\\\": removed 323778164 row versions\\nin 7070739 pages\\nDETAIL: CPU: user: 583.48 s, system: 69.77 s, elapsed: 8048.00 s\\nINFO: index \\\"aggregated_tracks_hourly_full_pkey_null\\\" now contains\\n720807609 row versions in 10529903 pages\\nDETAIL: 43184641 index row versions were removed.\\n5288916 index pages have been deleted, 4696227 are currently reusable.\\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.03 s.\\nINFO: index \\\"ix_aggregated_tracks_hourly_full_action_null\\\" now\\ncontains 720807609 row versions in 7635161 pages\\nDETAIL: 202678522 index row versions were removed.\\n4432789 index pages have been deleted, 3727966 are currently reusable.\\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.01 s.\\nINFO: index \\\"ix_aggregated_tracks_hourly_full_nunq\\\" now contains\\n720807609 row versions in 15526885 pages\\nDETAIL: 202678522 index row versions were removed.\\n9052488 index pages have been deleted, 7390279 are currently reusable.\\nCPU: user: 0.00 s, system: 0.00 s, elapsed: 0.02 s.\\nINFO: \\\"aggregated_tracks_hourly_full\\\": found 41131260 removable,\\n209520861 nonremovable row versions in 7549244 out of 22391603 pages\\nDETAIL: 0 dead row versions cannot be removed yet, oldest xmin: 245834316\\nThere were 260553451 unused item pointers.\\nSkipped 0 pages due to buffer pins, 0 frozen pages.\\n0 pages are entirely empty.\\nCPU: user: 1329.64 s, system: 244.22 s, elapsed: 22222.14 s.\\n\\n\\nVanilla 9.5 (ie: what's in production right now, should be similar to master):\\n\\nINFO: vacuuming \\\"public.aggregated_tracks_hourly_full\\\"\\nINFO: scanned index \\\"aggregated_tracks_hourly_full_pkey_null\\\" to\\nremove 178956729 row versions\\nDETAIL: CPU 65.51s/253.67u sec elapsed 3490.13 sec.\\nINFO: scanned index \\\"ix_aggregated_tracks_hourly_full_action_null\\\" to\\nremove 178956729 row versions\\nDETAIL: CPU 63.26s/238.08u sec elapsed 3483.32 sec.\\nINFO: scanned index \\\"ix_aggregated_tracks_hourly_full_nunq\\\" to remove\\n178956729 row versions\\nDETAIL: CPU 340.15s/445.52u sec elapsed 15898.48 sec.\\nINFO: \\\"aggregated_tracks_hourly_full\\\": removed 178956729 row versions\\nin 3121122 pages\\nDETAIL: CPU 168.24s/159.20u sec elapsed 5678.51 sec.\\nINFO: scanned index \\\"aggregated_tracks_hourly_full_pkey_null\\\" to\\nremove 134424729 row versions\\nDETAIL: CPU 50.66s/265.19u sec elapsed 3977.15 sec.\\nINFO: scanned index \\\"ix_aggregated_tracks_hourly_full_action_null\\\" to\\nremove 134424729 row versions\\nDETAIL: CPU 99.68s/326.44u sec elapsed 6580.22 sec.\\nINFO: scanned index \\\"ix_aggregated_tracks_hourly_full_nunq\\\" to remove\\n134424729 row versions\\nDETAIL: CPU 146.96s/358.86u sec elapsed 10464.69 sec.\\nINFO: \\\"aggregated_tracks_hourly_full\\\": removed 134424729 row versions\\nin 2072649 pages\\nDETAIL: CPU 109.07s/37.12u sec elapsed 3601.39 sec.\\nINFO: index \\\"aggregated_tracks_hourly_full_pkey_null\\\" now contains\\n870543969 row versions in 10529903 pages\\nDETAIL: 134424771 index row versions were removed.\\n4358027 index pages have been deleted, 3662385 are currently reusable.\\nCPU 0.02s/0.00u sec elapsed 2.42 sec.\\nINFO: index \\\"ix_aggregated_tracks_hourly_full_action_null\\\" now\\ncontains 870543969 row versions in 7635161 pages\\nDETAIL: 134424771 index row versions were removed.\\n3908583 index pages have been deleted, 3445049 are currently reusable.\\nCPU 0.02s/0.00u sec elapsed 0.08 sec.\\nINFO: index \\\"ix_aggregated_tracks_hourly_full_nunq\\\" now contains\\n870543969 row versions in 15526885 pages\\nDETAIL: 218955943 index row versions were removed.\\n7710441 index pages have been deleted, 5928522 are currently reusable.\\nCPU 0.02s/0.01u sec elapsed 0.19 sec.\\nINFO: \\\"aggregated_tracks_hourly_full\\\": found 134159696 removable,\\n90271560 nonremovable row versions in 6113375 out of 22391603 pages\\nDETAIL: 287 dead row versions cannot be removed yet.\\nThere were 126680434 unused item pointers.\\nSkipped 0 pages due to buffer pins.\\n0 pages are entirely empty.\\nCPU 1191.42s/2223.19u sec elapsed 59885.50 sec.\\n\\n\",\n \"msg_date\": \"Mon, 19 Feb 2018 18:50:40 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Feb 9, 2018 at 1:05 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> Turns out that it was a tad oversized. 300k tuples seems enough.\\n>\\n> Attached is a new patch version that:\\n>\\n> - Uses an unlogged table to make the large mwm test faster\\n> - Uses a wait_barrier helper that waits for concurrent transactions\\n> to finish before vacuuming tables, to make sure deleted tuples\\n> actually are vacuumable\\n> - Tweaks the size of the large mwm test to be as small as possible\\n> - Optimizes the delete to avoid expensive operations yet attain\\n> the same end result\\n\\nAttached rebased versions of the patches (they weren't applying to\\ncurrent master)\",\n \"msg_date\": \"Fri, 16 Mar 2018 18:46:06 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [HACKERS] Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Hello everyone,\\r\\n\\r\\nI would like to let you know that unfortunately these patches don't apply anymore. Also personally I'm a bit confused by the last message that has 0001- and 0003- patches attached but not the 0002- one.\",\n \"msg_date\": \"Tue, 27 Mar 2018 13:20:42 +0000\",\n \"msg_from\": \"Aleksander Alekseev <a.alekseev@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"I didn't receive your comment, I just saw it. Nevertheless, I rebased the patches a while ago just because I noticed they didn't apply anymore in cputube, and they still seem to apply.\\r\\n\\r\\nPatch number 2 was committed a long while ago, that's why it's missing. It was a simple patch, it landed rewritten as commit 7e26e02eec90370dd222f35f00042f8188488ac4\",\n \"msg_date\": \"Tue, 03 Apr 2018 14:06:30 +0000\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Apr 3, 2018 at 11:06 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> I didn't receive your comment, I just saw it. Nevertheless, I rebased the patches a while ago just because I noticed they didn't apply anymore in cputube, and they still seem to apply.\\n\\nSorry, that is false.\\n\\nThey appear green in cputube, so I was confident they did apply, but I\\njust double-checked on a recent pull and they don't. I'll rebase them\\nshortly.\\n\\n\",\n \"msg_date\": \"Tue, 3 Apr 2018 11:09:42 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Tue, Apr 3, 2018 at 11:09 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Tue, Apr 3, 2018 at 11:06 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> I didn't receive your comment, I just saw it. Nevertheless, I rebased the patches a while ago just because I noticed they didn't apply anymore in cputube, and they still seem to apply.\\n>\\n> Sorry, that is false.\\n>\\n> They appear green in cputube, so I was confident they did apply, but I\\n> just double-checked on a recent pull and they don't. I'll rebase them\\n> shortly.\\n\\n\\nOk, rebased patches attached\",\n \"msg_date\": \"Tue, 3 Apr 2018 11:20:11 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 03/04/18 17:20, Claudio Freire wrote:\\n> Ok, rebased patches attached\\n\\nThanks! I took a look at this.\\n\\nFirst, now that the data structure is more complicated, I think it's \\ntime to abstract it, and move it out of vacuumlazy.c. The Tid Map needs \\nto support the following operations:\\n\\n* Add TIDs, in order (in 1st phase of vacuum)\\n* Random lookup, by TID (when scanning indexes)\\n* Iterate through all TIDs, in order (2nd pass over heap)\\n\\nLet's add a new source file to hold the code for the tid map data \\nstructure, with functions corresponding those operations.\\n\\nI took a stab at doing that, and I think it makes vacuumlazy.c nicer.\\n\\nSecondly, I'm not a big fan of the chosen data structure. I think the \\nonly reason that the segmented \\\"multi-array\\\" was chosen is that each \\n\\\"segment\\\" works is similar to the simple array that we used to have. \\nAfter putting it behind the abstraction, it seems rather ad hoc. There \\nare many standard textbook data structures that we could use instead, \\nand would be easier to understand and reason about, I think.\\n\\nSo, I came up with the attached patch. I used a B-tree as the data \\nstructure. Not sure it's the best one, I'm all ears for suggestions and \\nbikeshedding on alternatives, but I'm pretty happy with that. I would \\nexpect it to be pretty close to the simple array with binary search in \\nperformance characteristics. It'd be pretty straightforward to optimize \\nfurther, and e.g. use a bitmap of OffsetNumbers or some other more dense \\ndata structure in the B-tree leaf pages, but I resisted doing that as \\npart of this patch.\\n\\nI haven't done any performance testing of this (and not much testing in \\ngeneral), but at least the abstraction seems better this way. \\nPerformance testing would be good, too. In particular, I'd like to know \\nhow this might affect the performance of lazy_tid_reaped(). That's a hot \\nspot when vacuuming indexes, so we don't want to add any cycles there. \\nWas there any ready-made test kits on that in this thread? I didn't see \\nany at a quick glance, but it's a long thread..\\n\\n- Heikki\",\n \"msg_date\": \"Thu, 5 Apr 2018 23:02:09 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Apr 5, 2018 at 5:02 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> On 03/04/18 17:20, Claudio Freire wrote:\\n>>\\n>> Ok, rebased patches attached\\n>\\n>\\n> Thanks! I took a look at this.\\n>\\n> First, now that the data structure is more complicated, I think it's time to\\n> abstract it, and move it out of vacuumlazy.c. The Tid Map needs to support\\n> the following operations:\\n>\\n> * Add TIDs, in order (in 1st phase of vacuum)\\n> * Random lookup, by TID (when scanning indexes)\\n> * Iterate through all TIDs, in order (2nd pass over heap)\\n>\\n> Let's add a new source file to hold the code for the tid map data structure,\\n> with functions corresponding those operations.\\n>\\n> I took a stab at doing that, and I think it makes vacuumlazy.c nicer.\\n\\nAbout the refactoring to split this into their own set of files and\\nabstract away the underlying structure, I can totally get behind that.\\n\\nThe iteration interface, however, seems quite specific for the use\\ncase of vacuumlazy, so it's not really a good abstraction. It also\\ncopies stuff a lot, so it's quite heavyweight. I'd suggest trying to\\ngo for a lighter weight interface with less overhead that is more\\ngeneral at the same time.\\n\\nIf it was C++, I'd say build an iterator class.\\n\\nC would do it probably with macros, so you can have a macro to get to\\nthe current element, another to advance to the next element, and\\nanother to check whether you've reached the end.\\n\\nI can do that if we agree on the points below:\\n\\n> Secondly, I'm not a big fan of the chosen data structure. I think the only\\n> reason that the segmented \\\"multi-array\\\" was chosen is that each \\\"segment\\\"\\n> works is similar to the simple array that we used to have. After putting it\\n> behind the abstraction, it seems rather ad hoc. There are many standard\\n> textbook data structures that we could use instead, and would be easier to\\n> understand and reason about, I think.\\n>\\n> So, I came up with the attached patch. I used a B-tree as the data\\n> structure. Not sure it's the best one, I'm all ears for suggestions and\\n> bikeshedding on alternatives, but I'm pretty happy with that. I would expect\\n> it to be pretty close to the simple array with binary search in performance\\n> characteristics. It'd be pretty straightforward to optimize further, and\\n> e.g. use a bitmap of OffsetNumbers or some other more dense data structure\\n> in the B-tree leaf pages, but I resisted doing that as part of this patch.\\n\\nAbout the B-tree, however, I don't think a B-tree is a good idea.\\n\\nTrees' main benefit is that they can be inserted to efficiently. When\\nall your data is loaded sequentially, in-order, in-memory and\\nimmutable; the tree is pointless, more costly to build, and harder to\\nmaintain - in terms of code complexity.\\n\\nIn this use case, the only benefit of B-trees would be that they're\\noptimized for disk access. If we planned to store this on-disk,\\nperhaps I'd grant you that. But we don't plan to do that, and it's not\\neven clear doing it would be efficient enough for the intended use.\\n\\nOn the other side, using B-trees incurs memory overhead due to the\\nneed for internal nodes, can fragment memory because internal nodes\\naren't the same size as leaf nodes, is easier to get wrong and\\nintroduce bugs... I don't see a gain. If you propose its use, at least\\nbenchmark it to show some gain.\\n\\nSo I don't think B-tree is a good idea, the sorted array already is\\ngood enough, and if not, it's at least close to the earlier\\nimplementation and less likely to introduce bugs.\\n\\nFurthermore, among the 200-ish messages this thread has accumulated,\\nbetter ideas have been proposed, better because they do use less\\nmemory and are faster (like using bitmaps when possible), but if we\\ncan't push a simple refactoring first, there's no chance a bigger\\nrewrite will fare better. Remember, in this use case, using less\\nmemory far outweights any other consideration. Less memory directly\\ntranslates to less iterations over the indexes, because more can be\\ncrammed into m_w_m, which is a huge time saving. Far more than any\\nmicro-optimization.\\n\\nAbout 2 years ago, I chose to try to push this simple algorithm first,\\nthen try to improve on it with better data structures. Nobody\\ncomplained at the time (I think, IIRC), and I don't think it fair to\\ngo and revisit that now. It just delays getting a solution for this\\nissue for the persuit of \\\"the perfect implementaiton\\\" that might never\\narrive. Or even if it doesn, there's nothing stopping us from pushing\\nanother patch in the future with that better implementation if we\\nwish. Lets get something simple and proven first.\\n\\n> I haven't done any performance testing of this (and not much testing in\\n> general), but at least the abstraction seems better this way. Performance\\n> testing would be good, too. In particular, I'd like to know how this might\\n> affect the performance of lazy_tid_reaped(). That's a hot spot when\\n> vacuuming indexes, so we don't want to add any cycles there. Was there any\\n> ready-made test kits on that in this thread? I didn't see any at a quick\\n> glance, but it's a long thread..\\n\\nIf you dig old messages in the thread, I had attached the scripts I\\nused for benchmarking this.\\n\\nI'm attaching again one version of them (I've been modifying it to\\nsuit my purposes at each review round), you'll probably want to tweak\\nit to build test cases good for your purpose here.\",\n \"msg_date\": \"Thu, 5 Apr 2018 19:59:59 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 06/04/18 01:59, Claudio Freire wrote:\\n> The iteration interface, however, seems quite specific for the use\\n> case of vacuumlazy, so it's not really a good abstraction.\\n\\nCan you elaborate? It does return the items one block at a time. Is that \\nwhat you mean by being specific for vacuumlazy? I guess that's a bit \\nspecial, but if you imagine some other users for this abstraction, it's \\nprobably not that unusual. For example, if we started using it in bitmap \\nheap scans, a bitmap heap scan would also want to get the TIDs one block \\nnumber at a time.\\n\\n> It also copies stuff a lot, so it's quite heavyweight. I'd suggest\\n> trying to go for a lighter weight interface with less overhead that\\n> is more general at the same time.\\n\\nNote that there was similar copying, to construct an array of \\nOffsetNumbers, happening in lazy_vacuum_page() before this patch. So the \\nnet amount of copying is the same.\\n\\nI'm envisioning that this data structure will sooner or later be \\noptimized further, so that when you have a lot of TIDs pointing to the \\nsame block, we would pack them more tightly, storing the block number \\njust once, with an array of offset numbers. This interface that returns \\nan array of offset numbers matches that future well, as the iterator \\ncould just return a pointer to the array of offset numbers, with no \\ncopying. (If we end up doing something even more dense, like a bitmap, \\nthen it doesn't help, but that's ok too.)\\n\\n> About the B-tree, however, I don't think a B-tree is a good idea.\\n> \\n> Trees' main benefit is that they can be inserted to efficiently. When\\n> all your data is loaded sequentially, in-order, in-memory and\\n> immutable; the tree is pointless, more costly to build, and harder to\\n> maintain - in terms of code complexity.\\n> \\n> In this use case, the only benefit of B-trees would be that they're\\n> optimized for disk access.\\n\\nThose are not the reasons for which I'd prefer a B-tree. A B-tree has \\ngood cache locality, and when you don't need to worry about random \\ninsertions, page splits, deletions etc., it's also very simple to \\nimplement. This patch is not much longer than the segmented multi-array.\\n\\n> On the other side, using B-trees incurs memory overhead due to the\\n> need for internal nodes, can fragment memory because internal nodes\\n> aren't the same size as leaf nodes, is easier to get wrong and\\n> introduce bugs... I don't see a gain.\\n\\nThe memory overhead incurred by the internal nodes is quite minimal, and \\ncan be adjusted by changing the node sizes. After some experimentation, \\nI settled on 2048 items per leaf node, and 64 items per internal node. \\nWith those values, the overhead caused by the internal nodes is minimal, \\nbelow 0.5%. That seems fine, but we could increase the node sizes to \\nbring it further down, if we'd prefer that tradeoff.\\n\\nI don't understand what memory fragmentation problems you're worried \\nabout. The tree grows one node at a time, as new TIDs are added, until \\nit's all released at the end. I don't see how the size of internal vs \\nleaf nodes matters.\\n\\n> If you propose its use, at least benchmark it to show some gain.\\n\\nSure. I used the attached script to test this. It's inspired by the test \\nscript you posted. It creates a pgbench database with scale factor 100, \\ndeletes 80% of the rows, and runs vacuum. To stress lazy_tid_reaped() \\nmore heavily, the test script creates a number of extra indexes. Half of \\nthem are on the primary key, just to get more repetitions without having \\nto re-initialize in between, and the rest are like this:\\n\\ncreate index random_1 on pgbench_accounts((hashint4(aid)))\\n\\nto stress lazy_vacuum_tid_reaped() with a random access pattern, rather \\nthan the sequential one that you get with the primary key index.\\n\\nI ran the test script on my laptop, with unpatched master, with your \\nlatest multi-array patch, and with the attached version of the b-tree \\npatch. The results are quite noisy, unfortunately, so I wouldn't draw \\nvery strong conclusions from it, but it seems that the performance of \\nall three versions is roughly the same. I looked in particular at the \\nCPU time spent in the index vacuums, as reported by VACUUM VERBOSE.\\n\\n> Furthermore, among the 200-ish messages this thread has accumulated,\\n> better ideas have been proposed, better because they do use less\\n> memory and are faster (like using bitmaps when possible), but if we\\n> can't push a simple refactoring first, there's no chance a bigger\\n> rewrite will fare better. Remember, in this use case, using less\\n> memory far outweights any other consideration. Less memory directly\\n> translates to less iterations over the indexes, because more can be\\n> crammed into m_w_m, which is a huge time saving. Far more than any\\n> micro-optimization.\\n> \\n> About 2 years ago, I chose to try to push this simple algorithm first,\\n> then try to improve on it with better data structures. Nobody\\n> complained at the time (I think, IIRC), and I don't think it fair to\\n> go and revisit that now. It just delays getting a solution for this\\n> issue for the persuit of \\\"the perfect implementaiton\\\" that might never\\n> arrive. Or even if it doesn, there's nothing stopping us from pushing\\n> another patch in the future with that better implementation if we\\n> wish. Lets get something simple and proven first.\\n\\nTrue all that. My point is that the multi-segmented array isn't all that \\nsimple and proven, compared to an also straightforward B-tree. It's \\npretty similar to a B-tree, actually, except that it has exactly two \\nlevels, and the node (= segment) sizes grow exponentially. I'd rather go \\nwith a true B-tree, than something homegrown that resembles a B-tree, \\nbut not quite.\\n\\n> I'm attaching again one version of them (I've been modifying it to\\n> suit my purposes at each review round), you'll probably want to tweak\\n> it to build test cases good for your purpose here.\\n\\nThanks!\\n\\nAttached is a new version of my b-tree version. Compared to yesterday's \\nversion, I fixed a bunch of bugs that turned up in testing.\\n\\nLooking at the changes to the regression test in this, I don't quite \\nunderstand what it's all about. What are the \\\"wait_barriers\\\" for? If I \\nunderstand correctly, they're added so that the VACUUMs can remove the \\ntuples that are deleted in the test. But why are they needed now? Was \\nthat an orthogonal change we should've done anyway?\\n\\nRather than add those wait_barriers, should we stop running the 'vacuum' \\ntest in parallel with the other tests? Or maybe it's a good thing to run \\nit in parallel, to test some other things?\\n\\nWhat are the new tests supposed to cover? The test comment says \\\"large \\nmwm vacuum runs\\\", and it sets maintenance_work_mem to 1 MB, which isn't \\nvery large\\n\\n- Heikki\",\n \"msg_date\": \"Fri, 6 Apr 2018 16:39:21 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 06/04/18 16:39, Heikki Linnakangas wrote:\\n> Sure. I used the attached script to test this. \\n\\nSorry, I attached the wrong script. Here is the correct one that I used. \\nHere are also the results I got from running it\\n\\n- Heikki\",\n \"msg_date\": \"Fri, 6 Apr 2018 16:42:17 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Heikki Linnakangas wrote:\\n> On 06/04/18 01:59, Claudio Freire wrote:\\n> > The iteration interface, however, seems quite specific for the use\\n> > case of vacuumlazy, so it's not really a good abstraction.\\n> \\n> Can you elaborate? It does return the items one block at a time. Is that\\n> what you mean by being specific for vacuumlazy? I guess that's a bit\\n> special, but if you imagine some other users for this abstraction, it's\\n> probably not that unusual. For example, if we started using it in bitmap\\n> heap scans, a bitmap heap scan would also want to get the TIDs one block\\n> number at a time.\\n\\nFWIW I liked the idea of having this abstraction possibly do other\\nthings -- for instance to vacuum brin indexes you'd like to mark index\\ntuples as \\\"containing tuples that were removed\\\" and eventually\\nre-summarize the range. With the current interface we cannot do that,\\nbecause vacuum expects brin vacuuming to ask for each heap tuple \\\"is\\nthis tid dead?\\\" and of course we don't have a list of tids to ask for.\\nSo if we can ask instead \\\"how many dead tuples does this block contain?\\\"\\nbrin vacuuming will be much happier.\\n\\n> Looking at the changes to the regression test in this, I don't quite\\n> understand what it's all about. What are the \\\"wait_barriers\\\" for? If I\\n> understand correctly, they're added so that the VACUUMs can remove the\\n> tuples that are deleted in the test. But why are they needed now? Was that\\n> an orthogonal change we should've done anyway?\\n> \\n> Rather than add those wait_barriers, should we stop running the 'vacuum'\\n> test in parallel with the other tests? Or maybe it's a good thing to run it\\n> in parallel, to test some other things?\\n\\n20180207235226.zygu4r3yv3yfcnmc@alvherre.pgsql\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Fri, 6 Apr 2018 11:00:16 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> On 06/04/18 01:59, Claudio Freire wrote:\\n>>\\n>> The iteration interface, however, seems quite specific for the use\\n>> case of vacuumlazy, so it's not really a good abstraction.\\n>\\n>\\n> Can you elaborate? It does return the items one block at a time. Is that\\n> what you mean by being specific for vacuumlazy? I guess that's a bit\\n> special, but if you imagine some other users for this abstraction, it's\\n> probably not that unusual. For example, if we started using it in bitmap\\n> heap scans, a bitmap heap scan would also want to get the TIDs one block\\n> number at a time.\\n\\nBut you're also tying the caller to the format of the buffer holding\\nthose TIDs, for instance. Why would you, when you can have an\\ninterface that just iterates TIDs and let the caller store them\\nif/however they want?\\n\\nI do believe a pure iterator interface is a better interface.\\n\\n>> It also copies stuff a lot, so it's quite heavyweight. I'd suggest\\n>> trying to go for a lighter weight interface with less overhead that\\n>> is more general at the same time.\\n>\\n>\\n> Note that there was similar copying, to construct an array of OffsetNumbers,\\n> happening in lazy_vacuum_page() before this patch. So the net amount of\\n> copying is the same.\\n>\\n> I'm envisioning that this data structure will sooner or later be optimized\\n> further, so that when you have a lot of TIDs pointing to the same block, we\\n> would pack them more tightly, storing the block number just once, with an\\n> array of offset numbers. This interface that returns an array of offset\\n> numbers matches that future well, as the iterator could just return a\\n> pointer to the array of offset numbers, with no copying. (If we end up doing\\n> something even more dense, like a bitmap, then it doesn't help, but that's\\n> ok too.)\\n\\nBut that's the thing. It's a specialized interface for a future we're\\nnot certain. It's premature.\\n\\nA generic interface does not preclude the possibility of implementing\\nthose in the future, it allows you *not* to if there's no gain. Doing\\nit now, it forces you to.\\n\\n>> About the B-tree, however, I don't think a B-tree is a good idea.\\n>>\\n>> Trees' main benefit is that they can be inserted to efficiently. When\\n>> all your data is loaded sequentially, in-order, in-memory and\\n>> immutable; the tree is pointless, more costly to build, and harder to\\n>> maintain - in terms of code complexity.\\n>>\\n>> In this use case, the only benefit of B-trees would be that they're\\n>> optimized for disk access.\\n>\\n>\\n> Those are not the reasons for which I'd prefer a B-tree. A B-tree has good\\n> cache locality, and when you don't need to worry about random insertions,\\n> page splits, deletions etc., it's also very simple to implement. This patch\\n> is not much longer than the segmented multi-array.\\n\\nBut it *is* complex and less tested. Testing it and making it mature\\nwill take time. Why do that if doing bitmaps is a better path?\\n\\n>> On the other side, using B-trees incurs memory overhead due to the\\n>> need for internal nodes, can fragment memory because internal nodes\\n>> aren't the same size as leaf nodes, is easier to get wrong and\\n>> introduce bugs... I don't see a gain.\\n>\\n>\\n> The memory overhead incurred by the internal nodes is quite minimal, and can\\n> be adjusted by changing the node sizes. After some experimentation, I\\n> settled on 2048 items per leaf node, and 64 items per internal node. With\\n> those values, the overhead caused by the internal nodes is minimal, below\\n> 0.5%. That seems fine, but we could increase the node sizes to bring it\\n> further down, if we'd prefer that tradeoff.\\n>\\n> I don't understand what memory fragmentation problems you're worried about.\\n> The tree grows one node at a time, as new TIDs are added, until it's all\\n> released at the end. I don't see how the size of internal vs leaf nodes\\n> matters.\\n\\nLarge vacuums do several passes, so they'll create one tid map for\\neach pass. Each pass will allocate m_w_m-worth of pages, and then\\ndeallocate them.\\n\\nB-tree page allocations are smaller than malloc's mmap threshold, so\\nfreeing them won't return memory to the operating system. Furthermore,\\nif other allocations get interleaved, objects could be left lying at\\nrandom points in the heap, preventing efficient reuse of the heap for\\nthe next round. In essence, internal fragmentation. This may be\\nexacerbated by AllocSet's own fragmentation and double-accounting.\\n From what I can tell, inner nodes will use pools, and leaf nodes will\\nbe allocated as dedicated chunks (mallocd).\\n\\nSegments in my implementation are big, exactly because of that. The\\naim is to have large buffers that malloc will mmap, so they get\\nreturned to the os (unmapped) when freed quickly, and with little\\noverhead.\\n\\nThis fragmentation may cause actual pain in autovacuum, since\\nautovacuum workers are relatively long-lived.\\n\\n>> If you propose its use, at least benchmark it to show some gain.\\n>\\n>\\n> Sure. I used the attached script to test this. It's inspired by the test\\n> script you posted. It creates a pgbench database with scale factor 100,\\n> deletes 80% of the rows, and runs vacuum. To stress lazy_tid_reaped() more\\n> heavily, the test script creates a number of extra indexes. Half of them are\\n> on the primary key, just to get more repetitions without having to\\n> re-initialize in between, and the rest are like this:\\n>\\n> create index random_1 on pgbench_accounts((hashint4(aid)))\\n>\\n> to stress lazy_vacuum_tid_reaped() with a random access pattern, rather than\\n> the sequential one that you get with the primary key index.\\n>\\n> I ran the test script on my laptop, with unpatched master, with your latest\\n> multi-array patch, and with the attached version of the b-tree patch. The\\n> results are quite noisy, unfortunately, so I wouldn't draw very strong\\n> conclusions from it, but it seems that the performance of all three versions\\n> is roughly the same. I looked in particular at the CPU time spent in the\\n> index vacuums, as reported by VACUUM VERBOSE.\\n\\nScale factor 100 is hardly enough to stress large m_w_m vacuum. I\\nfound scales of 1k-4k (or bigger) are best, with large m_w_m settings\\n(4G for example) to get to really see how the data structure performs.\\n\\n>> Furthermore, among the 200-ish messages this thread has accumulated,\\n>> better ideas have been proposed, better because they do use less\\n>> memory and are faster (like using bitmaps when possible), but if we\\n>> can't push a simple refactoring first, there's no chance a bigger\\n>> rewrite will fare better. Remember, in this use case, using less\\n>> memory far outweights any other consideration. Less memory directly\\n>> translates to less iterations over the indexes, because more can be\\n>> crammed into m_w_m, which is a huge time saving. Far more than any\\n>> micro-optimization.\\n>>\\n>> About 2 years ago, I chose to try to push this simple algorithm first,\\n>> then try to improve on it with better data structures. Nobody\\n>> complained at the time (I think, IIRC), and I don't think it fair to\\n>> go and revisit that now. It just delays getting a solution for this\\n>> issue for the persuit of \\\"the perfect implementaiton\\\" that might never\\n>> arrive. Or even if it doesn, there's nothing stopping us from pushing\\n>> another patch in the future with that better implementation if we\\n>> wish. Lets get something simple and proven first.\\n>\\n>\\n> True all that. My point is that the multi-segmented array isn't all that\\n> simple and proven, compared to an also straightforward B-tree. It's pretty\\n> similar to a B-tree, actually, except that it has exactly two levels, and\\n> the node (= segment) sizes grow exponentially. I'd rather go with a true\\n> B-tree, than something homegrown that resembles a B-tree, but not quite.\\n\\nI disagree.\\n\\nBeing similar to what vacuum is already doing, we can be confident the\\napproach is sound, at least as sound as current vacuum. It shares a\\nlot with the current implementation, which is known to be good.\\n\\nThe multi-segmented array itself has received a lot of testing during\\nthe ~1.5y it has spent in the making, as well. I've been running\\nextensive benchmarking and tests each time I changed something, and\\nI've even ran deep tests on an actual production snapshot. A complete\\ndb-wide vacuum of a heavily bloated ~12TB production database, showing\\nsignificant speedups not only because it does fewer index scans, but\\nalso because it uses less CPU time to do so, with consistency checking\\nafter the fact, to check for bugs. Of course I can't guarantee it's\\nbug-free, but it *is* decently tested.\\n\\nI'm pretty sure the B-tree implementation hasn't reached that level of\\ntesting yet. It might in the future, but it won't happen overnight.\\n\\nYour B-tree patch is also homegrown. You're not reusing well tested\\nbtree code, you're coding a B-tree from scratch, so it's as suspect as\\nany new code. I agree the multi-segment algorithm is quite similar to\\na shallow b-tree, but I'm not convinced a b-tree is what we must\\naspire to have. In fact, if you used large pages for the B-tree, you\\ndon't need more than 2 levels (there's a 12GB limit ATM on the size of\\nthe tid map), so the multi-segment approach and the b-tree approach\\nare essentially the same. Except the multi-segment code got more\\ntesting.\\n\\nIn short, there are other more enticing alternatives to try out first.\\nI'm not enthused by the idea of having to bench and test yet another\\nsorted set implementation before moving forward.\\n\\nOn Fri, Apr 6, 2018 at 11:00 AM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n> Heikki Linnakangas wrote:\\n>> On 06/04/18 01:59, Claudio Freire wrote:\\n>> > The iteration interface, however, seems quite specific for the use\\n>> > case of vacuumlazy, so it's not really a good abstraction.\\n>>\\n>> Can you elaborate? It does return the items one block at a time. Is that\\n>> what you mean by being specific for vacuumlazy? I guess that's a bit\\n>> special, but if you imagine some other users for this abstraction, it's\\n>> probably not that unusual. For example, if we started using it in bitmap\\n>> heap scans, a bitmap heap scan would also want to get the TIDs one block\\n>> number at a time.\\n>\\n> FWIW I liked the idea of having this abstraction possibly do other\\n> things -- for instance to vacuum brin indexes you'd like to mark index\\n> tuples as \\\"containing tuples that were removed\\\" and eventually\\n> re-summarize the range. With the current interface we cannot do that,\\n> because vacuum expects brin vacuuming to ask for each heap tuple \\\"is\\n> this tid dead?\\\" and of course we don't have a list of tids to ask for.\\n> So if we can ask instead \\\"how many dead tuples does this block contain?\\\"\\n> brin vacuuming will be much happier.\\n\\nI don't think either patch gives you that.\\n\\nThe bulkdelete interface is part of the indexam and unlikely to change\\nin this patch.\\n\\n\",\n \"msg_date\": \"Fri, 6 Apr 2018 17:25:00 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"Claudio Freire wrote:\\n\\n> On Fri, Apr 6, 2018 at 11:00 AM, Alvaro Herrera <alvherre@alvh.no-ip.org> wrote:\\n\\n> > FWIW I liked the idea of having this abstraction possibly do other\\n> > things -- for instance to vacuum brin indexes you'd like to mark index\\n> > tuples as \\\"containing tuples that were removed\\\" and eventually\\n> > re-summarize the range. With the current interface we cannot do that,\\n> > because vacuum expects brin vacuuming to ask for each heap tuple \\\"is\\n> > this tid dead?\\\" and of course we don't have a list of tids to ask for.\\n> > So if we can ask instead \\\"how many dead tuples does this block contain?\\\"\\n> > brin vacuuming will be much happier.\\n> \\n> I don't think either patch gives you that.\\n> \\n> The bulkdelete interface is part of the indexam and unlikely to change\\n> in this patch.\\n\\nI'm sure you're correct. I was just saying that with the abstract\\ninterface it is easier to implement what I suggest as a follow-on patch.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Fri, 6 Apr 2018 17:33:14 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@alvh.no-ip.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> On 06/04/18 01:59, Claudio Freire wrote:\\n>>>\\n>>> The iteration interface, however, seems quite specific for the use\\n>>> case of vacuumlazy, so it's not really a good abstraction.\\n>>\\n>>\\n>> Can you elaborate? It does return the items one block at a time. Is that\\n>> what you mean by being specific for vacuumlazy? I guess that's a bit\\n>> special, but if you imagine some other users for this abstraction, it's\\n>> probably not that unusual. For example, if we started using it in bitmap\\n>> heap scans, a bitmap heap scan would also want to get the TIDs one block\\n>> number at a time.\\n>\\n> But you're also tying the caller to the format of the buffer holding\\n> those TIDs, for instance. Why would you, when you can have an\\n> interface that just iterates TIDs and let the caller store them\\n> if/however they want?\\n>\\n> I do believe a pure iterator interface is a better interface.\\n\\nBetween the b-tree or not discussion and the refactoring to separate\\nthe code, I don't think we'll get this in the next 24hs.\\n\\nSo I guess we'll have ample time to poner on both issues during the\\nnext commit fest.\\n\\n\",\n \"msg_date\": \"Fri, 6 Apr 2018 21:00:20 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 04/06/2018 08:00 PM, Claudio Freire wrote:\\n> On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>> On 06/04/18 01:59, Claudio Freire wrote:\\n>>>> The iteration interface, however, seems quite specific for the use\\n>>>> case of vacuumlazy, so it's not really a good abstraction.\\n>>>\\n>>> Can you elaborate? It does return the items one block at a time. Is that\\n>>> what you mean by being specific for vacuumlazy? I guess that's a bit\\n>>> special, but if you imagine some other users for this abstraction, it's\\n>>> probably not that unusual. For example, if we started using it in bitmap\\n>>> heap scans, a bitmap heap scan would also want to get the TIDs one block\\n>>> number at a time.\\n>> But you're also tying the caller to the format of the buffer holding\\n>> those TIDs, for instance. Why would you, when you can have an\\n>> interface that just iterates TIDs and let the caller store them\\n>> if/however they want?\\n>>\\n>> I do believe a pure iterator interface is a better interface.\\n> Between the b-tree or not discussion and the refactoring to separate\\n> the code, I don't think we'll get this in the next 24hs.\\n>\\n> So I guess we'll have ample time to poner on both issues during the\\n> next commit fest.\\n>\\n\\n\\n\\nThere doesn't seem to have been much pondering done since then, at least \\npublicly. Can we make some progress on this? It's been around for a long \\ntime now.\\n\\ncheers\\n\\nandrew\\n\\n-- \\nAndrew Dunstan https://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\",\n \"msg_date\": \"Thu, 12 Jul 2018 09:44:05 -0400\",\n \"msg_from\": \"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Thu, Jul 12, 2018 at 10:44 AM Andrew Dunstan\\n<andrew.dunstan@2ndquadrant.com> wrote:\\n>\\n>\\n>\\n> On 04/06/2018 08:00 PM, Claudio Freire wrote:\\n> > On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> >> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> >>> On 06/04/18 01:59, Claudio Freire wrote:\\n> >>>> The iteration interface, however, seems quite specific for the use\\n> >>>> case of vacuumlazy, so it's not really a good abstraction.\\n> >>>\\n> >>> Can you elaborate? It does return the items one block at a time. Is that\\n> >>> what you mean by being specific for vacuumlazy? I guess that's a bit\\n> >>> special, but if you imagine some other users for this abstraction, it's\\n> >>> probably not that unusual. For example, if we started using it in bitmap\\n> >>> heap scans, a bitmap heap scan would also want to get the TIDs one block\\n> >>> number at a time.\\n> >> But you're also tying the caller to the format of the buffer holding\\n> >> those TIDs, for instance. Why would you, when you can have an\\n> >> interface that just iterates TIDs and let the caller store them\\n> >> if/however they want?\\n> >>\\n> >> I do believe a pure iterator interface is a better interface.\\n> > Between the b-tree or not discussion and the refactoring to separate\\n> > the code, I don't think we'll get this in the next 24hs.\\n> >\\n> > So I guess we'll have ample time to poner on both issues during the\\n> > next commit fest.\\n> >\\n>\\n>\\n>\\n> There doesn't seem to have been much pondering done since then, at least\\n> publicly. Can we make some progress on this? It's been around for a long\\n> time now.\\n\\nYeah, life has kept me busy and I haven't had much time to make\\nprogress here, but I was planning on doing the refactoring as we were\\ndiscussing soon. Can't give a time frame for that, but \\\"soonish\\\".\\n\\n\",\n \"msg_date\": \"Thu, 12 Jul 2018 13:38:18 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 07/12/2018 12:38 PM, Claudio Freire wrote:\\n> On Thu, Jul 12, 2018 at 10:44 AM Andrew Dunstan\\n> <andrew.dunstan@2ndquadrant.com> wrote:\\n>>\\n>>\\n>> On 04/06/2018 08:00 PM, Claudio Freire wrote:\\n>>> On Fri, Apr 6, 2018 at 5:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>>>> On Fri, Apr 6, 2018 at 10:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>>>> On 06/04/18 01:59, Claudio Freire wrote:\\n>>>>>> The iteration interface, however, seems quite specific for the use\\n>>>>>> case of vacuumlazy, so it's not really a good abstraction.\\n>>>>> Can you elaborate? It does return the items one block at a time. Is that\\n>>>>> what you mean by being specific for vacuumlazy? I guess that's a bit\\n>>>>> special, but if you imagine some other users for this abstraction, it's\\n>>>>> probably not that unusual. For example, if we started using it in bitmap\\n>>>>> heap scans, a bitmap heap scan would also want to get the TIDs one block\\n>>>>> number at a time.\\n>>>> But you're also tying the caller to the format of the buffer holding\\n>>>> those TIDs, for instance. Why would you, when you can have an\\n>>>> interface that just iterates TIDs and let the caller store them\\n>>>> if/however they want?\\n>>>>\\n>>>> I do believe a pure iterator interface is a better interface.\\n>>> Between the b-tree or not discussion and the refactoring to separate\\n>>> the code, I don't think we'll get this in the next 24hs.\\n>>>\\n>>> So I guess we'll have ample time to poner on both issues during the\\n>>> next commit fest.\\n>>>\\n>>\\n>>\\n>> There doesn't seem to have been much pondering done since then, at least\\n>> publicly. Can we make some progress on this? It's been around for a long\\n>> time now.\\n> Yeah, life has kept me busy and I haven't had much time to make\\n> progress here, but I was planning on doing the refactoring as we were\\n> discussing soon. Can't give a time frame for that, but \\\"soonish\\\".\\n\\nI fully understand. I think this needs to go back to \\\"Waiting on Author\\\".\\n\\ncheers\\n\\nandrew\\n\\n-- \\nAndrew Dunstan https://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\",\n \"msg_date\": \"Thu, 12 Jul 2018 18:15:54 -0400\",\n \"msg_from\": \"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 2018-Jul-12, Andrew Dunstan wrote:\\n\\n> I fully understand. I think this needs to go back to \\\"Waiting on Author\\\".\\n\\nWhy? Heikki's patch applies fine and passes the regression tests.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\",\n \"msg_date\": \"Thu, 12 Jul 2018 18:34:05 -0400\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n> On 2018-Jul-12, Andrew Dunstan wrote:\\n>\\n>> I fully understand. I think this needs to go back to \\\"Waiting on Author\\\".\\n> Why? Heikki's patch applies fine and passes the regression tests.\\n>\\n\\n\\nWell, I understood Claudio was going to do some more work (see \\nupthread). If we're going to go with Heikki's patch then do we need to \\nchange the author, or add him as an author?\\n\\ncheers\\n\\nandew\\n\\n-- \\nAndrew Dunstan https://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\",\n \"msg_date\": \"Thu, 12 Jul 2018 18:39:38 -0400\",\n \"msg_from\": \"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 13/07/18 01:39, Andrew Dunstan wrote:\\n> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n>> On 2018-Jul-12, Andrew Dunstan wrote:\\n>>\\n>>> I fully understand. I think this needs to go back to \\\"Waiting on Author\\\".\\n>> Why? Heikki's patch applies fine and passes the regression tests.\\n> \\n> Well, I understood Claudio was going to do some more work (see\\n> upthread).\\n\\nClaudio raised a good point, that doing small pallocs leads to \\nfragmentation, and in particular, it might mean that we can't give back \\nthe memory to the OS. The default glibc malloc() implementation has a \\nthreshold of 4 or 32 MB or something like that - allocations larger than \\nthe threshold are mmap()'d, and can always be returned to the OS. I \\nthink a simple solution to that is to allocate larger chunks, something \\nlike 32-64 MB at a time, and carve out the allocations for the nodes \\nfrom those chunks. That's pretty straightforward, because we don't need \\nto worry about freeing the nodes in retail. Keep track of the current \\nhalf-filled chunk, and allocate a new one when it fills up.\\n\\nHe also wanted to refactor the iterator API, to return one ItemPointer \\nat a time. I don't think that's necessary, the current iterator API is \\nmore convenient for the callers, but I don't feel strongly about that.\\n\\nAnything else?\\n\\n> If we're going to go with Heikki's patch then do we need to\\n> change the author, or add him as an author?\\n\\nLet's list both of us. At least in the commit message, doesn't matter \\nmuch what the commitfest app says.\\n\\n- Heikki\\n\\n\",\n \"msg_date\": \"Fri, 13 Jul 2018 16:44:25 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\\n> On 13/07/18 01:39, Andrew Dunstan wrote:\\n>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n>>> On 2018-Jul-12, Andrew Dunstan wrote:\\n>>>\\n>>>> I fully understand. I think this needs to go back to \\\"Waiting on \\n>>>> Author\\\".\\n>>> Why? Heikki's patch applies fine and passes the regression tests.\\n>>\\n>> Well, I understood Claudio was going to do some more work (see\\n>> upthread).\\n>\\n> Claudio raised a good point, that doing small pallocs leads to \\n> fragmentation, and in particular, it might mean that we can't give \\n> back the memory to the OS. The default glibc malloc() implementation \\n> has a threshold of 4 or 32 MB or something like that - allocations \\n> larger than the threshold are mmap()'d, and can always be returned to \\n> the OS. I think a simple solution to that is to allocate larger \\n> chunks, something like 32-64 MB at a time, and carve out the \\n> allocations for the nodes from those chunks. That's pretty \\n> straightforward, because we don't need to worry about freeing the \\n> nodes in retail. Keep track of the current half-filled chunk, and \\n> allocate a new one when it fills up.\\n\\n\\nGoogle seems to suggest the default threshold is much lower, like 128K. \\nStill, making larger allocations seems sensible. Are you going to work \\non that?\\n\\n\\n>\\n> He also wanted to refactor the iterator API, to return one ItemPointer \\n> at a time. I don't think that's necessary, the current iterator API is \\n> more convenient for the callers, but I don't feel strongly about that.\\n>\\n> Anything else?\\n>\\n>> If we're going to go with Heikki's patch then do we need to\\n>> change the author, or add him as an author?\\n>\\n> Let's list both of us. At least in the commit message, doesn't matter \\n> much what the commitfest app says.\\n>\\n\\n\\nI added you as an author in the CF App\\n\\ncheers\\n\\nandrew\\n\\n-- \\nAndrew Dunstan https://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\",\n \"msg_date\": \"Fri, 13 Jul 2018 16:43:12 -0400\",\n \"msg_from\": \"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\\n<andrew.dunstan@2ndquadrant.com> wrote:\\n>\\n>\\n>\\n> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\\n> > On 13/07/18 01:39, Andrew Dunstan wrote:\\n> >> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n> >>> On 2018-Jul-12, Andrew Dunstan wrote:\\n> >>>\\n> >>>> I fully understand. I think this needs to go back to \\\"Waiting on\\n> >>>> Author\\\".\\n> >>> Why? Heikki's patch applies fine and passes the regression tests.\\n> >>\\n> >> Well, I understood Claudio was going to do some more work (see\\n> >> upthread).\\n> >\\n> > Claudio raised a good point, that doing small pallocs leads to\\n> > fragmentation, and in particular, it might mean that we can't give\\n> > back the memory to the OS. The default glibc malloc() implementation\\n> > has a threshold of 4 or 32 MB or something like that - allocations\\n> > larger than the threshold are mmap()'d, and can always be returned to\\n> > the OS. I think a simple solution to that is to allocate larger\\n> > chunks, something like 32-64 MB at a time, and carve out the\\n> > allocations for the nodes from those chunks. That's pretty\\n> > straightforward, because we don't need to worry about freeing the\\n> > nodes in retail. Keep track of the current half-filled chunk, and\\n> > allocate a new one when it fills up.\\n>\\n>\\n> Google seems to suggest the default threshold is much lower, like 128K.\\n> Still, making larger allocations seems sensible. Are you going to work\\n> on that?\\n\\nBelow a few MB the threshold is dynamic, and if a block bigger than\\n128K but smaller than the higher threshold (32-64MB IIRC) is freed,\\nthe dynamic threshold is set to the size of the freed block.\\n\\nSee M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\\n\\nSo I'd suggest allocating blocks bigger than M_MMAP_MAX.\\n\\n[1] http://man7.org/linux/man-pages/man3/mallopt.3.html\\n\\n\",\n \"msg_date\": \"Mon, 16 Jul 2018 11:34:53 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Jul 16, 2018 at 11:34 AM Claudio Freire <klaussfreire@gmail.com> wrote:\\n>\\n> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\\n> <andrew.dunstan@2ndquadrant.com> wrote:\\n> >\\n> >\\n> >\\n> > On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\\n> > > On 13/07/18 01:39, Andrew Dunstan wrote:\\n> > >> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n> > >>> On 2018-Jul-12, Andrew Dunstan wrote:\\n> > >>>\\n> > >>>> I fully understand. I think this needs to go back to \\\"Waiting on\\n> > >>>> Author\\\".\\n> > >>> Why? Heikki's patch applies fine and passes the regression tests.\\n> > >>\\n> > >> Well, I understood Claudio was going to do some more work (see\\n> > >> upthread).\\n> > >\\n> > > Claudio raised a good point, that doing small pallocs leads to\\n> > > fragmentation, and in particular, it might mean that we can't give\\n> > > back the memory to the OS. The default glibc malloc() implementation\\n> > > has a threshold of 4 or 32 MB or something like that - allocations\\n> > > larger than the threshold are mmap()'d, and can always be returned to\\n> > > the OS. I think a simple solution to that is to allocate larger\\n> > > chunks, something like 32-64 MB at a time, and carve out the\\n> > > allocations for the nodes from those chunks. That's pretty\\n> > > straightforward, because we don't need to worry about freeing the\\n> > > nodes in retail. Keep track of the current half-filled chunk, and\\n> > > allocate a new one when it fills up.\\n> >\\n> >\\n> > Google seems to suggest the default threshold is much lower, like 128K.\\n> > Still, making larger allocations seems sensible. Are you going to work\\n> > on that?\\n>\\n> Below a few MB the threshold is dynamic, and if a block bigger than\\n> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\\n> the dynamic threshold is set to the size of the freed block.\\n>\\n> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\\n>\\n> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\\n>\\n> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\\n\\nSorry, substitute M_MMAP_MAX with DEFAULT_MMAP_THRESHOLD_MAX, the\\nformer is something else.\\n\\n\",\n \"msg_date\": \"Mon, 16 Jul 2018 12:35:17 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On 16/07/18 18:35, Claudio Freire wrote:\\n> On Mon, Jul 16, 2018 at 11:34 AM Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\\n>> <andrew.dunstan@2ndquadrant.com> wrote:\\n>>> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\\n>>>> Claudio raised a good point, that doing small pallocs leads to\\n>>>> fragmentation, and in particular, it might mean that we can't give\\n>>>> back the memory to the OS. The default glibc malloc() implementation\\n>>>> has a threshold of 4 or 32 MB or something like that - allocations\\n>>>> larger than the threshold are mmap()'d, and can always be returned to\\n>>>> the OS. I think a simple solution to that is to allocate larger\\n>>>> chunks, something like 32-64 MB at a time, and carve out the\\n>>>> allocations for the nodes from those chunks. That's pretty\\n>>>> straightforward, because we don't need to worry about freeing the\\n>>>> nodes in retail. Keep track of the current half-filled chunk, and\\n>>>> allocate a new one when it fills up.\\n>>>\\n>>> Google seems to suggest the default threshold is much lower, like 128K.\\n>>> Still, making larger allocations seems sensible. Are you going to work\\n>>> on that?\\n>>\\n>> Below a few MB the threshold is dynamic, and if a block bigger than\\n>> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\\n>> the dynamic threshold is set to the size of the freed block.\\n>>\\n>> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\\n>>\\n>> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\\n>>\\n>> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\\n> \\n> Sorry, substitute M_MMAP_MAX with DEFAULT_MMAP_THRESHOLD_MAX, the\\n> former is something else.\\n\\nYeah, we basically want to be well above whatever the threshold is. I \\ndon't think we should try to check for any specific constant, just make \\nit large enough. Different libc implementations might have different \\npolicies, too. There's little harm in overshooting, and making e.g. 64 \\nMB allocations when 1 MB would've been enough to trigger the mmap() \\nbehavior. It's going to be more granular than the current situation, \\nanyway, where we do a single massive allocation.\\n\\n(A code comment to briefly mention the thresholds on common platforms \\nwould be good, though).\\n\\n- Heikki\\n\\n\",\n \"msg_date\": \"Mon, 16 Jul 2018 18:47:45 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 07/16/2018 10:34 AM, Claudio Freire wrote:\\n> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\\n> <andrew.dunstan@2ndquadrant.com> wrote:\\n>>\\n>>\\n>> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\\n>>> On 13/07/18 01:39, Andrew Dunstan wrote:\\n>>>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n>>>>> On 2018-Jul-12, Andrew Dunstan wrote:\\n>>>>>\\n>>>>>> I fully understand. I think this needs to go back to \\\"Waiting on\\n>>>>>> Author\\\".\\n>>>>> Why? Heikki's patch applies fine and passes the regression tests.\\n>>>> Well, I understood Claudio was going to do some more work (see\\n>>>> upthread).\\n>>> Claudio raised a good point, that doing small pallocs leads to\\n>>> fragmentation, and in particular, it might mean that we can't give\\n>>> back the memory to the OS. The default glibc malloc() implementation\\n>>> has a threshold of 4 or 32 MB or something like that - allocations\\n>>> larger than the threshold are mmap()'d, and can always be returned to\\n>>> the OS. I think a simple solution to that is to allocate larger\\n>>> chunks, something like 32-64 MB at a time, and carve out the\\n>>> allocations for the nodes from those chunks. That's pretty\\n>>> straightforward, because we don't need to worry about freeing the\\n>>> nodes in retail. Keep track of the current half-filled chunk, and\\n>>> allocate a new one when it fills up.\\n>>\\n>> Google seems to suggest the default threshold is much lower, like 128K.\\n>> Still, making larger allocations seems sensible. Are you going to work\\n>> on that?\\n> Below a few MB the threshold is dynamic, and if a block bigger than\\n> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\\n> the dynamic threshold is set to the size of the freed block.\\n>\\n> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\\n>\\n> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\\n>\\n> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\\n\\n\\nThat page says:\\n\\n M_MMAP_MAX\\n This parameter specifies the maximum number of allocation\\n requests that may be simultaneously serviced using mmap(2).\\n This parameter exists because some systems have a limited\\n number of internal tables for use by mmap(2), and using more\\n than a few of them may degrade performance.\\n\\n The default value is 65,536, a value which has no special\\n significance and which serves only as a safeguard. Setting\\n this parameter to 0 disables the use of mmap(2) for servicing\\n large allocation requests.\\n\\n\\nI'm confused about the relevance.\\n\\ncheers\\n\\nandrew\\n\\n-- \\nAndrew Dunstan https://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\",\n \"msg_date\": \"Mon, 16 Jul 2018 14:30:13 -0400\",\n \"msg_from\": \"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Jul 16, 2018 at 3:30 PM Andrew Dunstan\\n<andrew.dunstan@2ndquadrant.com> wrote:\\n>\\n>\\n>\\n> On 07/16/2018 10:34 AM, Claudio Freire wrote:\\n> > On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\\n> > <andrew.dunstan@2ndquadrant.com> wrote:\\n> >>\\n> >>\\n> >> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\\n> >>> On 13/07/18 01:39, Andrew Dunstan wrote:\\n> >>>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n> >>>>> On 2018-Jul-12, Andrew Dunstan wrote:\\n> >>>>>\\n> >>>>>> I fully understand. I think this needs to go back to \\\"Waiting on\\n> >>>>>> Author\\\".\\n> >>>>> Why? Heikki's patch applies fine and passes the regression tests.\\n> >>>> Well, I understood Claudio was going to do some more work (see\\n> >>>> upthread).\\n> >>> Claudio raised a good point, that doing small pallocs leads to\\n> >>> fragmentation, and in particular, it might mean that we can't give\\n> >>> back the memory to the OS. The default glibc malloc() implementation\\n> >>> has a threshold of 4 or 32 MB or something like that - allocations\\n> >>> larger than the threshold are mmap()'d, and can always be returned to\\n> >>> the OS. I think a simple solution to that is to allocate larger\\n> >>> chunks, something like 32-64 MB at a time, and carve out the\\n> >>> allocations for the nodes from those chunks. That's pretty\\n> >>> straightforward, because we don't need to worry about freeing the\\n> >>> nodes in retail. Keep track of the current half-filled chunk, and\\n> >>> allocate a new one when it fills up.\\n> >>\\n> >> Google seems to suggest the default threshold is much lower, like 128K.\\n> >> Still, making larger allocations seems sensible. Are you going to work\\n> >> on that?\\n> > Below a few MB the threshold is dynamic, and if a block bigger than\\n> > 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\\n> > the dynamic threshold is set to the size of the freed block.\\n> >\\n> > See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\\n> >\\n> > So I'd suggest allocating blocks bigger than M_MMAP_MAX.\\n> >\\n> > [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\\n>\\n>\\n> That page says:\\n>\\n> M_MMAP_MAX\\n> This parameter specifies the maximum number of allocation\\n> requests that may be simultaneously serviced using mmap(2).\\n> This parameter exists because some systems have a limited\\n> number of internal tables for use by mmap(2), and using more\\n> than a few of them may degrade performance.\\n>\\n> The default value is 65,536, a value which has no special\\n> significance and which serves only as a safeguard. Setting\\n> this parameter to 0 disables the use of mmap(2) for servicing\\n> large allocation requests.\\n>\\n>\\n> I'm confused about the relevance.\\n\\nIt isn't relevant. See my next message, it should have read\\nDEFAULT_MMAP_THRESHOLD_MAX.\\n\\n\",\n \"msg_date\": \"Mon, 16 Jul 2018 15:32:03 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 07/16/2018 11:35 AM, Claudio Freire wrote:\\n> On Mon, Jul 16, 2018 at 11:34 AM Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Fri, Jul 13, 2018 at 5:43 PM Andrew Dunstan\\n>> <andrew.dunstan@2ndquadrant.com> wrote:\\n>>>\\n>>>\\n>>> On 07/13/2018 09:44 AM, Heikki Linnakangas wrote:\\n>>>> On 13/07/18 01:39, Andrew Dunstan wrote:\\n>>>>> On 07/12/2018 06:34 PM, Alvaro Herrera wrote:\\n>>>>>> On 2018-Jul-12, Andrew Dunstan wrote:\\n>>>>>>\\n>>>>>>> I fully understand. I think this needs to go back to \\\"Waiting on\\n>>>>>>> Author\\\".\\n>>>>>> Why? Heikki's patch applies fine and passes the regression tests.\\n>>>>> Well, I understood Claudio was going to do some more work (see\\n>>>>> upthread).\\n>>>> Claudio raised a good point, that doing small pallocs leads to\\n>>>> fragmentation, and in particular, it might mean that we can't give\\n>>>> back the memory to the OS. The default glibc malloc() implementation\\n>>>> has a threshold of 4 or 32 MB or something like that - allocations\\n>>>> larger than the threshold are mmap()'d, and can always be returned to\\n>>>> the OS. I think a simple solution to that is to allocate larger\\n>>>> chunks, something like 32-64 MB at a time, and carve out the\\n>>>> allocations for the nodes from those chunks. That's pretty\\n>>>> straightforward, because we don't need to worry about freeing the\\n>>>> nodes in retail. Keep track of the current half-filled chunk, and\\n>>>> allocate a new one when it fills up.\\n>>>\\n>>> Google seems to suggest the default threshold is much lower, like 128K.\\n>>> Still, making larger allocations seems sensible. Are you going to work\\n>>> on that?\\n>> Below a few MB the threshold is dynamic, and if a block bigger than\\n>> 128K but smaller than the higher threshold (32-64MB IIRC) is freed,\\n>> the dynamic threshold is set to the size of the freed block.\\n>>\\n>> See M_MMAP_MAX and M_MMAP_THRESHOLD in the man page for mallopt[1]\\n>>\\n>> So I'd suggest allocating blocks bigger than M_MMAP_MAX.\\n>>\\n>> [1] http://man7.org/linux/man-pages/man3/mallopt.3.html\\n> Sorry, substitute M_MMAP_MAX with DEFAULT_MMAP_THRESHOLD_MAX, the\\n> former is something else.\\n\\n\\nAh, ok. Thanks. ignore the email I just sent about that.\\n\\ncheers\\n\\nandrew\\n\\n-- \\nAndrew Dunstan https://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\",\n \"msg_date\": \"Mon, 16 Jul 2018 14:33:17 -0400\",\n \"msg_from\": \"Andrew Dunstan <andrew.dunstan@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 6, 2018 at 4:25 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> True all that. My point is that the multi-segmented array isn't all that\\n>> simple and proven, compared to an also straightforward B-tree. It's pretty\\n>> similar to a B-tree, actually, except that it has exactly two levels, and\\n>> the node (= segment) sizes grow exponentially. I'd rather go with a true\\n>> B-tree, than something homegrown that resembles a B-tree, but not quite.\\n>\\n> I disagree.\\n\\nYeah, me too. I think a segmented array is a lot simpler than a\\nhome-grown btree. I wrote a home-grown btree that ended up becoming\\nsrc/backend/utils/mmgr/freepage.c and it took me a long time to get\\nrid of all the bugs. Heikki is almost certainly better at coding up a\\nbug-free btree than I am, but a segmented array is a dead simple data\\nstructure, or should be if done properly, and a btree is not.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\",\n \"msg_date\": \"Tue, 17 Jul 2018 13:30:15 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n },\n {\n \"msg_contents\": \"On Mon, Jul 16, 2018 at 02:33:17PM -0400, Andrew Dunstan wrote:\\n> Ah, ok. Thanks. ignore the email I just sent about that.\\n\\nSo... This thread has basically died of inactivity, while there have\\nbeen a couple of interesting things discussed, like the version from\\nHeikki here:\\nhttps://www.postgresql.org/message-id/cd8f7b62-17e1-4307-9f81-427922e5a1f6@iki.fi\\n\\nI am marking the patches as returned with feedback for now.\\n--\\nMichael\",\n \"msg_date\": \"Tue, 2 Oct 2018 10:43:03 +0900\",\n \"msg_from\": \"Michael Paquier <michael@paquier.xyz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Vacuum: allow usage of more than 1GB of work mem\"\n }\n]","isConversational":false}}},{"rowIdx":43083,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi,\n\nupdating master from be7f7ee..39b691f, the following assertion is\ntriggered frequently by sqlsmith:\n\nTRAP: BadArgument(\"!(((context) != ((void *)0) && (((((const Node*)((context)))->type) == T_AllocSetContext))))\", File: \"mcxt.c\", Line: 1010)\n\nDigging in the coredumps, it looks like set_var_from_num() is invoked on\nan uninitialized NumericVar. Sample gdb session below.\n\nBelow is also one of the generated queries that eventually triggers it\nfor me when invoked a dozen times or so.\n\nregards,\nAndreas\n\n--8<---------------cut here---------------start------------->8---\nselect\n subq_0.c0 as c0,\n subq_0.c0 as c1,\n 5 as c2,\n (select pg_catalog.min(class) from public.f_star)\n as c3\nfrom\n (select\n sample_2.cc as c0\n from\n public.shoelace_arrive as ref_0\n inner join public.hub as sample_1\n right join public.e_star as sample_2\n on (sample_1.name = sample_2.class )\n on (ref_0.arr_name = sample_2.class )\n limit 63) as subq_0\nwhere ((subq_0.c0 is not NULL)\n and ((select pg_catalog.var_pop(enumsortorder) from pg_catalog.pg_enum)\n is not NULL))\n and (((select pg_catalog.var_samp(random) from public.bt_txt_heap)\n is NULL)\n or ((select m from public.money_data limit 1 offset 1)\n <> (select pg_catalog.min(salary) from public.rtest_empmass)\n ));\n--8<---------------cut here---------------end--------------->8---\n\n(gdb) bt\n#0 0x00007ff011f221c8 in __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:54\n#1 0x00007ff011f2364a in __GI_abort () at abort.c:89\n#2 0x00000000007ef1b1 in ExceptionalCondition (conditionName=conditionName@entry=0x9d26c8 \"!(((context) != ((void *)0) && (((((const Node*)((context)))->type) == T_AllocSetContext))))\", errorType=errorType@entry=0x835c25 \"BadArgument\", fileName=fileName@entry=0x9d2640 \"mcxt.c\", lineNumber=lineNumber@entry=1010) at assert.c:54\n#3 0x0000000000813561 in pfree (pointer=<optimized out>) at mcxt.c:1010\n#4 0x0000000000773169 in alloc_var (var=var@entry=0x7ffe3a6d18d0, ndigits=ndigits@entry=6) at numeric.c:5387\n#5 0x0000000000774230 in set_var_from_num (num=0x1e49180, dest=0x7ffe3a6d18d0) at numeric.c:5608\n#6 0x000000000077be2c in numeric_poly_deserialize (fcinfo=<optimized out>) at numeric.c:4196\n#7 0x00000000005ec48c in combine_aggregates (aggstate=0x1e255d8, pergroup=<optimized out>) at nodeAgg.c:986\n#8 0x00000000005edcc5 in agg_retrieve_direct (aggstate=0x1e255d8) at nodeAgg.c:2095\n#9 ExecAgg (node=node@entry=0x1e255d8) at nodeAgg.c:1837\n#10 0x00000000005e0078 in ExecProcNode (node=node@entry=0x1e255d8) at execProcnode.c:503\n#11 0x000000000060173c in ExecSetParamPlan (node=<optimized out>, econtext=0x1e2e710) at nodeSubplan.c:995\n#12 0x00000000005e4f75 in ExecEvalParamExec (exprstate=<optimized out>, econtext=<optimized out>, isNull=0x7ffe3a6d1b3f \"\", isDone=<optimized out>) at execQual.c:1140\n#13 0x00000000005e14c6 in ExecEvalNullTest (nstate=0x1e2ec50, econtext=0x1e2e710, isNull=0x7ffe3a6d1b3f \"\", isDone=0x0) at execQual.c:3902\n#14 0x00000000005e0656 in ExecEvalOr (orExpr=<optimized out>, econtext=0x1e2e710, isNull=0x7ffe3a6d1b3f \"\", isDone=<optimized out>) at execQual.c:2809\n#15 0x00000000005e7089 in ExecQual (qual=<optimized out>, econtext=econtext@entry=0x1e2e710, resultForNull=resultForNull@entry=0 '\\000') at execQual.c:5379\n#16 0x00000000005fd6b1 in ExecResult (node=node@entry=0x1e2e5f8) at nodeResult.c:82\n#17 0x00000000005e01f8 in ExecProcNode (node=node@entry=0x1e2e5f8) at execProcnode.c:392\n#18 0x00000000005dc27e in ExecutePlan (dest=0x7ff0129e22b0, direction=<optimized out>, numberTuples=0, sendTuples=<optimized out>, operation=CMD_SELECT, use_parallel_mode=<optimized out>, planstate=0x1e2e5f8, estate=0x1e1aba8) at execMain.c:1567\n#19 standard_ExecutorRun (queryDesc=0x1d563b8, direction=<optimized out>, count=0) at execMain.c:338\n#20 0x00000000006faad8 in PortalRunSelect (portal=portal@entry=0x1def878, forward=forward@entry=1 '\\001', count=0, count@entry=9223372036854775807, dest=dest@entry=0x7ff0129e22b0) at pquery.c:948\n#21 0x00000000006fc04e in PortalRun (portal=portal@entry=0x1def878, count=count@entry=9223372036854775807, isTopLevel=isTopLevel@entry=1 '\\001', dest=dest@entry=0x7ff0129e22b0, altdest=altdest@entry=0x7ff0129e22b0, completionTag=completionTag@entry=0x7ffe3a6d1fa0 \"\") at pquery.c:789\n#22 0x00000000006f8deb in exec_simple_query (query_string=0x1dc2e58 \"select \\n subq_0.c0 as c0, \\n subq_0.c0 as c1, \\n 5 as c2, \\n (select pg_catalog.min(class) from public.f_star)\\n as c3\\nfrom \\n (select \\n sample_2.cc as c0\\n from \\n public.shoel\"...) at postgres.c:1094\n#23 PostgresMain (argc=<optimized out>, argv=argv@entry=0x1d64730, dbname=0x1d64590 \"regression\", username=<optimized out>) at postgres.c:4070\n#24 0x000000000046cf81 in BackendRun (port=0x1d4ffd0) at postmaster.c:4260\n#25 BackendStartup (port=0x1d4ffd0) at postmaster.c:3934\n#26 ServerLoop () at postmaster.c:1691\n#27 0x0000000000693634 in PostmasterMain (argc=argc@entry=3, argv=argv@entry=0x1d2c5d0) at postmaster.c:1299\n#28 0x000000000046e0d6 in main (argc=3, argv=0x1d2c5d0) at main.c:228\n(gdb) frame 5\n#5 0x0000000000774230 in set_var_from_num (num=0x1e49180, dest=0x7ffe3a6d18d0) at numeric.c:5608\n(gdb) p *dest\n$14 = {ndigits = 30883864, weight = 0, sign = 31626200, dscale = 0, buf = 0x1e2a3f0, digits = 0x0}\n(gdb) \n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 03 Sep 2016 15:19:49 +0200","msg_from":"Andreas Seltenreich <seltenreich@gmx.de>","msg_from_op":true,"msg_subject":"[sqlsmith] Failed assertion in numeric aggregate"},{"msg_contents":"Andreas Seltenreich <seltenreich@gmx.de> writes:\n> Digging in the coredumps, it looks like set_var_from_num() is invoked on\n> an uninitialized NumericVar. Sample gdb session below.\n\nHm, yeah, looks like numeric_poly_deserialize is missing a required\ninit_var() step. Slightly astonishing that this got through even\nminimal testing.\n\nFor the archives' sake: I could not reproduce this at default settings,\nbecause the aggregate calls don't get parallelized. But it fails fairly\nquickly with\nset parallel_tuple_cost = 0;\nset parallel_setup_cost = 0;\nset min_parallel_relation_size = 0;\n\nThanks for the report!\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 03 Sep 2016 13:59:32 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: [sqlsmith] Failed assertion in numeric aggregate"},{"msg_contents":"On 09/03/2016 08:59 PM, Tom Lane wrote:\n> Andreas Seltenreich <seltenreich@gmx.de> writes:\n>> Digging in the coredumps, it looks like set_var_from_num() is invoked on\n>> an uninitialized NumericVar. Sample gdb session below.\n>\n> Hm, yeah, looks like numeric_poly_deserialize is missing a required\n> init_var() step. Slightly astonishing that this got through even\n> minimal testing.\n>\n> For the archives' sake: I could not reproduce this at default settings,\n> because the aggregate calls don't get parallelized. But it fails fairly\n> quickly with\n> set parallel_tuple_cost = 0;\n> set parallel_setup_cost = 0;\n> set min_parallel_relation_size = 0;\n>\n> Thanks for the report!\n\nThanks for fixing this so quickly. For the record, I did test \nparallelization at one point, but maybe it was with an older patch \nversion or I screwed up something in the tests - otherwise I clearly \nwould've hit that.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 4 Sep 2016 15:12:31 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: [sqlsmith] Failed assertion in numeric aggregate"}],"string":"[\n {\n \"msg_contents\": \"Hi,\\n\\nupdating master from be7f7ee..39b691f, the following assertion is\\ntriggered frequently by sqlsmith:\\n\\nTRAP: BadArgument(\\\"!(((context) != ((void *)0) && (((((const Node*)((context)))->type) == T_AllocSetContext))))\\\", File: \\\"mcxt.c\\\", Line: 1010)\\n\\nDigging in the coredumps, it looks like set_var_from_num() is invoked on\\nan uninitialized NumericVar. Sample gdb session below.\\n\\nBelow is also one of the generated queries that eventually triggers it\\nfor me when invoked a dozen times or so.\\n\\nregards,\\nAndreas\\n\\n--8<---------------cut here---------------start------------->8---\\nselect\\n subq_0.c0 as c0,\\n subq_0.c0 as c1,\\n 5 as c2,\\n (select pg_catalog.min(class) from public.f_star)\\n as c3\\nfrom\\n (select\\n sample_2.cc as c0\\n from\\n public.shoelace_arrive as ref_0\\n inner join public.hub as sample_1\\n right join public.e_star as sample_2\\n on (sample_1.name = sample_2.class )\\n on (ref_0.arr_name = sample_2.class )\\n limit 63) as subq_0\\nwhere ((subq_0.c0 is not NULL)\\n and ((select pg_catalog.var_pop(enumsortorder) from pg_catalog.pg_enum)\\n is not NULL))\\n and (((select pg_catalog.var_samp(random) from public.bt_txt_heap)\\n is NULL)\\n or ((select m from public.money_data limit 1 offset 1)\\n <> (select pg_catalog.min(salary) from public.rtest_empmass)\\n ));\\n--8<---------------cut here---------------end--------------->8---\\n\\n(gdb) bt\\n#0 0x00007ff011f221c8 in __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:54\\n#1 0x00007ff011f2364a in __GI_abort () at abort.c:89\\n#2 0x00000000007ef1b1 in ExceptionalCondition (conditionName=conditionName@entry=0x9d26c8 \\\"!(((context) != ((void *)0) && (((((const Node*)((context)))->type) == T_AllocSetContext))))\\\", errorType=errorType@entry=0x835c25 \\\"BadArgument\\\", fileName=fileName@entry=0x9d2640 \\\"mcxt.c\\\", lineNumber=lineNumber@entry=1010) at assert.c:54\\n#3 0x0000000000813561 in pfree (pointer=<optimized out>) at mcxt.c:1010\\n#4 0x0000000000773169 in alloc_var (var=var@entry=0x7ffe3a6d18d0, ndigits=ndigits@entry=6) at numeric.c:5387\\n#5 0x0000000000774230 in set_var_from_num (num=0x1e49180, dest=0x7ffe3a6d18d0) at numeric.c:5608\\n#6 0x000000000077be2c in numeric_poly_deserialize (fcinfo=<optimized out>) at numeric.c:4196\\n#7 0x00000000005ec48c in combine_aggregates (aggstate=0x1e255d8, pergroup=<optimized out>) at nodeAgg.c:986\\n#8 0x00000000005edcc5 in agg_retrieve_direct (aggstate=0x1e255d8) at nodeAgg.c:2095\\n#9 ExecAgg (node=node@entry=0x1e255d8) at nodeAgg.c:1837\\n#10 0x00000000005e0078 in ExecProcNode (node=node@entry=0x1e255d8) at execProcnode.c:503\\n#11 0x000000000060173c in ExecSetParamPlan (node=<optimized out>, econtext=0x1e2e710) at nodeSubplan.c:995\\n#12 0x00000000005e4f75 in ExecEvalParamExec (exprstate=<optimized out>, econtext=<optimized out>, isNull=0x7ffe3a6d1b3f \\\"\\\", isDone=<optimized out>) at execQual.c:1140\\n#13 0x00000000005e14c6 in ExecEvalNullTest (nstate=0x1e2ec50, econtext=0x1e2e710, isNull=0x7ffe3a6d1b3f \\\"\\\", isDone=0x0) at execQual.c:3902\\n#14 0x00000000005e0656 in ExecEvalOr (orExpr=<optimized out>, econtext=0x1e2e710, isNull=0x7ffe3a6d1b3f \\\"\\\", isDone=<optimized out>) at execQual.c:2809\\n#15 0x00000000005e7089 in ExecQual (qual=<optimized out>, econtext=econtext@entry=0x1e2e710, resultForNull=resultForNull@entry=0 '\\\\000') at execQual.c:5379\\n#16 0x00000000005fd6b1 in ExecResult (node=node@entry=0x1e2e5f8) at nodeResult.c:82\\n#17 0x00000000005e01f8 in ExecProcNode (node=node@entry=0x1e2e5f8) at execProcnode.c:392\\n#18 0x00000000005dc27e in ExecutePlan (dest=0x7ff0129e22b0, direction=<optimized out>, numberTuples=0, sendTuples=<optimized out>, operation=CMD_SELECT, use_parallel_mode=<optimized out>, planstate=0x1e2e5f8, estate=0x1e1aba8) at execMain.c:1567\\n#19 standard_ExecutorRun (queryDesc=0x1d563b8, direction=<optimized out>, count=0) at execMain.c:338\\n#20 0x00000000006faad8 in PortalRunSelect (portal=portal@entry=0x1def878, forward=forward@entry=1 '\\\\001', count=0, count@entry=9223372036854775807, dest=dest@entry=0x7ff0129e22b0) at pquery.c:948\\n#21 0x00000000006fc04e in PortalRun (portal=portal@entry=0x1def878, count=count@entry=9223372036854775807, isTopLevel=isTopLevel@entry=1 '\\\\001', dest=dest@entry=0x7ff0129e22b0, altdest=altdest@entry=0x7ff0129e22b0, completionTag=completionTag@entry=0x7ffe3a6d1fa0 \\\"\\\") at pquery.c:789\\n#22 0x00000000006f8deb in exec_simple_query (query_string=0x1dc2e58 \\\"select \\\\n subq_0.c0 as c0, \\\\n subq_0.c0 as c1, \\\\n 5 as c2, \\\\n (select pg_catalog.min(class) from public.f_star)\\\\n as c3\\\\nfrom \\\\n (select \\\\n sample_2.cc as c0\\\\n from \\\\n public.shoel\\\"...) at postgres.c:1094\\n#23 PostgresMain (argc=<optimized out>, argv=argv@entry=0x1d64730, dbname=0x1d64590 \\\"regression\\\", username=<optimized out>) at postgres.c:4070\\n#24 0x000000000046cf81 in BackendRun (port=0x1d4ffd0) at postmaster.c:4260\\n#25 BackendStartup (port=0x1d4ffd0) at postmaster.c:3934\\n#26 ServerLoop () at postmaster.c:1691\\n#27 0x0000000000693634 in PostmasterMain (argc=argc@entry=3, argv=argv@entry=0x1d2c5d0) at postmaster.c:1299\\n#28 0x000000000046e0d6 in main (argc=3, argv=0x1d2c5d0) at main.c:228\\n(gdb) frame 5\\n#5 0x0000000000774230 in set_var_from_num (num=0x1e49180, dest=0x7ffe3a6d18d0) at numeric.c:5608\\n(gdb) p *dest\\n$14 = {ndigits = 30883864, weight = 0, sign = 31626200, dscale = 0, buf = 0x1e2a3f0, digits = 0x0}\\n(gdb) \\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 03 Sep 2016 15:19:49 +0200\",\n \"msg_from\": \"Andreas Seltenreich <seltenreich@gmx.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"[sqlsmith] Failed assertion in numeric aggregate\"\n },\n {\n \"msg_contents\": \"Andreas Seltenreich <seltenreich@gmx.de> writes:\\n> Digging in the coredumps, it looks like set_var_from_num() is invoked on\\n> an uninitialized NumericVar. Sample gdb session below.\\n\\nHm, yeah, looks like numeric_poly_deserialize is missing a required\\ninit_var() step. Slightly astonishing that this got through even\\nminimal testing.\\n\\nFor the archives' sake: I could not reproduce this at default settings,\\nbecause the aggregate calls don't get parallelized. But it fails fairly\\nquickly with\\nset parallel_tuple_cost = 0;\\nset parallel_setup_cost = 0;\\nset min_parallel_relation_size = 0;\\n\\nThanks for the report!\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 03 Sep 2016 13:59:32 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [sqlsmith] Failed assertion in numeric aggregate\"\n },\n {\n \"msg_contents\": \"On 09/03/2016 08:59 PM, Tom Lane wrote:\\n> Andreas Seltenreich <seltenreich@gmx.de> writes:\\n>> Digging in the coredumps, it looks like set_var_from_num() is invoked on\\n>> an uninitialized NumericVar. Sample gdb session below.\\n>\\n> Hm, yeah, looks like numeric_poly_deserialize is missing a required\\n> init_var() step. Slightly astonishing that this got through even\\n> minimal testing.\\n>\\n> For the archives' sake: I could not reproduce this at default settings,\\n> because the aggregate calls don't get parallelized. But it fails fairly\\n> quickly with\\n> set parallel_tuple_cost = 0;\\n> set parallel_setup_cost = 0;\\n> set min_parallel_relation_size = 0;\\n>\\n> Thanks for the report!\\n\\nThanks for fixing this so quickly. For the record, I did test \\nparallelization at one point, but maybe it was with an older patch \\nversion or I screwed up something in the tests - otherwise I clearly \\nwould've hit that.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 4 Sep 2016 15:12:31 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [sqlsmith] Failed assertion in numeric aggregate\"\n }\n]","isConversational":false}}},{"rowIdx":43084,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"One thing that has been irking me ever since I came to PostgreSQL is the\nfact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\nuse the long version in scripts and such as extra documentation, and\nI've never been able to with these. What's more, I keep forgetting that\n--wait (and --no-wait) aren't a thing.\n\nTrivial patch attached.\n-- \nVik Fearing +33 6 46 75 15 36\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Sat, 3 Sep 2016 22:57:08 +0200","msg_from":"Vik Fearing <vik@2ndquadrant.fr>","msg_from_op":true,"msg_subject":"Long options for pg_ctl waiting"},{"msg_contents":"On Sun, Sep 4, 2016 at 5:57 AM, Vik Fearing <vik@2ndquadrant.fr> wrote:\n> One thing that has been irking me ever since I came to PostgreSQL is the\n> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\n> use the long version in scripts and such as extra documentation, and\n> I've never been able to with these. What's more, I keep forgetting that\n> --wait (and --no-wait) aren't a thing.\n>\n> Trivial patch attached.\n\nNit: Like --nosync we could use --nowait, without an hyphen.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 4 Sep 2016 08:13:59 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On Sat, Sep 3, 2016 at 7:13 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> On Sun, Sep 4, 2016 at 5:57 AM, Vik Fearing <vik@2ndquadrant.fr> wrote:\n>> One thing that has been irking me ever since I came to PostgreSQL is the\n>> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\n>> use the long version in scripts and such as extra documentation, and\n>> I've never been able to with these. What's more, I keep forgetting that\n>> --wait (and --no-wait) aren't a thing.\n>>\n>> Trivial patch attached.\n>\n> Nit: Like --nosync we could use --nowait, without an hyphen.\n\nBut is that actually better? I think that the idea of omitting the\ndash here is one of those things that sounds good at first, and then\nlater you realize that it was actually a dumb idea all along. If\nsomebody has an option for --body or --on or --table and has to negate\nit by running --nobody or --noon or --notable, some confusion may\nresult, because in each case you get a word that is not really the\nlogical inverse of the original option. Also, if you end up with any\nmulti-word options, like --save-backup-files, then users wonder why\nthe opposite, --nosave-backup-files, has a dash between words 2 and 3\nand between words 3 and 4, but not between words 1 and 2. I suggest\nwe'd do better to standardize on always including a dash in such\ncases.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 15:31:13 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On 08/09/16 07:31, Robert Haas wrote:\n> On Sat, Sep 3, 2016 at 7:13 PM, Michael Paquier\n> <michael.paquier@gmail.com> wrote:\n>> On Sun, Sep 4, 2016 at 5:57 AM, Vik Fearing <vik@2ndquadrant.fr> wrote:\n>>> One thing that has been irking me ever since I came to PostgreSQL is the\n>>> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\n>>> use the long version in scripts and such as extra documentation, and\n>>> I've never been able to with these. What's more, I keep forgetting that\n>>> --wait (and --no-wait) aren't a thing.\n>>>\n>>> Trivial patch attached.\n>> Nit: Like --nosync we could use --nowait, without an hyphen.\n> But is that actually better? I think that the idea of omitting the\n> dash here is one of those things that sounds good at first, and then\n> later you realize that it was actually a dumb idea all along. If\n> somebody has an option for --body or --on or --table and has to negate\n> it by running --nobody or --noon or --notable, some confusion may\n> result, because in each case you get a word that is not really the\n> logical inverse of the original option. Also, if you end up with any\n> multi-word options, like --save-backup-files, then users wonder why\n> the opposite, --nosave-backup-files, has a dash between words 2 and 3\n> and between words 3 and 4, but not between words 1 and 2. I suggest\n> we'd do better to standardize on always including a dash in such\n> cases.\n>\n+1\n\npossibly '--nosync' (& any similar) should have a '--no-sync' variation \nadded, with the '--nosync' variation documented as depreciated?\n\n\nCheers,\nGavin\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 07:38:28 +1200","msg_from":"Gavin Flower <GavinFlower@archidevsys.co.nz>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"Gavin Flower wrote:\n\n> possibly '--nosync' (& any similar) should have a '--no-sync' variation\n> added, with the '--nosync' variation documented as depreciated?\n\nI agree -- I would go as far as just documenting --no-sync only and\nkeeping the --nosync one working with minimal (if any) visibility in\ndocs.\n\n-- \n�lvaro Herrera http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 17:41:57 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\n> Gavin Flower wrote:\n> \n>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\n>> added, with the '--nosync' variation documented as depreciated?\n> \n> I agree -- I would go as far as just documenting --no-sync only and\n> keeping the --nosync one working with minimal (if any) visibility in\n> docs.\n\nOkay, here's a patch to do that. I don't think it's the other patch's\njob to do it.\n\nI also changed --noclean to --no-clean, and --no-locale was already correct.\n-- \nVik Fearing +33 6 46 75 15 36\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 7 Sep 2016 23:08:05 +0200","msg_from":"Vik Fearing <vik@2ndquadrant.fr>","msg_from_op":true,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On 08/09/16 09:08, Vik Fearing wrote:\n> On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\n>> Gavin Flower wrote:\n>>\n>>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\n>>> added, with the '--nosync' variation documented as depreciated?\n>> I agree -- I would go as far as just documenting --no-sync only and\n>> keeping the --nosync one working with minimal (if any) visibility in\n>> docs.\n> Okay, here's a patch to do that. I don't think it's the other patch's\n> job to do it.\n>\n> I also changed --noclean to --no-clean, and --no-locale was already correct.\n\nSuggest a comment along the lines \"Where flags of the form --xxx have a \nnegated form, then the preferred negated form is --no-xxx - and that any \nexisting use of the form --noxxx should be converted to --no-xxx, as the \nnon hyphenated form is now deprecated & will be removed in a future \nversion of Postgres.\"\n\nPossibly generate warningswhen the non hyphenated form is used?\n\nCheers,\nGavin\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 09:39:19 +1200","msg_from":"Gavin Flower <GavinFlower@archidevsys.co.nz>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On 09/07/2016 11:39 PM, Gavin Flower wrote:\n> On 08/09/16 09:08, Vik Fearing wrote:\n>> On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\n>>> Gavin Flower wrote:\n>>>\n>>>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\n>>>> added, with the '--nosync' variation documented as depreciated?\n>>> I agree -- I would go as far as just documenting --no-sync only and\n>>> keeping the --nosync one working with minimal (if any) visibility in\n>>> docs.\n>> Okay, here's a patch to do that. I don't think it's the other patch's\n>> job to do it.\n>>\n>> I also changed --noclean to --no-clean, and --no-locale was already\n>> correct.\n> \n> Suggest a comment along the lines \"Where flags of the form --xxx have a\n> negated form, then the preferred negated form is --no-xxx - and that any\n> existing use of the form --noxxx should be converted to --no-xxx, as the\n> non hyphenated form is now deprecated & will be removed in a future\n> version of Postgres.\"\n\nI have verified that these are the only two options anywhere in the tree\nthat start with \"no\" and not \"no-\" so it should be pretty easy for\nfuture options to conform on their own. I don't see adding a comment\nlike this to every long option definition block to be very helpful, and\nonly adding it to initdb is just weird. So I don't see the need for it.\n\n> Possibly generate warningswhen the non hyphenated form is used?\n\nI'm not quite sure how I got volunteered to do this work, but it's easy\nenough so I don't mind.\n\nHere is a new patch that emits a warning when --noclean and/or --nosync\nare used.\n-- \nVik Fearing +33 6 46 75 15 36\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 8 Sep 2016 00:57:15 +0200","msg_from":"Vik Fearing <vik@2ndquadrant.fr>","msg_from_op":true,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"Vik Fearing <vik@2ndquadrant.fr> writes:\n> On 09/07/2016 11:39 PM, Gavin Flower wrote:\n>> Possibly generate warningswhen the non hyphenated form is used?\n\n> I'm not quite sure how I got volunteered to do this work, but it's easy\n> enough so I don't mind.\n> Here is a new patch that emits a warning when --noclean and/or --nosync\n> are used.\n\nI'm pretty much -1 on printing a warning. There's no ambiguity, and no\nreal reason for us ever to remove the old spellings. Standardizing on\n\"no-\" going forward makes sense, but let's not slap people's wrists for\nexisting usage. (Or: if it ain't broke, don't break it.)\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 07 Sep 2016 19:05:49 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On 09/08/2016 01:05 AM, Tom Lane wrote:\n> Vik Fearing <vik@2ndquadrant.fr> writes:\n>> On 09/07/2016 11:39 PM, Gavin Flower wrote:\n>>> Possibly generate warningswhen the non hyphenated form is used?\n> \n>> I'm not quite sure how I got volunteered to do this work, but it's easy\n>> enough so I don't mind.\n>> Here is a new patch that emits a warning when --noclean and/or --nosync\n>> are used.\n> \n> I'm pretty much -1 on printing a warning. There's no ambiguity, and no\n> real reason for us ever to remove the old spellings. Standardizing on\n> \"no-\" going forward makes sense, but let's not slap people's wrists for\n> existing usage. (Or: if it ain't broke, don't break it.)\n\nOne could also argue that 2 out of 53 \"no\" options omitting the dash is\nin fact broken, and a real reason to remove them.\n\nI don't see the warning as \"slapping wrists\" so much as saying that\nwe're harmonizing our conventions and their scripts need to be updated\nfor the better.\n\nThat said, I'm not going to fight for this. My only goal here is to get\n--wait and --no-wait added to pg_ctl.\n-- \nVik Fearing +33 6 46 75 15 36\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 01:46:03 +0200","msg_from":"Vik Fearing <vik@2ndquadrant.fr>","msg_from_op":true,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"Vik Fearing <vik@2ndquadrant.fr> writes:\n> On 09/08/2016 01:05 AM, Tom Lane wrote:\n>> I'm pretty much -1 on printing a warning. There's no ambiguity, and no\n>> real reason for us ever to remove the old spellings. Standardizing on\n>> \"no-\" going forward makes sense, but let's not slap people's wrists for\n>> existing usage. (Or: if it ain't broke, don't break it.)\n\n> One could also argue that 2 out of 53 \"no\" options omitting the dash is\n> in fact broken, and a real reason to remove them.\n\nI do not buy that. As a counter argument, consider that removing them\nwould make it impossible to write a script that works with both old\nand new versions of PG. That's a mighty high price to pay for what\nis little more than pedantry.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 07 Sep 2016 19:56:31 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On Thu, Sep 8, 2016 at 5:41 AM, Alvaro Herrera <alvherre@2ndquadrant.com> wrote:\n> Gavin Flower wrote:\n>\n>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\n>> added, with the '--nosync' variation documented as depreciated?\n>\n> I agree -- I would go as far as just documenting --no-sync only and\n> keeping the --nosync one working with minimal (if any) visibility in\n> docs.\n\nKeeping no visibility at all in the docs, with an alias in the\nbinaries sounds fine to me if we want to standardize a bit more\nthings.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 09:00:13 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On Thu, Sep 8, 2016 at 8:56 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> Vik Fearing <vik@2ndquadrant.fr> writes:\n>> On 09/08/2016 01:05 AM, Tom Lane wrote:\n>>> I'm pretty much -1 on printing a warning. There's no ambiguity, and no\n>>> real reason for us ever to remove the old spellings. Standardizing on\n>>> \"no-\" going forward makes sense, but let's not slap people's wrists for\n>>> existing usage. (Or: if it ain't broke, don't break it.)\n>\n>> One could also argue that 2 out of 53 \"no\" options omitting the dash is\n>> in fact broken, and a real reason to remove them.\n>\n> I do not buy that. As a counter argument, consider that removing them\n> would make it impossible to write a script that works with both old\n> and new versions of PG. That's a mighty high price to pay for what\n> is little more than pedantry.\n\nPerhaps discussing that on another thread would be better, and I was\nthe one who began this thing... So I'll do it.\n\nVik's stuff is just to add a --no-wait and --wait long option alias on\npg_ctl. And that clearly improves the readability for users, so that's\na +1 from here. And let's just use the v1 presented at the beginning\nof this thread. I agree with the feeling that standardizing things\nwould be better btw for such option names.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 09:05:45 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On 9/3/16 4:57 PM, Vik Fearing wrote:\n> One thing that has been irking me ever since I came to PostgreSQL is the\n> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\n> use the long version in scripts and such as extra documentation, and\n> I've never been able to with these. What's more, I keep forgetting that\n> --wait (and --no-wait) aren't a thing.\n\ncommitted\n\n-- \nPeter Eisentraut http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 19 Oct 2016 08:50:45 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"},{"msg_contents":"On 9/7/16 5:08 PM, Vik Fearing wrote:\n> On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\n>> Gavin Flower wrote:\n>>\n>>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\n>>> added, with the '--nosync' variation documented as depreciated?\n>>\n>> I agree -- I would go as far as just documenting --no-sync only and\n>> keeping the --nosync one working with minimal (if any) visibility in\n>> docs.\n> \n> Okay, here's a patch to do that. I don't think it's the other patch's\n> job to do it.\n> \n> I also changed --noclean to --no-clean, and --no-locale was already correct.\n\ncommitted\n\n-- \nPeter Eisentraut http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 19 Oct 2016 08:51:10 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Long options for pg_ctl waiting"}],"string":"[\n {\n \"msg_contents\": \"One thing that has been irking me ever since I came to PostgreSQL is the\\nfact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\\nuse the long version in scripts and such as extra documentation, and\\nI've never been able to with these. What's more, I keep forgetting that\\n--wait (and --no-wait) aren't a thing.\\n\\nTrivial patch attached.\\n-- \\nVik Fearing +33 6 46 75 15 36\\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sat, 3 Sep 2016 22:57:08 +0200\",\n \"msg_from\": \"Vik Fearing <vik@2ndquadrant.fr>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 4, 2016 at 5:57 AM, Vik Fearing <vik@2ndquadrant.fr> wrote:\\n> One thing that has been irking me ever since I came to PostgreSQL is the\\n> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\\n> use the long version in scripts and such as extra documentation, and\\n> I've never been able to with these. What's more, I keep forgetting that\\n> --wait (and --no-wait) aren't a thing.\\n>\\n> Trivial patch attached.\\n\\nNit: Like --nosync we could use --nowait, without an hyphen.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 4 Sep 2016 08:13:59 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On Sat, Sep 3, 2016 at 7:13 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> On Sun, Sep 4, 2016 at 5:57 AM, Vik Fearing <vik@2ndquadrant.fr> wrote:\\n>> One thing that has been irking me ever since I came to PostgreSQL is the\\n>> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\\n>> use the long version in scripts and such as extra documentation, and\\n>> I've never been able to with these. What's more, I keep forgetting that\\n>> --wait (and --no-wait) aren't a thing.\\n>>\\n>> Trivial patch attached.\\n>\\n> Nit: Like --nosync we could use --nowait, without an hyphen.\\n\\nBut is that actually better? I think that the idea of omitting the\\ndash here is one of those things that sounds good at first, and then\\nlater you realize that it was actually a dumb idea all along. If\\nsomebody has an option for --body or --on or --table and has to negate\\nit by running --nobody or --noon or --notable, some confusion may\\nresult, because in each case you get a word that is not really the\\nlogical inverse of the original option. Also, if you end up with any\\nmulti-word options, like --save-backup-files, then users wonder why\\nthe opposite, --nosave-backup-files, has a dash between words 2 and 3\\nand between words 3 and 4, but not between words 1 and 2. I suggest\\nwe'd do better to standardize on always including a dash in such\\ncases.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 15:31:13 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On 08/09/16 07:31, Robert Haas wrote:\\n> On Sat, Sep 3, 2016 at 7:13 PM, Michael Paquier\\n> <michael.paquier@gmail.com> wrote:\\n>> On Sun, Sep 4, 2016 at 5:57 AM, Vik Fearing <vik@2ndquadrant.fr> wrote:\\n>>> One thing that has been irking me ever since I came to PostgreSQL is the\\n>>> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\\n>>> use the long version in scripts and such as extra documentation, and\\n>>> I've never been able to with these. What's more, I keep forgetting that\\n>>> --wait (and --no-wait) aren't a thing.\\n>>>\\n>>> Trivial patch attached.\\n>> Nit: Like --nosync we could use --nowait, without an hyphen.\\n> But is that actually better? I think that the idea of omitting the\\n> dash here is one of those things that sounds good at first, and then\\n> later you realize that it was actually a dumb idea all along. If\\n> somebody has an option for --body or --on or --table and has to negate\\n> it by running --nobody or --noon or --notable, some confusion may\\n> result, because in each case you get a word that is not really the\\n> logical inverse of the original option. Also, if you end up with any\\n> multi-word options, like --save-backup-files, then users wonder why\\n> the opposite, --nosave-backup-files, has a dash between words 2 and 3\\n> and between words 3 and 4, but not between words 1 and 2. I suggest\\n> we'd do better to standardize on always including a dash in such\\n> cases.\\n>\\n+1\\n\\npossibly '--nosync' (& any similar) should have a '--no-sync' variation \\nadded, with the '--nosync' variation documented as depreciated?\\n\\n\\nCheers,\\nGavin\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 07:38:28 +1200\",\n \"msg_from\": \"Gavin Flower <GavinFlower@archidevsys.co.nz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"Gavin Flower wrote:\\n\\n> possibly '--nosync' (& any similar) should have a '--no-sync' variation\\n> added, with the '--nosync' variation documented as depreciated?\\n\\nI agree -- I would go as far as just documenting --no-sync only and\\nkeeping the --nosync one working with minimal (if any) visibility in\\ndocs.\\n\\n-- \\n�lvaro Herrera http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 17:41:57 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\\n> Gavin Flower wrote:\\n> \\n>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\\n>> added, with the '--nosync' variation documented as depreciated?\\n> \\n> I agree -- I would go as far as just documenting --no-sync only and\\n> keeping the --nosync one working with minimal (if any) visibility in\\n> docs.\\n\\nOkay, here's a patch to do that. I don't think it's the other patch's\\njob to do it.\\n\\nI also changed --noclean to --no-clean, and --no-locale was already correct.\\n-- \\nVik Fearing +33 6 46 75 15 36\\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 7 Sep 2016 23:08:05 +0200\",\n \"msg_from\": \"Vik Fearing <vik@2ndquadrant.fr>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On 08/09/16 09:08, Vik Fearing wrote:\\n> On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\\n>> Gavin Flower wrote:\\n>>\\n>>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\\n>>> added, with the '--nosync' variation documented as depreciated?\\n>> I agree -- I would go as far as just documenting --no-sync only and\\n>> keeping the --nosync one working with minimal (if any) visibility in\\n>> docs.\\n> Okay, here's a patch to do that. I don't think it's the other patch's\\n> job to do it.\\n>\\n> I also changed --noclean to --no-clean, and --no-locale was already correct.\\n\\nSuggest a comment along the lines \\\"Where flags of the form --xxx have a \\nnegated form, then the preferred negated form is --no-xxx - and that any \\nexisting use of the form --noxxx should be converted to --no-xxx, as the \\nnon hyphenated form is now deprecated & will be removed in a future \\nversion of Postgres.\\\"\\n\\nPossibly generate warningswhen the non hyphenated form is used?\\n\\nCheers,\\nGavin\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 09:39:19 +1200\",\n \"msg_from\": \"Gavin Flower <GavinFlower@archidevsys.co.nz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On 09/07/2016 11:39 PM, Gavin Flower wrote:\\n> On 08/09/16 09:08, Vik Fearing wrote:\\n>> On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\\n>>> Gavin Flower wrote:\\n>>>\\n>>>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\\n>>>> added, with the '--nosync' variation documented as depreciated?\\n>>> I agree -- I would go as far as just documenting --no-sync only and\\n>>> keeping the --nosync one working with minimal (if any) visibility in\\n>>> docs.\\n>> Okay, here's a patch to do that. I don't think it's the other patch's\\n>> job to do it.\\n>>\\n>> I also changed --noclean to --no-clean, and --no-locale was already\\n>> correct.\\n> \\n> Suggest a comment along the lines \\\"Where flags of the form --xxx have a\\n> negated form, then the preferred negated form is --no-xxx - and that any\\n> existing use of the form --noxxx should be converted to --no-xxx, as the\\n> non hyphenated form is now deprecated & will be removed in a future\\n> version of Postgres.\\\"\\n\\nI have verified that these are the only two options anywhere in the tree\\nthat start with \\\"no\\\" and not \\\"no-\\\" so it should be pretty easy for\\nfuture options to conform on their own. I don't see adding a comment\\nlike this to every long option definition block to be very helpful, and\\nonly adding it to initdb is just weird. So I don't see the need for it.\\n\\n> Possibly generate warningswhen the non hyphenated form is used?\\n\\nI'm not quite sure how I got volunteered to do this work, but it's easy\\nenough so I don't mind.\\n\\nHere is a new patch that emits a warning when --noclean and/or --nosync\\nare used.\\n-- \\nVik Fearing +33 6 46 75 15 36\\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 8 Sep 2016 00:57:15 +0200\",\n \"msg_from\": \"Vik Fearing <vik@2ndquadrant.fr>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"Vik Fearing <vik@2ndquadrant.fr> writes:\\n> On 09/07/2016 11:39 PM, Gavin Flower wrote:\\n>> Possibly generate warningswhen the non hyphenated form is used?\\n\\n> I'm not quite sure how I got volunteered to do this work, but it's easy\\n> enough so I don't mind.\\n> Here is a new patch that emits a warning when --noclean and/or --nosync\\n> are used.\\n\\nI'm pretty much -1 on printing a warning. There's no ambiguity, and no\\nreal reason for us ever to remove the old spellings. Standardizing on\\n\\\"no-\\\" going forward makes sense, but let's not slap people's wrists for\\nexisting usage. (Or: if it ain't broke, don't break it.)\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 07 Sep 2016 19:05:49 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On 09/08/2016 01:05 AM, Tom Lane wrote:\\n> Vik Fearing <vik@2ndquadrant.fr> writes:\\n>> On 09/07/2016 11:39 PM, Gavin Flower wrote:\\n>>> Possibly generate warningswhen the non hyphenated form is used?\\n> \\n>> I'm not quite sure how I got volunteered to do this work, but it's easy\\n>> enough so I don't mind.\\n>> Here is a new patch that emits a warning when --noclean and/or --nosync\\n>> are used.\\n> \\n> I'm pretty much -1 on printing a warning. There's no ambiguity, and no\\n> real reason for us ever to remove the old spellings. Standardizing on\\n> \\\"no-\\\" going forward makes sense, but let's not slap people's wrists for\\n> existing usage. (Or: if it ain't broke, don't break it.)\\n\\nOne could also argue that 2 out of 53 \\\"no\\\" options omitting the dash is\\nin fact broken, and a real reason to remove them.\\n\\nI don't see the warning as \\\"slapping wrists\\\" so much as saying that\\nwe're harmonizing our conventions and their scripts need to be updated\\nfor the better.\\n\\nThat said, I'm not going to fight for this. My only goal here is to get\\n--wait and --no-wait added to pg_ctl.\\n-- \\nVik Fearing +33 6 46 75 15 36\\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 01:46:03 +0200\",\n \"msg_from\": \"Vik Fearing <vik@2ndquadrant.fr>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"Vik Fearing <vik@2ndquadrant.fr> writes:\\n> On 09/08/2016 01:05 AM, Tom Lane wrote:\\n>> I'm pretty much -1 on printing a warning. There's no ambiguity, and no\\n>> real reason for us ever to remove the old spellings. Standardizing on\\n>> \\\"no-\\\" going forward makes sense, but let's not slap people's wrists for\\n>> existing usage. (Or: if it ain't broke, don't break it.)\\n\\n> One could also argue that 2 out of 53 \\\"no\\\" options omitting the dash is\\n> in fact broken, and a real reason to remove them.\\n\\nI do not buy that. As a counter argument, consider that removing them\\nwould make it impossible to write a script that works with both old\\nand new versions of PG. That's a mighty high price to pay for what\\nis little more than pedantry.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 07 Sep 2016 19:56:31 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 5:41 AM, Alvaro Herrera <alvherre@2ndquadrant.com> wrote:\\n> Gavin Flower wrote:\\n>\\n>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\\n>> added, with the '--nosync' variation documented as depreciated?\\n>\\n> I agree -- I would go as far as just documenting --no-sync only and\\n> keeping the --nosync one working with minimal (if any) visibility in\\n> docs.\\n\\nKeeping no visibility at all in the docs, with an alias in the\\nbinaries sounds fine to me if we want to standardize a bit more\\nthings.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 09:00:13 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 8:56 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Vik Fearing <vik@2ndquadrant.fr> writes:\\n>> On 09/08/2016 01:05 AM, Tom Lane wrote:\\n>>> I'm pretty much -1 on printing a warning. There's no ambiguity, and no\\n>>> real reason for us ever to remove the old spellings. Standardizing on\\n>>> \\\"no-\\\" going forward makes sense, but let's not slap people's wrists for\\n>>> existing usage. (Or: if it ain't broke, don't break it.)\\n>\\n>> One could also argue that 2 out of 53 \\\"no\\\" options omitting the dash is\\n>> in fact broken, and a real reason to remove them.\\n>\\n> I do not buy that. As a counter argument, consider that removing them\\n> would make it impossible to write a script that works with both old\\n> and new versions of PG. That's a mighty high price to pay for what\\n> is little more than pedantry.\\n\\nPerhaps discussing that on another thread would be better, and I was\\nthe one who began this thing... So I'll do it.\\n\\nVik's stuff is just to add a --no-wait and --wait long option alias on\\npg_ctl. And that clearly improves the readability for users, so that's\\na +1 from here. And let's just use the v1 presented at the beginning\\nof this thread. I agree with the feeling that standardizing things\\nwould be better btw for such option names.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 09:05:45 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On 9/3/16 4:57 PM, Vik Fearing wrote:\\n> One thing that has been irking me ever since I came to PostgreSQL is the\\n> fact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\\n> use the long version in scripts and such as extra documentation, and\\n> I've never been able to with these. What's more, I keep forgetting that\\n> --wait (and --no-wait) aren't a thing.\\n\\ncommitted\\n\\n-- \\nPeter Eisentraut http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 19 Oct 2016 08:50:45 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n },\n {\n \"msg_contents\": \"On 9/7/16 5:08 PM, Vik Fearing wrote:\\n> On 09/07/2016 10:41 PM, Alvaro Herrera wrote:\\n>> Gavin Flower wrote:\\n>>\\n>>> possibly '--nosync' (& any similar) should have a '--no-sync' variation\\n>>> added, with the '--nosync' variation documented as depreciated?\\n>>\\n>> I agree -- I would go as far as just documenting --no-sync only and\\n>> keeping the --nosync one working with minimal (if any) visibility in\\n>> docs.\\n> \\n> Okay, here's a patch to do that. I don't think it's the other patch's\\n> job to do it.\\n> \\n> I also changed --noclean to --no-clean, and --no-locale was already correct.\\n\\ncommitted\\n\\n-- \\nPeter Eisentraut http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 19 Oct 2016 08:51:10 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Long options for pg_ctl waiting\"\n }\n]","isConversational":false}}},{"rowIdx":43085,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi guys,\n\nI'm trying to get my feet wet in PG development, but I ran into a snag\nwith the TODO item I picked. Could someone please tell me if I'm\nmaking an obvious error?\n\nI chose this item from the TODO page: \"[E] Remove warnings created by\n-Wcast-align\". It didn't have a check-mark after the \"[E]\", which I\ntook to mean it's an outstanding issue.\n\nHowever, I'm starting to wonder if it's already been fixed:\n\n(1) I wasn't able to reproduce it. I built PG using:\n * PG source commit 6591f4... (a recent master/HEAD)\n * Ubuntu's patched version of GCC 4.8.4\n * \"-Wcast-align\"\nbut I didn't see anything in the compiler output indicating that the\nwarning got triggered.\n\n(2) It looks like someone else tried to tackle this TODO item about\ntwo years ago, but he also was unable to reproduce it:\nhttps://www.postgresql.org/message-id/flat/CALgh3eseTDT9RspDi0AfhE0j0A3e%2B5XiS3ykQyhK7Z5RgPQTLA%40mail.gmail.com#CALgh3eseTDT9RspDi0AfhE0j0A3e+5XiS3ykQyhK7Z5RgPQTLA@mail.gmail.com\n\nI didn't find any other discussions about that line-item via Google,\nor by looking at the official/unofficial TODO-detail pages.\n\nThanks very much,\nChristian Convey\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 4 Sep 2016 17:22:38 -0400","msg_from":"Christian Convey <christian.convey@gmail.com>","msg_from_op":true,"msg_subject":"Obsolete TODO item \"-Wcast-align\" ?"},{"msg_contents":"Christian Convey <christian.convey@gmail.com> writes:\n> I chose this item from the TODO page: \"[E] Remove warnings created by\n> -Wcast-align\". It didn't have a check-mark after the \"[E]\", which I\n> took to mean it's an outstanding issue.\n> However, I'm starting to wonder if it's already been fixed:\n\nNo, but you only see it on some platforms/compilers. On my OS X laptop\n(clang-based not gcc-based compiler), turning that on generates just a\nhair short of 13000 warnings :-(\n\nI think that TODO item is indeed obsolete, but more in the direction\nof \"we're never gonna do that\". There are too many places where we\ndo need to cast up from generic pointer to specific structure pointer,\nand there doesn't seem to be any practical way to tell a compiler which\ninstances are useful to warn about.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 04 Sep 2016 17:56:09 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Obsolete TODO item \"-Wcast-align\" ?"},{"msg_contents":"On Sun, Sep 4, 2016 at 5:56 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> Christian Convey <christian.convey@gmail.com> writes:\n>> I chose this item from the TODO page: \"[E] Remove warnings created by\n>> -Wcast-align\". It didn't have a check-mark after the \"[E]\", which I\n>> took to mean it's an outstanding issue.\n>> However, I'm starting to wonder if it's already been fixed:\n>\n> No, but you only see it on some platforms/compilers. On my OS X laptop\n> (clang-based not gcc-based compiler), turning that on generates just a\n> hair short of 13000 warnings :-(\n>\n> I think that TODO item is indeed obsolete, but more in the direction\n> of \"we're never gonna do that\". There are too many places where we\n> do need to cast up from generic pointer to specific structure pointer,\n> and there doesn't seem to be any practical way to tell a compiler which\n> instances are useful to warn about.\n\nThanks for the response. I'm unclear about how the TODO list is\ncurated. Is there someone whose attention I should direct to this\nthread?\n\n- Christian\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 4 Sep 2016 18:10:23 -0400","msg_from":"Christian Convey <christian.convey@gmail.com>","msg_from_op":true,"msg_subject":"Re: Obsolete TODO item \"-Wcast-align\" ?"},{"msg_contents":"On 9/4/16 5:10 PM, Christian Convey wrote:\n> Thanks for the response. I'm unclear about how the TODO list is\n> curated. Is there someone whose attention I should direct to this\n> thread?\n\nThere's a number of people that can edit the TODO list. I've removed \nthat item.\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 4 Sep 2016 20:20:32 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":false,"msg_subject":"Re: Obsolete TODO item \"-Wcast-align\" ?"},{"msg_contents":"On Sun, Sep 4, 2016 at 06:10:23PM -0400, Christian Convey wrote:\n> On Sun, Sep 4, 2016 at 5:56 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> > Christian Convey <christian.convey@gmail.com> writes:\n> >> I chose this item from the TODO page: \"[E] Remove warnings created by\n> >> -Wcast-align\". It didn't have a check-mark after the \"[E]\", which I\n> >> took to mean it's an outstanding issue.\n> >> However, I'm starting to wonder if it's already been fixed:\n> >\n> > No, but you only see it on some platforms/compilers. On my OS X laptop\n> > (clang-based not gcc-based compiler), turning that on generates just a\n> > hair short of 13000 warnings :-(\n> >\n> > I think that TODO item is indeed obsolete, but more in the direction\n> > of \"we're never gonna do that\". There are too many places where we\n> > do need to cast up from generic pointer to specific structure pointer,\n> > and there doesn't seem to be any practical way to tell a compiler which\n> > instances are useful to warn about.\n> \n> Thanks for the response. I'm unclear about how the TODO list is\n> curated. Is there someone whose attention I should direct to this\n> thread?\n\nSomeone has removed the item. It is a wiki so anyone can add/remove\nthings.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n+ As you are, so once was I. As I am, so you will be. +\n+ Ancient Roman grave inscription +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 13:00:48 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":false,"msg_subject":"Re: Obsolete TODO item \"-Wcast-align\" ?"}],"string":"[\n {\n \"msg_contents\": \"Hi guys,\\n\\nI'm trying to get my feet wet in PG development, but I ran into a snag\\nwith the TODO item I picked. Could someone please tell me if I'm\\nmaking an obvious error?\\n\\nI chose this item from the TODO page: \\\"[E] Remove warnings created by\\n-Wcast-align\\\". It didn't have a check-mark after the \\\"[E]\\\", which I\\ntook to mean it's an outstanding issue.\\n\\nHowever, I'm starting to wonder if it's already been fixed:\\n\\n(1) I wasn't able to reproduce it. I built PG using:\\n * PG source commit 6591f4... (a recent master/HEAD)\\n * Ubuntu's patched version of GCC 4.8.4\\n * \\\"-Wcast-align\\\"\\nbut I didn't see anything in the compiler output indicating that the\\nwarning got triggered.\\n\\n(2) It looks like someone else tried to tackle this TODO item about\\ntwo years ago, but he also was unable to reproduce it:\\nhttps://www.postgresql.org/message-id/flat/CALgh3eseTDT9RspDi0AfhE0j0A3e%2B5XiS3ykQyhK7Z5RgPQTLA%40mail.gmail.com#CALgh3eseTDT9RspDi0AfhE0j0A3e+5XiS3ykQyhK7Z5RgPQTLA@mail.gmail.com\\n\\nI didn't find any other discussions about that line-item via Google,\\nor by looking at the official/unofficial TODO-detail pages.\\n\\nThanks very much,\\nChristian Convey\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 4 Sep 2016 17:22:38 -0400\",\n \"msg_from\": \"Christian Convey <christian.convey@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Obsolete TODO item \\\"-Wcast-align\\\" ?\"\n },\n {\n \"msg_contents\": \"Christian Convey <christian.convey@gmail.com> writes:\\n> I chose this item from the TODO page: \\\"[E] Remove warnings created by\\n> -Wcast-align\\\". It didn't have a check-mark after the \\\"[E]\\\", which I\\n> took to mean it's an outstanding issue.\\n> However, I'm starting to wonder if it's already been fixed:\\n\\nNo, but you only see it on some platforms/compilers. On my OS X laptop\\n(clang-based not gcc-based compiler), turning that on generates just a\\nhair short of 13000 warnings :-(\\n\\nI think that TODO item is indeed obsolete, but more in the direction\\nof \\\"we're never gonna do that\\\". There are too many places where we\\ndo need to cast up from generic pointer to specific structure pointer,\\nand there doesn't seem to be any practical way to tell a compiler which\\ninstances are useful to warn about.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 04 Sep 2016 17:56:09 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Obsolete TODO item \\\"-Wcast-align\\\" ?\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 4, 2016 at 5:56 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Christian Convey <christian.convey@gmail.com> writes:\\n>> I chose this item from the TODO page: \\\"[E] Remove warnings created by\\n>> -Wcast-align\\\". It didn't have a check-mark after the \\\"[E]\\\", which I\\n>> took to mean it's an outstanding issue.\\n>> However, I'm starting to wonder if it's already been fixed:\\n>\\n> No, but you only see it on some platforms/compilers. On my OS X laptop\\n> (clang-based not gcc-based compiler), turning that on generates just a\\n> hair short of 13000 warnings :-(\\n>\\n> I think that TODO item is indeed obsolete, but more in the direction\\n> of \\\"we're never gonna do that\\\". There are too many places where we\\n> do need to cast up from generic pointer to specific structure pointer,\\n> and there doesn't seem to be any practical way to tell a compiler which\\n> instances are useful to warn about.\\n\\nThanks for the response. I'm unclear about how the TODO list is\\ncurated. Is there someone whose attention I should direct to this\\nthread?\\n\\n- Christian\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 4 Sep 2016 18:10:23 -0400\",\n \"msg_from\": \"Christian Convey <christian.convey@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Obsolete TODO item \\\"-Wcast-align\\\" ?\"\n },\n {\n \"msg_contents\": \"On 9/4/16 5:10 PM, Christian Convey wrote:\\n> Thanks for the response. I'm unclear about how the TODO list is\\n> curated. Is there someone whose attention I should direct to this\\n> thread?\\n\\nThere's a number of people that can edit the TODO list. I've removed \\nthat item.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 4 Sep 2016 20:20:32 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Obsolete TODO item \\\"-Wcast-align\\\" ?\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 4, 2016 at 06:10:23PM -0400, Christian Convey wrote:\\n> On Sun, Sep 4, 2016 at 5:56 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> > Christian Convey <christian.convey@gmail.com> writes:\\n> >> I chose this item from the TODO page: \\\"[E] Remove warnings created by\\n> >> -Wcast-align\\\". It didn't have a check-mark after the \\\"[E]\\\", which I\\n> >> took to mean it's an outstanding issue.\\n> >> However, I'm starting to wonder if it's already been fixed:\\n> >\\n> > No, but you only see it on some platforms/compilers. On my OS X laptop\\n> > (clang-based not gcc-based compiler), turning that on generates just a\\n> > hair short of 13000 warnings :-(\\n> >\\n> > I think that TODO item is indeed obsolete, but more in the direction\\n> > of \\\"we're never gonna do that\\\". There are too many places where we\\n> > do need to cast up from generic pointer to specific structure pointer,\\n> > and there doesn't seem to be any practical way to tell a compiler which\\n> > instances are useful to warn about.\\n> \\n> Thanks for the response. I'm unclear about how the TODO list is\\n> curated. Is there someone whose attention I should direct to this\\n> thread?\\n\\nSomeone has removed the item. It is a wiki so anyone can add/remove\\nthings.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 13:00:48 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Obsolete TODO item \\\"-Wcast-align\\\" ?\"\n }\n]","isConversational":false}}},{"rowIdx":43086,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"I noticed some imbalanced '-'s in execnodes.h. Though, ISTM newer code \ndoesn't use -'s in comments anymore, so maybe it'd be better to just \nditch them?\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Sun, 4 Sep 2016 17:30:57 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":true,"msg_subject":"Minor fix to comments"},{"msg_contents":"On Sun, Sep 4, 2016 at 05:30:57PM -0500, Jim Nasby wrote:\n> I noticed some imbalanced '-'s in execnodes.h. Though, ISTM newer code\n> doesn't use -'s in comments anymore, so maybe it'd be better to just ditch\n> them?\n\nPatch applied.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n+ As you are, so once was I. As I am, so you will be. +\n+ Ancient Roman grave inscription +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 13:10:07 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":false,"msg_subject":"Re: Minor fix to comments"}],"string":"[\n {\n \"msg_contents\": \"I noticed some imbalanced '-'s in execnodes.h. Though, ISTM newer code \\ndoesn't use -'s in comments anymore, so maybe it'd be better to just \\nditch them?\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sun, 4 Sep 2016 17:30:57 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Minor fix to comments\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 4, 2016 at 05:30:57PM -0500, Jim Nasby wrote:\\n> I noticed some imbalanced '-'s in execnodes.h. Though, ISTM newer code\\n> doesn't use -'s in comments anymore, so maybe it'd be better to just ditch\\n> them?\\n\\nPatch applied.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 13:10:07 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Minor fix to comments\"\n }\n]","isConversational":false}}},{"rowIdx":43087,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi all\n\nCurrently hot standby feedback sends GetOldestXmin()'s result to the\nupstream as the required xmin. GetOldestXmin() returns a slot's\ncatalog_xmin if that's the lowest xmin on the system.\n\nThat's fine so long as we don't do logical decoding on standbys, but\nif we start allowing logical slots on standbys it'll cause the master\nto retain too much bloat since it'll pin the master's xmin (not\ncatalog_xmin) down based on the catalog_xmin of any slots on the\ndownstream.\n\nTo fix that, add new fields to the hot standby feedback protocol\nmessage to carry a separate catalog_xmin.\n\nThis doesn't need any special care for backward compatibility because\nthe only thing that has any business sending hot standby feedback is a\nphysical standby and they're required to be the same major version as\nthe master. If someone tries to connect with a standby of the wrong\nversion they'll fail long before this, and even if they didn't they'd\njust get an error saying there's not enough data in the message.\npg_basebackup, pg_recvlogical and pg_receivexlog don't send hot\nstandby feedback messages.\n\nI'm posting this now because Petr was interested in it for his work on\nlogical replication. I'll be following it a subsequent patch to allow\nlogical slot creation on physical replicas if they're using a slot to\ntalk to the master and have hot_standby_feedback enabled, just so you\nknow the direction this is going in.\n\nPasses 'make check', src/bin/pg_basebackup and src/test/recovery TAP\ntests. I haven't added specific tests for this functionality since\nthere isn't (yet) a way to set catalog_xmin separately on a physical\nstandby without a dedicated test module.\n\nThe logical decoding timeline following patch[1] is also relevant for\nthis, since it is required for logical decoding on standby to survive\npromotion.\n\nNext steps will be:\n\n\n* Expose information about whether or not a slot is in use from walreceiver.c\n\n* Allow logical slots to be created on replicas if\nhot_standby_feedback is enabled and a logical slot is in use. Return\nnull as the exported snapshot ID when creating over the walsender\nprotocol, since we can't export a snapshot on a standby due to the\nneed to allocate an xid. (That can be addressed separately).\n\n* Now that recovery tests are possible, write the recovery test suite\nfor logical decoding on standby\n\n* Auto-drop replication slots when dropping a database in dbase_redo\n\n* Add a safety mechanism to stop users disabling hs feedback on the\nreplica or stopping using a physical slot to the upstream while\nlogical slots exist on the replica. Or mark such logical slots as\nunusable using a new persistent field on the slot. Not trivial because\nwe must allow crash recovery without a slot to upstream (obviously),\nand should preferably also allow fallback to archive recovery when\nserver with slot is temporarily unreachable. Must also consider\nhandling of physical slot with catalog_xmin set from cascading\nphysical replica with logical slots on it.\n\n* Extend the logical replication patch to add support for following\nphysical failover using this functionality, likely in 11.0.\n\n[1] https://commitfest.postgresql.org/10/779/\n\n\nI'll add this to the next CF, but I realise the inability to test it\nstandalone may mean it can only be committed as part of a series along\nwith full support for logical decoding from standby.\n\n-- \n Craig Ringer http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 5 Sep 2016 12:40:47 +0800","msg_from":"Craig Ringer <craig@2ndquadrant.com>","msg_from_op":true,"msg_subject":"[PATCH] Send catalog_xmin separately in hot standby feedback"},{"msg_contents":"On 5 September 2016 at 12:40, Craig Ringer <craig@2ndquadrant.com> wrote:\n> Hi all\n>\n> Currently hot standby feedback sends GetOldestXmin()'s result to the\n> upstream as the required xmin. GetOldestXmin() returns a slot's\n> catalog_xmin if that's the lowest xmin on the system.\n\n\nNote that this patch changes the API to GetOldestXmin(), adding a new\nboolean to allow it to disregard the catalog_xmin of slots.\n\nPer Simon's feedback I'm going to split that out into a separate\npatch, so will post a follow-up split one soon as the series.\n\n-- \n Craig Ringer http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 14:44:16 +0800","msg_from":"Craig Ringer <craig@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: [PATCH] Send catalog_xmin separately in hot standby feedback"},{"msg_contents":"On 5 September 2016 at 14:44, Craig Ringer <craig@2ndquadrant.com> wrote:\n> On 5 September 2016 at 12:40, Craig Ringer <craig@2ndquadrant.com> wrote:\n>> Hi all\n>>\n>> Currently hot standby feedback sends GetOldestXmin()'s result to the\n>> upstream as the required xmin. GetOldestXmin() returns a slot's\n>> catalog_xmin if that's the lowest xmin on the system.\n>\n>\n> Note that this patch changes the API to GetOldestXmin(), adding a new\n> boolean to allow it to disregard the catalog_xmin of slots.\n>\n> Per Simon's feedback I'm going to split that out into a separate\n> patch, so will post a follow-up split one soon as the series.\n\nNow formatted a series:\n\n1. Send catalog_xmin in hot standby feedback protocol\n2. Make walsender respect catalog_xmin in hot standby feedback messages\n3. Allow GetOldestXmin(...) to optionally disregard the catalog_xmin\n4. Send catalog_xmin separately in hot_standby_feedback messages\n\n\nDescriptions are in the patch headers.\n\n\n1 adds the protocol field only. The value is at this point always sent\nas 0 by walreceiver and ignored by walsender. There's need to handle\nbackward compatibility in the addition to the hot standby protocol\nmessage here as only the same major version Pg has any business\nsending us hot standby feedback. pg_receivexlog, pg_basebackup etc\ndon't use hs feedback. Includes protocol docs change.\n\n2 makes walsender now pay attention to the sent catalog_xmin.\nwalreceiver doesn't set it yet and has no way to get it separately.\n\n3 Provides a way to get the global xmin without considering the\ncatalog_xmin so walreceiver can use it.\n\n4 makes walsender use the modified GetOldestXmin()\n\n\n(3) needs additional attention:\n\nBy ignoring slot catalog_xmin in the GetOldestXmin() call then\nseparately calling ProcArrayGetReplicationSlotXmin() to get the\ncatalog_xmin to we might produce a catalog xmin slightly later than\nwhat was in the procarray at the time we previously called\nGetOldestXmin() to examine backend/session state. ProcArrayLock is\nreleased so it can be advanced in-between the calls. That's harmless -\nit isn't necessary for the reported catalog_xmin to be exactly\nconsistent with backend state. If it advances it's safe to report the\nnew position since we know the confirmed positions are on-disk\nlocally.\n\nThe alternative here is to extend GetOldestXmin() to take an out-param\nto report the slot catalog xmin. That really just duplicates the\nfunctionality of ProcArrayGetReplicationSlotXmin but means we can grab\nit within a single ProcArray lock. Variants of GetOldestXmin and\nProcArrayGetReplicationSlotXmin that take an already-locked flag would\nwork too, but would hold the lock across parts of GetOldestXmin() that\ncurrently don't retain it. I could also convert the current boolean\nparam ignoreVacuum into a flags argument instead of adding another\nboolean. No real preference from me.\n\nI cut out some comment changes to be submitted separately; otherwise\nthis series is much the same as the original patch upthread.\n\nAlso available at\nhttps://github.com/2ndQuadrant/postgres/tree/dev/feedback-catalog-xmin\n(and tagged dev/feedback-catalog-xmin). Branch subject to rebasing.\n\n-- \n Craig Ringer http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 5 Sep 2016 17:28:02 +0800","msg_from":"Craig Ringer <craig@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: [PATCH] Send catalog_xmin separately in hot standby feedback"},{"msg_contents":"Hi Craig,\n\nOn 05/09/16 11:28, Craig Ringer wrote:\n> On 5 September 2016 at 14:44, Craig Ringer <craig@2ndquadrant.com> wrote:\n>> On 5 September 2016 at 12:40, Craig Ringer <craig@2ndquadrant.com> wrote:\n>>> Hi all\n>>>\n>>> Currently hot standby feedback sends GetOldestXmin()'s result to the\n>>> upstream as the required xmin. GetOldestXmin() returns a slot's\n>>> catalog_xmin if that's the lowest xmin on the system.\n>>\n>>\n>> Note that this patch changes the API to GetOldestXmin(), adding a new\n>> boolean to allow it to disregard the catalog_xmin of slots.\n>>\n>> Per Simon's feedback I'm going to split that out into a separate\n>> patch, so will post a follow-up split one soon as the series.\n> \n\nHere is my review of them.\n\n> Now formatted a series:\n> \n> 1. Send catalog_xmin in hot standby feedback protocol\n\n> +\txmin_epoch = nextEpoch;\n> \tif (nextXid < xmin)\n> -\t\tnextEpoch--;\n> +\t\txmin_epoch --;\n> +\tcatalog_xmin_epoch = nextEpoch;\n> +\tif (nextXid < catalog_xmin)\n> +\t\tcatalog_xmin_epoch --;\n\nDon't understand why you keep the nextEpoch here, it's not used anywhere\nthat I can see, you could just as well use the xmin_epoch directly if\nthat's how you want to name it.\n\n> +\t/*\n> +\t * A 10.0+ standby's walsender passes the lowest catalog xmin of any\n> +\t * replication slot up to the master.\n> +\t */\n> +\tfeedbackCatalogXmin = pq_getmsgint(&reply_message, 4);\n> +\tfeedbackCatalogEpoch = pq_getmsgint(&reply_message, 4);\n> \n\nI'd be more interested to know why this is sent rather than it's sent\nsince version 10+ in this comment.\n\n> 2. Make walsender respect catalog_xmin in hot standby feedback messages\n\n> +\t\tif (TransactionIdIsNormal(feedbackCatalogXmin)\n> +\t\t\t&& TransactionIdPrecedes(feedbackCatalogXmin, feedbackXmin))\n> +\t\t{\n> +\t\t\tMyPgXact->xmin = feedbackCatalogXmin;\n> +\t\t}\n> +\t\telse\n> +\t\t{\n> +\t\t\tMyPgXact->xmin = feedbackXmin;\n> +\t\t}\n\nThis not how we usually use the {} brackets (there are some more\ninstances of using them for one line of code in this particular commit).\n\n> 3. Allow GetOldestXmin(...) to optionally disregard the catalog_xmin\n> By ignoring slot catalog_xmin in the GetOldestXmin() call then\n> separately calling ProcArrayGetReplicationSlotXmin() to get the\n> catalog_xmin to we might produce a catalog xmin slightly later than\n> what was in the procarray at the time we previously called\n> GetOldestXmin() to examine backend/session state. ProcArrayLock is\n> released so it can be advanced in-between the calls. That's harmless -\n> it isn't necessary for the reported catalog_xmin to be exactly\n> consistent with backend state. If it advances it's safe to report the\n> new position since we know the confirmed positions are on-disk\n> locally.\n> \n> The alternative here is to extend GetOldestXmin() to take an out-param\n> to report the slot catalog xmin. That really just duplicates the\n> functionality of ProcArrayGetReplicationSlotXmin but means we can grab\n> it within a single ProcArray lock. Variants of GetOldestXmin and\n> ProcArrayGetReplicationSlotXmin that take an already-locked flag would\n> work too, but would hold the lock across parts of GetOldestXmin() that\n> currently don't retain it. I could also convert the current boolean\n> param ignoreVacuum into a flags argument instead of adding another\n> boolean. No real preference from me.\n> \n\nI would honestly prefer the change to GetOldestXmin to return the\ncatalog_xmin. It seems both cleaner and does less locking.\n\n> 4. Send catalog_xmin separately in hot_standby_feedback messages\n> \n\nThis looks okay (provided the change above).\n\nIn general it's simpler patch than I expected which is good. But it\nwould be good to have some tests.\n\n-- \n Petr Jelinek http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 24 Oct 2016 18:19:25 +0200","msg_from":"Petr Jelinek <petr@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: [PATCH] Send catalog_xmin separately in hot standby feedback"},{"msg_contents":"On 25 October 2016 at 00:19, Petr Jelinek <petr@2ndquadrant.com> wrote:\n\n>> Now formatted a series:\n>>\n>> 1. Send catalog_xmin in hot standby feedback protocol\n>\n>> + xmin_epoch = nextEpoch;\n>> if (nextXid < xmin)\n>> - nextEpoch--;\n>> + xmin_epoch --;\n>> + catalog_xmin_epoch = nextEpoch;\n>> + if (nextXid < catalog_xmin)\n>> + catalog_xmin_epoch --;\n>\n> Don't understand why you keep the nextEpoch here, it's not used anywhere\n> that I can see, you could just as well use the xmin_epoch directly if\n> that's how you want to name it.\n\nFixed, thanks.\n\n>> + /*\n>> + * A 10.0+ standby's walsender passes the lowest catalog xmin of any\n>> + * replication slot up to the master.\n>> + */\n>> + feedbackCatalogXmin = pq_getmsgint(&reply_message, 4);\n>> + feedbackCatalogEpoch = pq_getmsgint(&reply_message, 4);\n>>\n>\n> I'd be more interested to know why this is sent rather than it's sent\n> since version 10+ in this comment.\n\nRemoved. It's explained in a comment inside the if\n(hot_standby_feedback) block in walreceiver anyway.\n\n>> 2. Make walsender respect catalog_xmin in hot standby feedback messages\n>\n>> + if (TransactionIdIsNormal(feedbackCatalogXmin)\n>> + && TransactionIdPrecedes(feedbackCatalogXmin, feedbackXmin))\n>> + {\n>> + MyPgXact->xmin = feedbackCatalogXmin;\n>> + }\n>> + else\n>> + {\n>> + MyPgXact->xmin = feedbackXmin;\n>> + }\n>\n> This not how we usually use the {} brackets (there are some more\n> instances of using them for one line of code in this particular commit).\n\nWhoops. Thanks. I find the Pg convention pretty ghastly when dealing\nwith multi-line 'if' conditions followed by a single-line statement,\nbut it's still the convention whether I like it or not.\n\n>> 3. Allow GetOldestXmin(...) to optionally disregard the catalog_xmin\n>> By ignoring slot catalog_xmin in the GetOldestXmin() call then\n>> separately calling ProcArrayGetReplicationSlotXmin() to get the\n>> catalog_xmin to we might produce a catalog xmin slightly later than\n>> what was in the procarray at the time we previously called\n>> GetOldestXmin() to examine backend/session state. ProcArrayLock is\n>> released so it can be advanced in-between the calls. That's harmless -\n>> it isn't necessary for the reported catalog_xmin to be exactly\n>> consistent with backend state. If it advances it's safe to report the\n>> new position since we know the confirmed positions are on-disk\n>> locally.\n>>\n>> The alternative here is to extend GetOldestXmin() to take an out-param\n>> to report the slot catalog xmin. That really just duplicates the\n>> functionality of ProcArrayGetReplicationSlotXmin but means we can grab\n>> it within a single ProcArray lock. Variants of GetOldestXmin and\n>> ProcArrayGetReplicationSlotXmin that take an already-locked flag would\n>> work too, but would hold the lock across parts of GetOldestXmin() that\n>> currently don't retain it. I could also convert the current boolean\n>> param ignoreVacuum into a flags argument instead of adding another\n>> boolean. No real preference from me.\n>>\n>\n> I would honestly prefer the change to GetOldestXmin to return the\n> catalog_xmin. It seems both cleaner and does less locking.\n\nFair enough. Done.\n\n> In general it's simpler patch than I expected which is good. But it\n> would be good to have some tests.\n\nAgreed. OK, I've added basic tests for physical replication slots and\nhot_standby_feedback to t/001_stream_rep.pl since it make sense to\ntest both along with stream_rep.pl's tests of cascading, etc and I\ndon't think a separate test is needed.\n\nIt's not actually practical to add tests for the catalog_xmin on\nstandby functionality until the next patch in the series (pending)\nwhich enables logical decoding on standby. Currently you can't create\na slot on a standby so you can't cause the standby to hold down\ncatalog_xmin. But the tests show things work how they should within\nthe range of currently exposed functionality.\n\nIn the process I noticed how skeletal those tests still are. We have a\ngreat framework now (thanks Michael!) and I'd like to start filling it\nout with tests involving unclean shutdowns, promotions, etc. There's a\nlot still to write to get solid coverage. Tests aren't hard. Who's\nkeen to write some? I'll happily help any volunteers out.\n\nNew patch series attached. 0001 is the new tests. The guts is patches\n2-5. I'm not sure whether 2, 3, 4 and 5 should be squashed for commit\nor not, but I left them separate for easier review.\n\nFor complete functionality this series will want to be coupled with\nlogical decoding timeline following and a pending patch to enable\nlogical decoding on standby.\n\n-- \n Craig Ringer http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 11 Nov 2016 13:48:36 +0800","msg_from":"Craig Ringer <craig@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: [PATCH] Send catalog_xmin separately in hot standby feedback"}],"string":"[\n {\n \"msg_contents\": \"Hi all\\n\\nCurrently hot standby feedback sends GetOldestXmin()'s result to the\\nupstream as the required xmin. GetOldestXmin() returns a slot's\\ncatalog_xmin if that's the lowest xmin on the system.\\n\\nThat's fine so long as we don't do logical decoding on standbys, but\\nif we start allowing logical slots on standbys it'll cause the master\\nto retain too much bloat since it'll pin the master's xmin (not\\ncatalog_xmin) down based on the catalog_xmin of any slots on the\\ndownstream.\\n\\nTo fix that, add new fields to the hot standby feedback protocol\\nmessage to carry a separate catalog_xmin.\\n\\nThis doesn't need any special care for backward compatibility because\\nthe only thing that has any business sending hot standby feedback is a\\nphysical standby and they're required to be the same major version as\\nthe master. If someone tries to connect with a standby of the wrong\\nversion they'll fail long before this, and even if they didn't they'd\\njust get an error saying there's not enough data in the message.\\npg_basebackup, pg_recvlogical and pg_receivexlog don't send hot\\nstandby feedback messages.\\n\\nI'm posting this now because Petr was interested in it for his work on\\nlogical replication. I'll be following it a subsequent patch to allow\\nlogical slot creation on physical replicas if they're using a slot to\\ntalk to the master and have hot_standby_feedback enabled, just so you\\nknow the direction this is going in.\\n\\nPasses 'make check', src/bin/pg_basebackup and src/test/recovery TAP\\ntests. I haven't added specific tests for this functionality since\\nthere isn't (yet) a way to set catalog_xmin separately on a physical\\nstandby without a dedicated test module.\\n\\nThe logical decoding timeline following patch[1] is also relevant for\\nthis, since it is required for logical decoding on standby to survive\\npromotion.\\n\\nNext steps will be:\\n\\n\\n* Expose information about whether or not a slot is in use from walreceiver.c\\n\\n* Allow logical slots to be created on replicas if\\nhot_standby_feedback is enabled and a logical slot is in use. Return\\nnull as the exported snapshot ID when creating over the walsender\\nprotocol, since we can't export a snapshot on a standby due to the\\nneed to allocate an xid. (That can be addressed separately).\\n\\n* Now that recovery tests are possible, write the recovery test suite\\nfor logical decoding on standby\\n\\n* Auto-drop replication slots when dropping a database in dbase_redo\\n\\n* Add a safety mechanism to stop users disabling hs feedback on the\\nreplica or stopping using a physical slot to the upstream while\\nlogical slots exist on the replica. Or mark such logical slots as\\nunusable using a new persistent field on the slot. Not trivial because\\nwe must allow crash recovery without a slot to upstream (obviously),\\nand should preferably also allow fallback to archive recovery when\\nserver with slot is temporarily unreachable. Must also consider\\nhandling of physical slot with catalog_xmin set from cascading\\nphysical replica with logical slots on it.\\n\\n* Extend the logical replication patch to add support for following\\nphysical failover using this functionality, likely in 11.0.\\n\\n[1] https://commitfest.postgresql.org/10/779/\\n\\n\\nI'll add this to the next CF, but I realise the inability to test it\\nstandalone may mean it can only be committed as part of a series along\\nwith full support for logical decoding from standby.\\n\\n-- \\n Craig Ringer http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 5 Sep 2016 12:40:47 +0800\",\n \"msg_from\": \"Craig Ringer <craig@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"[PATCH] Send catalog_xmin separately in hot standby feedback\"\n },\n {\n \"msg_contents\": \"On 5 September 2016 at 12:40, Craig Ringer <craig@2ndquadrant.com> wrote:\\n> Hi all\\n>\\n> Currently hot standby feedback sends GetOldestXmin()'s result to the\\n> upstream as the required xmin. GetOldestXmin() returns a slot's\\n> catalog_xmin if that's the lowest xmin on the system.\\n\\n\\nNote that this patch changes the API to GetOldestXmin(), adding a new\\nboolean to allow it to disregard the catalog_xmin of slots.\\n\\nPer Simon's feedback I'm going to split that out into a separate\\npatch, so will post a follow-up split one soon as the series.\\n\\n-- \\n Craig Ringer http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 14:44:16 +0800\",\n \"msg_from\": \"Craig Ringer <craig@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [PATCH] Send catalog_xmin separately in hot standby feedback\"\n },\n {\n \"msg_contents\": \"On 5 September 2016 at 14:44, Craig Ringer <craig@2ndquadrant.com> wrote:\\n> On 5 September 2016 at 12:40, Craig Ringer <craig@2ndquadrant.com> wrote:\\n>> Hi all\\n>>\\n>> Currently hot standby feedback sends GetOldestXmin()'s result to the\\n>> upstream as the required xmin. GetOldestXmin() returns a slot's\\n>> catalog_xmin if that's the lowest xmin on the system.\\n>\\n>\\n> Note that this patch changes the API to GetOldestXmin(), adding a new\\n> boolean to allow it to disregard the catalog_xmin of slots.\\n>\\n> Per Simon's feedback I'm going to split that out into a separate\\n> patch, so will post a follow-up split one soon as the series.\\n\\nNow formatted a series:\\n\\n1. Send catalog_xmin in hot standby feedback protocol\\n2. Make walsender respect catalog_xmin in hot standby feedback messages\\n3. Allow GetOldestXmin(...) to optionally disregard the catalog_xmin\\n4. Send catalog_xmin separately in hot_standby_feedback messages\\n\\n\\nDescriptions are in the patch headers.\\n\\n\\n1 adds the protocol field only. The value is at this point always sent\\nas 0 by walreceiver and ignored by walsender. There's need to handle\\nbackward compatibility in the addition to the hot standby protocol\\nmessage here as only the same major version Pg has any business\\nsending us hot standby feedback. pg_receivexlog, pg_basebackup etc\\ndon't use hs feedback. Includes protocol docs change.\\n\\n2 makes walsender now pay attention to the sent catalog_xmin.\\nwalreceiver doesn't set it yet and has no way to get it separately.\\n\\n3 Provides a way to get the global xmin without considering the\\ncatalog_xmin so walreceiver can use it.\\n\\n4 makes walsender use the modified GetOldestXmin()\\n\\n\\n(3) needs additional attention:\\n\\nBy ignoring slot catalog_xmin in the GetOldestXmin() call then\\nseparately calling ProcArrayGetReplicationSlotXmin() to get the\\ncatalog_xmin to we might produce a catalog xmin slightly later than\\nwhat was in the procarray at the time we previously called\\nGetOldestXmin() to examine backend/session state. ProcArrayLock is\\nreleased so it can be advanced in-between the calls. That's harmless -\\nit isn't necessary for the reported catalog_xmin to be exactly\\nconsistent with backend state. If it advances it's safe to report the\\nnew position since we know the confirmed positions are on-disk\\nlocally.\\n\\nThe alternative here is to extend GetOldestXmin() to take an out-param\\nto report the slot catalog xmin. That really just duplicates the\\nfunctionality of ProcArrayGetReplicationSlotXmin but means we can grab\\nit within a single ProcArray lock. Variants of GetOldestXmin and\\nProcArrayGetReplicationSlotXmin that take an already-locked flag would\\nwork too, but would hold the lock across parts of GetOldestXmin() that\\ncurrently don't retain it. I could also convert the current boolean\\nparam ignoreVacuum into a flags argument instead of adding another\\nboolean. No real preference from me.\\n\\nI cut out some comment changes to be submitted separately; otherwise\\nthis series is much the same as the original patch upthread.\\n\\nAlso available at\\nhttps://github.com/2ndQuadrant/postgres/tree/dev/feedback-catalog-xmin\\n(and tagged dev/feedback-catalog-xmin). Branch subject to rebasing.\\n\\n-- \\n Craig Ringer http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 5 Sep 2016 17:28:02 +0800\",\n \"msg_from\": \"Craig Ringer <craig@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [PATCH] Send catalog_xmin separately in hot standby feedback\"\n },\n {\n \"msg_contents\": \"Hi Craig,\\n\\nOn 05/09/16 11:28, Craig Ringer wrote:\\n> On 5 September 2016 at 14:44, Craig Ringer <craig@2ndquadrant.com> wrote:\\n>> On 5 September 2016 at 12:40, Craig Ringer <craig@2ndquadrant.com> wrote:\\n>>> Hi all\\n>>>\\n>>> Currently hot standby feedback sends GetOldestXmin()'s result to the\\n>>> upstream as the required xmin. GetOldestXmin() returns a slot's\\n>>> catalog_xmin if that's the lowest xmin on the system.\\n>>\\n>>\\n>> Note that this patch changes the API to GetOldestXmin(), adding a new\\n>> boolean to allow it to disregard the catalog_xmin of slots.\\n>>\\n>> Per Simon's feedback I'm going to split that out into a separate\\n>> patch, so will post a follow-up split one soon as the series.\\n> \\n\\nHere is my review of them.\\n\\n> Now formatted a series:\\n> \\n> 1. Send catalog_xmin in hot standby feedback protocol\\n\\n> +\\txmin_epoch = nextEpoch;\\n> \\tif (nextXid < xmin)\\n> -\\t\\tnextEpoch--;\\n> +\\t\\txmin_epoch --;\\n> +\\tcatalog_xmin_epoch = nextEpoch;\\n> +\\tif (nextXid < catalog_xmin)\\n> +\\t\\tcatalog_xmin_epoch --;\\n\\nDon't understand why you keep the nextEpoch here, it's not used anywhere\\nthat I can see, you could just as well use the xmin_epoch directly if\\nthat's how you want to name it.\\n\\n> +\\t/*\\n> +\\t * A 10.0+ standby's walsender passes the lowest catalog xmin of any\\n> +\\t * replication slot up to the master.\\n> +\\t */\\n> +\\tfeedbackCatalogXmin = pq_getmsgint(&reply_message, 4);\\n> +\\tfeedbackCatalogEpoch = pq_getmsgint(&reply_message, 4);\\n> \\n\\nI'd be more interested to know why this is sent rather than it's sent\\nsince version 10+ in this comment.\\n\\n> 2. Make walsender respect catalog_xmin in hot standby feedback messages\\n\\n> +\\t\\tif (TransactionIdIsNormal(feedbackCatalogXmin)\\n> +\\t\\t\\t&& TransactionIdPrecedes(feedbackCatalogXmin, feedbackXmin))\\n> +\\t\\t{\\n> +\\t\\t\\tMyPgXact->xmin = feedbackCatalogXmin;\\n> +\\t\\t}\\n> +\\t\\telse\\n> +\\t\\t{\\n> +\\t\\t\\tMyPgXact->xmin = feedbackXmin;\\n> +\\t\\t}\\n\\nThis not how we usually use the {} brackets (there are some more\\ninstances of using them for one line of code in this particular commit).\\n\\n> 3. Allow GetOldestXmin(...) to optionally disregard the catalog_xmin\\n> By ignoring slot catalog_xmin in the GetOldestXmin() call then\\n> separately calling ProcArrayGetReplicationSlotXmin() to get the\\n> catalog_xmin to we might produce a catalog xmin slightly later than\\n> what was in the procarray at the time we previously called\\n> GetOldestXmin() to examine backend/session state. ProcArrayLock is\\n> released so it can be advanced in-between the calls. That's harmless -\\n> it isn't necessary for the reported catalog_xmin to be exactly\\n> consistent with backend state. If it advances it's safe to report the\\n> new position since we know the confirmed positions are on-disk\\n> locally.\\n> \\n> The alternative here is to extend GetOldestXmin() to take an out-param\\n> to report the slot catalog xmin. That really just duplicates the\\n> functionality of ProcArrayGetReplicationSlotXmin but means we can grab\\n> it within a single ProcArray lock. Variants of GetOldestXmin and\\n> ProcArrayGetReplicationSlotXmin that take an already-locked flag would\\n> work too, but would hold the lock across parts of GetOldestXmin() that\\n> currently don't retain it. I could also convert the current boolean\\n> param ignoreVacuum into a flags argument instead of adding another\\n> boolean. No real preference from me.\\n> \\n\\nI would honestly prefer the change to GetOldestXmin to return the\\ncatalog_xmin. It seems both cleaner and does less locking.\\n\\n> 4. Send catalog_xmin separately in hot_standby_feedback messages\\n> \\n\\nThis looks okay (provided the change above).\\n\\nIn general it's simpler patch than I expected which is good. But it\\nwould be good to have some tests.\\n\\n-- \\n Petr Jelinek http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 24 Oct 2016 18:19:25 +0200\",\n \"msg_from\": \"Petr Jelinek <petr@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [PATCH] Send catalog_xmin separately in hot standby feedback\"\n },\n {\n \"msg_contents\": \"On 25 October 2016 at 00:19, Petr Jelinek <petr@2ndquadrant.com> wrote:\\n\\n>> Now formatted a series:\\n>>\\n>> 1. Send catalog_xmin in hot standby feedback protocol\\n>\\n>> + xmin_epoch = nextEpoch;\\n>> if (nextXid < xmin)\\n>> - nextEpoch--;\\n>> + xmin_epoch --;\\n>> + catalog_xmin_epoch = nextEpoch;\\n>> + if (nextXid < catalog_xmin)\\n>> + catalog_xmin_epoch --;\\n>\\n> Don't understand why you keep the nextEpoch here, it's not used anywhere\\n> that I can see, you could just as well use the xmin_epoch directly if\\n> that's how you want to name it.\\n\\nFixed, thanks.\\n\\n>> + /*\\n>> + * A 10.0+ standby's walsender passes the lowest catalog xmin of any\\n>> + * replication slot up to the master.\\n>> + */\\n>> + feedbackCatalogXmin = pq_getmsgint(&reply_message, 4);\\n>> + feedbackCatalogEpoch = pq_getmsgint(&reply_message, 4);\\n>>\\n>\\n> I'd be more interested to know why this is sent rather than it's sent\\n> since version 10+ in this comment.\\n\\nRemoved. It's explained in a comment inside the if\\n(hot_standby_feedback) block in walreceiver anyway.\\n\\n>> 2. Make walsender respect catalog_xmin in hot standby feedback messages\\n>\\n>> + if (TransactionIdIsNormal(feedbackCatalogXmin)\\n>> + && TransactionIdPrecedes(feedbackCatalogXmin, feedbackXmin))\\n>> + {\\n>> + MyPgXact->xmin = feedbackCatalogXmin;\\n>> + }\\n>> + else\\n>> + {\\n>> + MyPgXact->xmin = feedbackXmin;\\n>> + }\\n>\\n> This not how we usually use the {} brackets (there are some more\\n> instances of using them for one line of code in this particular commit).\\n\\nWhoops. Thanks. I find the Pg convention pretty ghastly when dealing\\nwith multi-line 'if' conditions followed by a single-line statement,\\nbut it's still the convention whether I like it or not.\\n\\n>> 3. Allow GetOldestXmin(...) to optionally disregard the catalog_xmin\\n>> By ignoring slot catalog_xmin in the GetOldestXmin() call then\\n>> separately calling ProcArrayGetReplicationSlotXmin() to get the\\n>> catalog_xmin to we might produce a catalog xmin slightly later than\\n>> what was in the procarray at the time we previously called\\n>> GetOldestXmin() to examine backend/session state. ProcArrayLock is\\n>> released so it can be advanced in-between the calls. That's harmless -\\n>> it isn't necessary for the reported catalog_xmin to be exactly\\n>> consistent with backend state. If it advances it's safe to report the\\n>> new position since we know the confirmed positions are on-disk\\n>> locally.\\n>>\\n>> The alternative here is to extend GetOldestXmin() to take an out-param\\n>> to report the slot catalog xmin. That really just duplicates the\\n>> functionality of ProcArrayGetReplicationSlotXmin but means we can grab\\n>> it within a single ProcArray lock. Variants of GetOldestXmin and\\n>> ProcArrayGetReplicationSlotXmin that take an already-locked flag would\\n>> work too, but would hold the lock across parts of GetOldestXmin() that\\n>> currently don't retain it. I could also convert the current boolean\\n>> param ignoreVacuum into a flags argument instead of adding another\\n>> boolean. No real preference from me.\\n>>\\n>\\n> I would honestly prefer the change to GetOldestXmin to return the\\n> catalog_xmin. It seems both cleaner and does less locking.\\n\\nFair enough. Done.\\n\\n> In general it's simpler patch than I expected which is good. But it\\n> would be good to have some tests.\\n\\nAgreed. OK, I've added basic tests for physical replication slots and\\nhot_standby_feedback to t/001_stream_rep.pl since it make sense to\\ntest both along with stream_rep.pl's tests of cascading, etc and I\\ndon't think a separate test is needed.\\n\\nIt's not actually practical to add tests for the catalog_xmin on\\nstandby functionality until the next patch in the series (pending)\\nwhich enables logical decoding on standby. Currently you can't create\\na slot on a standby so you can't cause the standby to hold down\\ncatalog_xmin. But the tests show things work how they should within\\nthe range of currently exposed functionality.\\n\\nIn the process I noticed how skeletal those tests still are. We have a\\ngreat framework now (thanks Michael!) and I'd like to start filling it\\nout with tests involving unclean shutdowns, promotions, etc. There's a\\nlot still to write to get solid coverage. Tests aren't hard. Who's\\nkeen to write some? I'll happily help any volunteers out.\\n\\nNew patch series attached. 0001 is the new tests. The guts is patches\\n2-5. I'm not sure whether 2, 3, 4 and 5 should be squashed for commit\\nor not, but I left them separate for easier review.\\n\\nFor complete functionality this series will want to be coupled with\\nlogical decoding timeline following and a pending patch to enable\\nlogical decoding on standby.\\n\\n-- \\n Craig Ringer http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 11 Nov 2016 13:48:36 +0800\",\n \"msg_from\": \"Craig Ringer <craig@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: [PATCH] Send catalog_xmin separately in hot standby feedback\"\n }\n]","isConversational":false}}},{"rowIdx":43088,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hello,\n\nI'd like to propose adding SJIS as a database encoding. You may wonder why SJIS is still necessary in the world of Unicode. The purpose is to achieve comparable performance when migrating legacy database systems from other DBMSs without little modification of applications.\n\nRecently, we failed to migrate some customer's legacy database from DBMS-X to PostgreSQL. That customer wished for PostgreSQL, but PostgreSQL couldn't meet the performance requirement.\n\nThe system uses DBMS-X with the database character set being SJIS. The main applications are written in embedded SQL, which require SJIS in their host variables. They insisted they cannot use UTF8 for the host variables because that would require large modification of applications due to character handling. So no character set conversion is necessary between the clients and the server.\n\nOn the other hand, PostgreSQL doesn't support SJIS as a database encoding. Therefore, character set conversion from UTF-8 to SJIS has to be performed. The batch application runs millions of SELECTS each of which retrieves more than 100 columns. And many of those columns are of character type.\n\nIf PostgreSQL supports SJIS, PostgreSQL will match or outperform the performance of DBMS-X with regard to the applications. We confirmed it by using psql to run a subset of the batch processing. When the client encoding is SJIS, one FETCH of 10,000 rows took about 500ms. When the client encoding is UTF8 (the same as the database encoding), the same FETCH took 270ms.\n\nSupporting SJIS may somewhat regain attention to PostgreSQL here in Japan, in the context of database migration. BTW, MySQL supports SJIS as a database encoding. PostgreSQL used to be the most popular open source database in Japan, but MySQL is now more popular.\n\n\nBut what I'm wondering is why PostgreSQL doesn't support SJIS. Was there any technical difficulty? Is there anything you are worried about if adding SJIS?\n\nI'd like to write a patch for adding SJIS if there's no strong objection. I'd appreciate it if you could let me know good design information to add a server encoding (e.g. the URL of the most recent patch to add a new server encoding)\n\nRegards\nTakayuki Tsunakawa\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 07:23:21 +0000","msg_from":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com>","msg_from_op":true,"msg_subject":"Supporting SJIS as a database encoding"},{"msg_contents":"> But what I'm wondering is why PostgreSQL doesn't support SJIS. Was there any technical difficulty? Is there anything you are worried about if adding SJIS?\n\nYes, there's a technical difficulty with backend code. In many places\nit is assumed that any string is \"ASCII compatible\", which means no\nASCII character is used as a part of multi byte string. Here is such a\nrandom example from src/backend/util/adt/varlena.c:\n\n\t/* Else, it's the traditional escaped style */\n\tfor (bc = 0, tp = inputText; *tp != '\\0'; bc++)\n\t{\n\t\tif (tp[0] != '\\\\')\n\t\t\ttp++;\n\nSometimes SJIS uses '\\' as the second byte of it.\n\nBest regards,\n--\nTatsuo Ishii\nSRA OSS, Inc. Japan\nEnglish: http://www.sraoss.co.jp/index_en.php\nJapanese:http://www.sraoss.co.jp\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 05 Sep 2016 16:38:54 +0900 (JST)","msg_from":"Tatsuo Ishii <ishii@sraoss.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"> From: pgsql-hackers-owner@postgresql.org\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Tatsuo Ishii\n> > But what I'm wondering is why PostgreSQL doesn't support SJIS. Was there\n> any technical difficulty? Is there anything you are worried about if adding\n> SJIS?\n> \n> Yes, there's a technical difficulty with backend code. In many places it\n> is assumed that any string is \"ASCII compatible\", which means no ASCII\n> character is used as a part of multi byte string. Here is such a random\n> example from src/backend/util/adt/varlena.c:\n> \n> \t/* Else, it's the traditional escaped style */\n> \tfor (bc = 0, tp = inputText; *tp != '\\0'; bc++)\n> \t{\n> \t\tif (tp[0] != '\\\\')\n> \t\t\ttp++;\n> \n> Sometimes SJIS uses '\\' as the second byte of it.\n\nThanks, I'll try to understand the seriousness of the problem as I don't have good knowledge of character sets. But your example seems to be telling everything about the difficulty...\n\nBefore digging into the problem, could you share your impression on whether PostgreSQL can support SJIS? Would it be hopeless? Can't we find any direction to go? Can I find relevant source code by searching specific words like \"ASCII\", \"HIGH_BIT\", \"\\\\\" etc?\n\nRegards\nTakayuki Tsunakawa\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 08:00:06 +0000","msg_from":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com>","msg_from_op":true,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"> Before digging into the problem, could you share your impression on whether PostgreSQL can support SJIS? Would it be hopeless? Can't we find any direction to go? Can I find relevant source code by searching specific words like \"ASCII\", \"HIGH_BIT\", \"\\\\\" etc?\n\nFor starters, you could grep \"multibyte\".\n\nBest regards,\n--\nTatsuo Ishii\nSRA OSS, Inc. Japan\nEnglish: http://www.sraoss.co.jp/index_en.php\nJapanese:http://www.sraoss.co.jp\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 05 Sep 2016 17:19:25 +0900 (JST)","msg_from":"Tatsuo Ishii <ishii@sraoss.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com> writes:\n> Before digging into the problem, could you share your impression on\n> whether PostgreSQL can support SJIS? Would it be hopeless?\n\nI think it's pretty much hopeless. Even if we were willing to make every\nbit of code that looks for '\\' and other specific at-risk characters\nmulti-byte aware (with attendant speed penalties), we could expect that\nthird-party extensions would still contain vulnerable code. More, we\ncould expect that new bugs of the same ilk would get introduced all the\ntime. Many such bugs would amount to security problems. So the amount of\neffort and vigilance required seems out of proportion to the benefits.\n\nMost of the recent discussion about allowed backend encodings has run\nmore in the other direction, ie, \"why don't we disallow everything but\nUTF8 and get rid of all the infrastructure for multiple backend\nencodings?\". I'm not personally in favor of that, but there are very\nfew hackers who want to add any more overhead in this area.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 05 Sep 2016 10:47:15 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"On 09/05/2016 05:47 PM, Tom Lane wrote:\n> \"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com> writes:\n>> Before digging into the problem, could you share your impression on\n>> whether PostgreSQL can support SJIS? Would it be hopeless?\n>\n> I think it's pretty much hopeless.\n\nAgreed.\n\nBut one thing that would help a little, would be to optimize the UTF-8 \n-> SJIS conversion. It uses a very generic routine, with a binary search \nover a large array of mappings. I bet you could do better than that, \nmaybe using a hash table or a radix tree instead of the large \nbinary-searched array.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 19:38:33 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"From: Tom Lane [mailto:tgl@sss.pgh.pa.us]\n> \"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com> writes:\n> > Before digging into the problem, could you share your impression on\n> > whether PostgreSQL can support SJIS? Would it be hopeless?\n> \n> I think it's pretty much hopeless. Even if we were willing to make every\n> bit of code that looks for '\\' and other specific at-risk characters\n> multi-byte aware (with attendant speed penalties), we could expect that\n> third-party extensions would still contain vulnerable code. More, we could\n> expect that new bugs of the same ilk would get introduced all the time.\n> Many such bugs would amount to security problems. So the amount of effort\n> and vigilance required seems out of proportion to the benefits.\n\nHmm, this sounds like a death sentence. But as I don't have good knowledge of character set handling yet, I'm not completely convinced about why PostgreSQL cannot support SJIS. I wonder why and how other DBMSs support SJIS and what's the difference of the implementation. Using multibyte-functions like mb... to process characters would solve the problem? Isn't the current implementation blocking the support of other character sets that have similar characteristics? I'll learn the character set handling...\n\n> Most of the recent discussion about allowed backend encodings has run more\n> in the other direction, ie, \"why don't we disallow everything but\n> UTF8 and get rid of all the infrastructure for multiple backend encodings?\".\n> I'm not personally in favor of that, but there are very few hackers who\n> want to add any more overhead in this area.\n\nPersonally, I totally agree. I want non-Unicode character sets to disappear from the world. But the real business doesn't seem to forgive the lack of SJIS...\n\nRegards\nTakayuki Tsunakawa\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 02:51:13 +0000","msg_from":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com>","msg_from_op":true,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"From: pgsql-hackers-owner@postgresql.org\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Heikki\n> But one thing that would help a little, would be to optimize the UTF-8\n> -> SJIS conversion. It uses a very generic routine, with a binary search\n> over a large array of mappings. I bet you could do better than that, maybe\n> using a hash table or a radix tree instead of the large binary-searched\n> array.\n\nThat sounds worth pursuing. Thanks!\n\n\nRegards\nTakayuki Tsunakawa\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 02:57:01 +0000","msg_from":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com>","msg_from_op":true,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com> writes:\n> Using multibyte-functions like mb... to process characters would solve\n> the problem?\n\nWell, sure. The problem is (1) finding all the places that need that\n(I'd estimate dozens to hundreds of places in the core code, and then\nthere's the question of extensions); (2) preventing new\nnon-multibyte-aware code from being introduced after you've fixed those\nplaces; and (3) the performance penalties you'd take, because a lot of\nthose places are bottlenecks and it's much cheaper to not worry about\ncharacter lengths in an inner loop.\n\n> Isn't the current implementation blocking the support of\n> other character sets that have similar characteristics?\n\nSure, SJIS is not the only encoding that we consider frontend-only.\nSee\n\nhttps://www.postgresql.org/docs/devel/static/multibyte.html#MULTIBYTE-CHARSET-SUPPORTED\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 05 Sep 2016 23:10:14 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"Hello,\n\nAt Mon, 5 Sep 2016 19:38:33 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <529db688-72fc-1ca2-f898-b0b99e30076f@iki.fi>\n> On 09/05/2016 05:47 PM, Tom Lane wrote:\n> > \"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com> writes:\n> >> Before digging into the problem, could you share your impression on\n> >> whether PostgreSQL can support SJIS? Would it be hopeless?\n> >\n> > I think it's pretty much hopeless.\n> \n> Agreed.\n\n+1, even as a user of SJIS:)\n\n> But one thing that would help a little, would be to optimize the UTF-8\n> -> SJIS conversion. It uses a very generic routine, with a binary\n> search over a large array of mappings. I bet you could do better than\n> that, maybe using a hash table or a radix tree instead of the large\n> binary-searched array.\n\nI'm very impressed by the idea. Mean number of iterations for\nbinsearch on current conversion table with 8000 characters is\nabout 13 and the table size is under 100kBytes (maybe).\n\nA three-level array with 2 byte values will take about 1.6~2MB of memory.\n\nA radix tree for UTF-8->some-encoding conversion requires about,\nor up to.. (using 1 byte index to point the next level)\n\n(1 * ((7f + 1) +\n (df - c2 + 1) * (bf - 80 + 1) +\n (ef - e0 + 1) * (bf - 80 + 1)^2)) = 67 kbytes.\n\nSJIS characters are 2byte length at longest so about 8000\ncharacters takes extra 16 k Bytes. And some padding space will be\nadded on them.\n\nAs the result, radix tree seems to be promising because of small\nrequirement of additional memory and far less comparisons. Also\nBig5 and other encodings including EUC-* will get benefit from\nit.\n\nImplementing radix tree code, then redefining the format of\nmapping table to suppot radix tree, then modifying mapping\ngenerator script are needed.\n\nIf no one oppse to this, I'll do that.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 06 Sep 2016 12:29:04 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"> From: pgsql-hackers-owner@postgresql.org\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\n> HORIGUCHI\nImplementing radix tree code, then redefining the format of mapping table\n> to suppot radix tree, then modifying mapping generator script are needed.\n> \n> If no one oppse to this, I'll do that.\n\n+100\nGreat analysis and your guts. I very much appreciate your trial!\n\nRegards\nTakayuki Tsunakawa\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 03:43:46 +0000","msg_from":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com>","msg_from_op":true,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"Hello,\n\nAt Tue, 6 Sep 2016 03:43:46 +0000, \"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com> wrote in <0A3221C70F24FB45833433255569204D1F5E66CE@G01JPEXMBYT05>\n> > From: pgsql-hackers-owner@postgresql.org\n> > [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\n> > HORIGUCHI\n> Implementing radix tree code, then redefining the format of mapping table\n> > to suppot radix tree, then modifying mapping generator script are needed.\n> > \n> > If no one oppse to this, I'll do that.\n> \n> +100\n> Great analysis and your guts. I very much appreciate your trial!\n\nThanks, by the way, there's another issue related to SJIS\nconversion. MS932 has several characters that have multiple code\npoints. By converting texts in this encoding to and from Unicode\ncauses a round-trop problem. For example,\n\n8754(ROMAN NUMERICAL I in NEC specials)\n => U+2160(ROMAN NUMERICAL I)\n => FA4A (ROMAN NUMERICA I in IBM extension)\n\nMy counting said that 398 characters are affected by this kind of\nreplacement. Addition to that, \"GAIJI\" (Private usage area) is\nnot allowed. Is this meet your purpose?\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 07 Sep 2016 16:13:04 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"From: pgsql-hackers-owner@postgresql.org\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\n> Thanks, by the way, there's another issue related to SJIS conversion. MS932\n> has several characters that have multiple code points. By converting texts\n> in this encoding to and from Unicode causes a round-trop problem. For\n> example,\n> \n> 8754(ROMAN NUMERICAL I in NEC specials)\n> => U+2160(ROMAN NUMERICAL I)\n> => FA4A (ROMAN NUMERICA I in IBM extension)\n> \n> My counting said that 398 characters are affected by this kind of replacement.\n> Addition to that, \"GAIJI\" (Private usage area) is not allowed. Is this meet\n> your purpose?\n\nSupporting GAIJI is not a requirement as far as I know. Thank you for sharing information.\n\n# I realize my lack of knowledge about character sets...\n\nRegards\nTakayuki Tsunakawa\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 07:39:09 +0000","msg_from":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com>","msg_from_op":true,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"Hello,\n\nAt Wed, 07 Sep 2016 16:13:04 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20160907.161304.112519789.horiguchi.kyotaro@lab.ntt.co.jp>\n> > Implementing radix tree code, then redefining the format of mapping table\n> > > to suppot radix tree, then modifying mapping generator script are needed.\n> > > \n> > > If no one oppse to this, I'll do that.\n\nSo, I did that as a PoC. The radix tree takes a little less than\n100k bytes (far smaller than expected:) and it is defnitely\nfaster than binsearch.\n\n\nThe attached patch does the following things.\n\n- Defines a struct for static radix tree\n (utf_radix_tree). Currently it supports up to 3-byte encodings.\n\n- Adds a map generator script UCS_to_SJIS_radix.pl, which\n generates utf8_to_sjis_radix.map from utf8_to_sjis.map.\n\n- Adds a new conversion function utf8_to_sjis_radix.\n\n- Modifies UtfToLocal so as to allow map to be NULL.\n\n- Modifies utf8_to_sjis to use the new conversion function\n instead of ULmapSJIS.\n\n\nThe followings are to be done.\n\n- utf8_to_sjis_radix could be more generic.\n\n- SJIS->UTF8 is not implemented but it would be easily done since\n there's no difference in using the radix tree mechanism.\n (but the output character is currently assumed to be 2-byte long)\n\n- It doesn't support 4-byte codes so this is not applicable to\n sjis_2004. Extending the radix tree to support 4-byte wouldn't\n be hard.\n\n\nThe following is the result of a simple test.\n\n=# create table t (a text); alter table t alter column a storage plain;\n=# insert into t values ('... 7130 cahracters containing (I believe) all characters in SJIS encoding');\n=# insert into t values ('... 7130 cahracters containing (I believe) all characters in SJIS encoding');\n\n# Doing that twice is just my mistake.\n\n$ export PGCLIENTENCODING=SJIS\n\n$ time psql postgres -c '\n$ psql -c '\\encoding' postgres\nSJIS\n\n<Using radix tree>\n$ time psql postgres -c 'select t.a from t, generate_series(0, 9999)' > /dev/null\n\nreal\t0m22.696s\nuser\t0m16.991s\nsys\t0m0.182s>\n\nUsing binsearch the result for the same operation was \nreal\t0m35.296s\nuser\t0m17.166s\nsys\t0m0.216s\n\nReturning in UTF-8 bloats the result string by about 1.5 times so\nit doesn't seem to make sense comparing with it. But it takes\nreal = 47.35s.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 08 Sep 2016 15:35:46 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"From: pgsql-hackers-owner@postgresql.org\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\n> HORIGUCHI\n> <Using radix tree>\n> $ time psql postgres -c 'select t.a from t, generate_series(0, 9999)' >\n> /dev/null\n> \n> real\t0m22.696s\n> user\t0m16.991s\n> sys\t0m0.182s>\n> \n> Using binsearch the result for the same operation was\n> real\t0m35.296s\n> user\t0m17.166s\n> sys\t0m0.216s\n> \n> Returning in UTF-8 bloats the result string by about 1.5 times so it doesn't\n> seem to make sense comparing with it. But it takes real = 47.35s.\n\nCool, 36% speedup! Does this difference vary depending on the actual characters used, e.g. the speedup would be greater if most of the characters are ASCII?\n\nRegards\nTakayuki Tsunakawa\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 07:09:51 +0000","msg_from":"\"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com>","msg_from_op":true,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"At Thu, 8 Sep 2016 07:09:51 +0000, \"Tsunakawa, Takayuki\" <tsunakawa.takay@jp.fujitsu.com> wrote in <0A3221C70F24FB45833433255569204D1F5E7D4A@G01JPEXMBYT05>\n> From: pgsql-hackers-owner@postgresql.org\n> > [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\n> > HORIGUCHI\n> > <Using radix tree>\n> > $ time psql postgres -c 'select t.a from t, generate_series(0, 9999)' >\n> > /dev/null\n> > \n> > real\t0m22.696s\n> > user\t0m16.991s\n> > sys\t0m0.182s>\n> > \n> > Using binsearch the result for the same operation was\n> > real\t0m35.296s\n> > user\t0m17.166s\n> > sys\t0m0.216s\n> > \n> > Returning in UTF-8 bloats the result string by about 1.5 times so it doesn't\n> > seem to make sense comparing with it. But it takes real = 47.35s.\n> \n> Cool, 36% speedup! Does this difference vary depending on the actual characters used, e.g. the speedup would be greater if most of the characters are ASCII?\n\nBinsearch on JIS X 0208 always needs about 10 times of comparison\nand bisecting and the radix tree requires three hops on arrays\nfor most of the characters and two hops for some. In sort, this\neffect won't be differ among 2 and 3 byte characters in UTF-8.\n\nThe translation speed of ASCII cahracters (U+20 - U+7f) is not\naffected by the character conversion mechanism. They are just\ncopied without conversion.\n\nAs the result, there's no speedup if the output consists only of\nASCII characters and maximum speedup when the output consists\nonly of 2 byte UTF-8 characters.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 13 Sep 2016 11:04:27 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"On 09/08/2016 09:35 AM, Kyotaro HORIGUCHI wrote:\n> Returning in UTF-8 bloats the result string by about 1.5 times so\n> it doesn't seem to make sense comparing with it. But it takes\n> real = 47.35s.\n\nNice!\n\nI was hoping that this would also make the binaries smaller. A few dozen \nkB of storage is perhaps not a big deal these days, but still. And \nsmaller tables would also consume less memory and CPU cache.\n\nI removed the #include \"../../Unicode/utf8_to_sjis.map\" line, so that \nthe old table isn't included anymore, compiled, and ran \"strip \nutf8_and_sjis.so\". Without this patch, it's 126 kB, and with it, it's \n160 kB. So the radix tree takes a little bit more space.\n\nThat's not too bad, and I'm sure we could live with that, but with a few \nsimple tricks, we could do better. First, since all the values we store \nin the tree are < 0xffff, we could store them in int16 instead of int32, \nand halve the size of the table right off the bat. That won't work for \nall encodings, of course, but it might be worth it to have two versions \nof the code, one for int16 and another for int32.\n\nAnother trick is to eliminate redundancies in the tables. Many of the \ntables contain lots of zeros, as in:\n\n> /* c3xx */{\n> /* c380 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* c388 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* c390 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x817e,\n> /* c398 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* c3a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* c3a8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* c3b0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8180,\n> /* c3b8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000\n> },\n\nand\n\n> /* e388xx */{\n> /* e38880 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* e38888 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* e38890 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* e38898 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* e388a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* e388a8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* e388b0 */ 0x0000, 0xfa58, 0x878b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> /* e388b8 */ 0x0000, 0x878c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000\n> },\n\nYou could overlay the last row of the first table, which is all zeros, \nwith the first row of the second table, which is also all zeros. (Many \nof the tables have a lot more zero-rows than this example.)\n\nBut yes, this patch looks very promising in general. I think we should \nswitch over to radix trees for the all the encodings.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 13 Sep 2016 11:44:01 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"Hello,\n\nAt Tue, 13 Sep 2016 11:44:01 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <7ff67a45-a53e-4d38-e25d-3a121afea47c@iki.fi>\n> On 09/08/2016 09:35 AM, Kyotaro HORIGUCHI wrote:\n> > Returning in UTF-8 bloats the result string by about 1.5 times so\n> > it doesn't seem to make sense comparing with it. But it takes\n> > real = 47.35s.\n> \n> Nice!\n\nThanks!\n\n> I was hoping that this would also make the binaries smaller. A few\n> dozen kB of storage is perhaps not a big deal these days, but\n> still. And smaller tables would also consume less memory and CPU\n> cache.\n\nAgreed.\n\n> I removed the #include \"../../Unicode/utf8_to_sjis.map\" line, so that\n> the old table isn't included anymore, compiled, and ran \"strip\n> utf8_and_sjis.so\". Without this patch, it's 126 kB, and with it, it's\n> 160 kB. So the radix tree takes a little bit more space.\n> \n> That's not too bad, and I'm sure we could live with that, but with a\n> few simple tricks, we could do better. First, since all the values we\n> store in the tree are < 0xffff, we could store them in int16 instead\n> of int32, and halve the size of the table right off the bat. won't work\n> for all encodings, of course, but it might be worth it to\n> have two versions of the code, one for int16 and another for int32.\n\nThat's right. I used int imprudently. All of the character in the\npatch, and most of characters in other than Unicode-related\nencodings are in 2 bytes. 3 bytes characters can be in separate\ntable in the struct for the case. Othersise two or more versions\nof the structs is possible since currently the radix struct is\nutf8_and_sjis's own in spite of the fact that it is in pg_wchar.h\nin the patch.\n\n> Another trick is to eliminate redundancies in the tables. Many of the\n> tables contain lots of zeros, as in:\n> \n> > /* c3xx */{\n...\n> > 0x817e,\n> > /* c398 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n> > /* c3a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n> > /* c3a8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n> > /* c3b0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x8180,\n> > /* c3b8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000\n> > },\n> \n> and\n> \n> > /* e388xx */{\n> > /* e38880 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n> > /* e38888 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n> > /* e38890 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n> > /* e38898 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n> > /* e388a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\n> > 0x0000,\n...\n> > },\n> \n> You could overlay the last row of the first table, which is all zeros,\n> with the first row of the second table, which is also all zeros. (Many\n> of the tables have a lot more zero-rows than this example.)\n\nYes, the bunch of zeros was annoyance. Several or many\ncompression techniques are available in exchange for some\nadditional CPU time. But the technique you suggested doesn't\nneed such sacrifice, sounds nice.\n\n> But yes, this patch looks very promising in general. I think we should\n> switch over to radix trees for the all the encodings.\n\nThe result was more than I expected for a character set with\nabout 7000 characters. We can expect certain amount of advangate\neven for character sets that have less than a hundred of\ncharacters.\n\n\nI'll work on this for the next CF.\n\nThanks.\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 21 Sep 2016 15:14:27 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"Hello, did this.\n\nAs a result, radix tree is about 1.5 times faster and needs a\nhalf memory.\n\nAt Wed, 21 Sep 2016 15:14:27 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20160921.151427.265121484.horiguchi.kyotaro@lab.ntt.co.jp>\n> I'll work on this for the next CF.\n\nThe radix conversion function and map conversion script became\nmore generic than the previous state. So I could easily added\nradix conversion of EUC_JP in addition to SjiftJIS.\n\nnm -S said that the size of radix tree data for sjis->utf8\nconversion is 34kB and that for utf8->sjis is 46kB. (eucjp->utf8\n57kB, utf8->eucjp 93kB) LUmapSJIS and ULmapSJIS was 62kB and\n59kB, and LUmapEUC_JP and ULmapEUC_JP was 106kB and 105kB. If I'm\nnot missing something, radix tree is faster and require less\nmemory.\n\nA simple test where 'select '7070 sjis chars' x 100' (I'm not\nsure, but the size is 1404kB) on local connection shows that this\nis fast enough.\n\nradix: real 0m0.285s / user 0m0.199s / sys 0m0.006s\nmaster: real 0m0.418s / user 0m0.180s / sys 0m0.004s\n\nTo make sure, the result of a test of sending the same amount of\nASCII string (1404kB) on SJIS and UTF8(no-conversion) encoding is\nas follows.\n\nascii/utf8-sjis: real 0m0.220s / user 0m0.176s / sys 0m0.011s\nascii/utf8-utf8: real 0m0.137s / user 0m0.111s / sys 0m0.008s\n\n======\nRandom discussions -\n\nCurrently the tree structure is devided into several elements,\nOne for 2-byte, other ones for 3-byte and 4-byte codes and output\ntable. The other than the last one is logically and technically\nmerged into single table but it makes the generator script far\ncomplex than the current complexity. I no longer want to play\nhide'n seek with complex perl object..\n\nIt might be better that combining this as a native feature of the\ncore. Currently the helper function is in core but that function\nis given as conv_func on calling LocalToUtf.\n\nCurrent implement uses *.map files of pg_utf_to_local as\ninput. It seems not good but the radix tree files is completely\nuneditable. Provide custom made loading functions for every\nsource instead of load_chartable() would be the way to go.\n\n# However, for example utf8_to_sjis.map, it doesn't seem to have\n# generated from the source mentioned in UCS_to_SJIS.pl\n\nI'm not sure that compilers other than gcc accepts generated map\nfile content.\n\nThe RADIXTREE.pm is in rather older style but seem no problem.\n\nI haven't tried this for charsets that contains 4-byte code.\n\nI haven't consider charset with conbined characters. I don't\nthink it is needed so immediately.\n\nThough I believe that this is easily applied to other\nconversions, I tried this only with character sets that I know\nabout it.\n\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 07 Oct 2016 17:32:00 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Supporting SJIS as a database encoding"},{"msg_contents":"This is a differnet topic from the original thread so I renamed\nthe subject and repost. Sorry for duplicate posting.\n\n======================\nHello, I did this.\n\nAs a result, radix tree is about 1.5 times faster and needs a\nhalf memory.\n\nAt Wed, 21 Sep 2016 15:14:27 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20160921.151427.265121484.horiguchi.kyotaro@lab.ntt.co.jp>\n> I'll work on this for the next CF.\n\nThe radix conversion function and map conversion script became\nmore generic than the previous state. So I could easily added\nradix conversion of EUC_JP in addition to SjiftJIS.\n\nnm -S said that the size of radix tree data for sjis->utf8\nconversion is 34kB and that for utf8->sjis is 46kB. (eucjp->utf8\n57kB, utf8->eucjp 93kB) LUmapSJIS and ULmapSJIS was 62kB and\n59kB, and LUmapEUC_JP and ULmapEUC_JP was 106kB and 105kB. If I'm\nnot missing something, radix tree is faster and require less\nmemory.\n\nA simple test where 'select '7070 sjis chars' x 100' (I'm not\nsure, but the size is 1404kB) on local connection shows that this\nis fast enough.\n\nradix: real 0m0.285s / user 0m0.199s / sys 0m0.006s\nmaster: real 0m0.418s / user 0m0.180s / sys 0m0.004s\n\nTo make sure, the result of a test of sending the same amount of\nASCII string (1404kB) on SJIS and UTF8(no-conversion) encoding is\nas follows.\n\nascii/utf8-sjis: real 0m0.220s / user 0m0.176s / sys 0m0.011s\nascii/utf8-utf8: real 0m0.137s / user 0m0.111s / sys 0m0.008s\n\n======\nRandom discussions -\n\nCurrently the tree structure is devided into several elements,\nOne for 2-byte, other ones for 3-byte and 4-byte codes and output\ntable. The other than the last one is logically and technically\nmerged into single table but it makes the generator script far\ncomplex than the current complexity. I no longer want to play\nhide'n seek with complex perl object..\n\nIt might be better that combining this as a native feature of the\ncore. Currently the helper function is in core but that function\nis given as conv_func on calling LocalToUtf.\n\nCurrent implement uses *.map files of pg_utf_to_local as\ninput. It seems not good but the radix tree files is completely\nuneditable. Provide custom made loading functions for every\nsource instead of load_chartable() would be the way to go.\n\n# However, for example utf8_to_sjis.map, it doesn't seem to have\n# generated from the source mentioned in UCS_to_SJIS.pl\n\nI'm not sure that compilers other than gcc accepts generated map\nfile content.\n\nThe RADIXTREE.pm is in rather older style but seem no problem.\n\nI haven't tried this for charsets that contains 4-byte code.\n\nI haven't consider charset with conbined characters. I don't\nthink it is needed so immediately.\n\nThough I believe that this is easily applied to other\nconversions, I tried this only with character sets that I know\nabout it.\n\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 07 Oct 2016 17:36:06 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Radix tree for character conversion"},{"msg_contents":"On 10/07/2016 11:36 AM, Kyotaro HORIGUCHI wrote:\n> The radix conversion function and map conversion script became\n> more generic than the previous state. So I could easily added\n> radix conversion of EUC_JP in addition to SjiftJIS.\n>\n> nm -S said that the size of radix tree data for sjis->utf8\n> conversion is 34kB and that for utf8->sjis is 46kB. (eucjp->utf8\n> 57kB, utf8->eucjp 93kB) LUmapSJIS and ULmapSJIS was 62kB and\n> 59kB, and LUmapEUC_JP and ULmapEUC_JP was 106kB and 105kB. If I'm\n> not missing something, radix tree is faster and require less\n> memory.\n\nCool!\n\n> Currently the tree structure is devided into several elements,\n> One for 2-byte, other ones for 3-byte and 4-byte codes and output\n> table. The other than the last one is logically and technically\n> merged into single table but it makes the generator script far\n> complex than the current complexity. I no longer want to play\n> hide'n seek with complex perl object..\n\nI think that's OK. There isn't really anything to gain by merging them.\n\n> It might be better that combining this as a native feature of the\n> core. Currently the helper function is in core but that function\n> is given as conv_func on calling LocalToUtf.\n\nYeah, I think we want to completely replace the current binary-search \nbased code with this. I would rather maintain just one mechanism.\n\n> Current implement uses *.map files of pg_utf_to_local as\n> input. It seems not good but the radix tree files is completely\n> uneditable. Provide custom made loading functions for every\n> source instead of load_chartable() would be the way to go.\n>\n> # However, for example utf8_to_sjis.map, it doesn't seem to have\n> # generated from the source mentioned in UCS_to_SJIS.pl\n\nOuch. We should find and document an authoritative source for all the \nmappings we have...\n\nI think the next steps here are:\n\n1. Find an authoritative source for all the existing mappings.\n2. Generate the radix tree files directly from the authoritative \nsources, instead of the existing *.map files.\n3. Completely replace the existing binary-search code with this.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Oct 2016 13:46:31 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Fri, Oct 7, 2016 at 6:46 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Ouch. We should find and document an authoritative source for all the\n> mappings we have...\n>\n> I think the next steps here are:\n>\n> 1. Find an authoritative source for all the existing mappings.\n> 2. Generate the radix tree files directly from the authoritative sources,\n> instead of the existing *.map files.\n> 3. Completely replace the existing binary-search code with this.\n\nIt might be best to convert using the existing map files, and then\nupdate the mappings later. Otherwise, when things break, you won't\nknow what to blame.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Oct 2016 11:55:10 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Robert Haas <robertmhaas@gmail.com> writes:\n> On Fri, Oct 7, 2016 at 6:46 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Ouch. We should find and document an authoritative source for all the\n>> mappings we have...\n>> \n>> I think the next steps here are:\n>> \n>> 1. Find an authoritative source for all the existing mappings.\n>> 2. Generate the radix tree files directly from the authoritative sources,\n>> instead of the existing *.map files.\n>> 3. Completely replace the existing binary-search code with this.\n\n> It might be best to convert using the existing map files, and then\n> update the mappings later. Otherwise, when things break, you won't\n> know what to blame.\n\nI think I went through this exercise last year or so, and updated the\nnotes about the authoritative sources where I was able to find one.\nIn the remaining cases, I believe that the maps have been intentionally\ntweaked and we should be cautious about undoing that. Tatsuo-san might\nremember more about why they are the way they are.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 07 Oct 2016 12:19:23 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 10/07/2016 06:55 PM, Robert Haas wrote:\n> On Fri, Oct 7, 2016 at 6:46 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Ouch. We should find and document an authoritative source for all the\n>> mappings we have...\n>>\n>> I think the next steps here are:\n>>\n>> 1. Find an authoritative source for all the existing mappings.\n>> 2. Generate the radix tree files directly from the authoritative sources,\n>> instead of the existing *.map files.\n>> 3. Completely replace the existing binary-search code with this.\n>\n> It might be best to convert using the existing map files, and then\n> update the mappings later. Otherwise, when things break, you won't\n> know what to blame.\n\nI was thinking that we keep the mappings unchanged, but figure out where \nwe got the mappings we have. An authoritative source may well be \"file X \nfrom unicode, with the following tweaks: ...\". As long as we have some \nway of representing that, in text files, or in perl code, that's OK.\n\nWhat I don't want is that the current *.map files are turned into the \nauthoritative source files, that we modify by hand. There are no \ncomments in them, for starters, which makes hand-editing cumbersome. It \nseems that we have edited some of them by hand already, but we should \nrectify that.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 8 Oct 2016 00:37:28 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, this is new version of radix charconv.\n\nAt Sat, 8 Oct 2016 00:37:28 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <6d85d710-9554-a928-29ff-b2d3b80b01c9@iki.fi>\n> What I don't want is that the current *.map files are turned into the\n> authoritative source files, that we modify by hand. There are no\n> comments in them, for starters, which makes hand-editing\n> cumbersome. It seems that we have edited some of them by hand already,\n> but we should rectify that.\n\nAgreed. So, I identifed source files of each character for EUC_JP\nand SJIS conversions to clarify what has been done on them.\n\nSJIS conversion is made from CP932.TXT and 8 additional\nconversions for UTF8->SJIS and none for SJIS->UTF8.\n\nEUC_JP is made from CP932.TXT and JIS0212.TXT. JIS0201.TXT and\nJIS0208.TXT are useless. It adds 83 or 86 (different by\ndirection) conversion entries.\n\nhttp://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP932.TXT\nhttp://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0212.TXT\n\nNow the generator scripts don't use *.map as source and in turn\ngenerates old-style map files as well as radix tree files.\n\nFor convenience, UCS_to_(SJIS|EUC_JP).pl takes parater --flat and\n-v. The format generates the old-style flat map as well as radix\nmap file and additional -v adds source description for each line\nin the flat map file.\n\nDuring working on this, EUC_JP map lacks some conversions but it\nis another issue.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 21 Oct 2016 17:33:21 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 10/21/2016 11:33 AM, Kyotaro HORIGUCHI wrote:\n> Hello, this is new version of radix charconv.\n>\n> At Sat, 8 Oct 2016 00:37:28 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <6d85d710-9554-a928-29ff-b2d3b80b01c9@iki.fi>\n>> What I don't want is that the current *.map files are turned into the\n>> authoritative source files, that we modify by hand. There are no\n>> comments in them, for starters, which makes hand-editing\n>> cumbersome. It seems that we have edited some of them by hand already,\n>> but we should rectify that.\n>\n> Agreed. So, I identifed source files of each character for EUC_JP\n> and SJIS conversions to clarify what has been done on them.\n>\n> SJIS conversion is made from CP932.TXT and 8 additional\n> conversions for UTF8->SJIS and none for SJIS->UTF8.\n>\n> EUC_JP is made from CP932.TXT and JIS0212.TXT. JIS0201.TXT and\n> JIS0208.TXT are useless. It adds 83 or 86 (different by\n> direction) conversion entries.\n>\n> http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP932.TXT\n> http://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0212.TXT\n>\n> Now the generator scripts don't use *.map as source and in turn\n> generates old-style map files as well as radix tree files.\n>\n> For convenience, UCS_to_(SJIS|EUC_JP).pl takes parater --flat and\n> -v. The format generates the old-style flat map as well as radix\n> map file and additional -v adds source description for each line\n> in the flat map file.\n>\n> During working on this, EUC_JP map lacks some conversions but it\n> is another issue.\n\nThanks!\n\nI'd reallly like to clean up all the current perl scripts, before we \nstart to do the radix tree stuff. I worked through the rest of the \nconversions, and fixed/hacked the perl scripts so that they faithfully \nre-produce the mapping tables that we have in the repository currently. \nWhether those are the best mappings or not, or whether we should update \nthem based on some authoritative source is another question, but let's \ntry to nail down the process of creating the mapping tables.\n\nTom Lane looked into this in Nov 2015 \n(https://www.postgresql.org/message-id/28825.1449076551%40sss.pgh.pa.us). \nThis is a continuation of that, to actually fix the scripts. This patch \nseries doesn't change any of the mappings, only the way we produce the \nmapping tables.\n\nOur UHC conversion tables contained a lot more characters than the \nCP949.TXT file it's supposedly based on. I rewrote the script to use \n\"windows-949-2000.xml\" file, from the ICU project, as the source \ninstead. It's a much closer match to our mapping tables, containing all \nbut one of the additional characters. We were already using \ngb-18030-2000.xml as the source in UCS_GB18030.pl, so parsing ICU's XML \nfiles isn't a new thing.\n\nThe GB2312.TXT source file seems to have disappeared from the Unicode \nconsortium's FTP site. I changed the UCS_to_EUC_CN.pl script to use \ngb-18030-2000.xml as the source instead. GB-18030 is an extension of \nGB-2312, UCS_to_EUC_CN.pl filters out the additional characters that are \nnot in GB-2312.\n\nThis now forms a reasonable basis for switching to radix tree. Every \nmapping table is now generated by the print_tables() perl function in \nconvutils.pm. To switch to a radix tree, you just need to swap that \nfunction with one that produces a radix tree instead of the \ncurrent-format mapping tables.\n\nThe perl scripts are still quite messy. For example, I lost the checks \nfor duplicate mappings somewhere along the way - that ought to be put \nback. My Perl skills are limited.\n\n\nThis is now an orthogonal discussion, and doesn't need to block the \nradix tree work, but we should consider what we want to base our mapping \ntables on. Perhaps we could use the XML files from ICU as the source for \nall of the mappings?\n\nICU seems to use a BSD-like license, so we could even include the XML \nfiles in our repository. Actually, looking at \nhttp://www.unicode.org/copyright.html#License, I think we could include \nthe *.TXT files in our repository, too, if we wanted to. The *.TXT files \nare found under www.unicode.org/Public/, so that license applies. I \nthink that has changed somewhat recently, because the comments in our \nperl scripts claim that the license didn't allow that.\n\n- Heikki\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 25 Oct 2016 12:23:48 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, thank you very much for the work. My work became quite\neasier with it.\n\nAt Tue, 25 Oct 2016 12:23:48 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi>\n> I'd reallly like to clean up all the current perl scripts, before we\n> start to do the radix tree stuff. I worked through the rest of the\n> conversions, and fixed/hacked the perl scripts so that they faithfully\n> re-produce the mapping tables that we have in the repository\n> currently. Whether those are the best mappings or not, or whether we\n> should update them based on some authoritative source is another\n> question, but let's try to nail down the process of creating the\n> mapping tables.\n> \n> Tom Lane looked into this in Nov 2015\n> (https://www.postgresql.org/message-id/28825.1449076551%40sss.pgh.pa.us). This\n> is a continuation of that, to actually fix the scripts. This patch\n> series doesn't change any of the mappings, only the way we produce the\n> mapping tables.\n> \n> > Our UHC conversion tables contained a lot more characters than the\n> CP949.TXT file it's supposedly based on. I rewrote the script to use\n> \"windows-949-2000.xml\" file, from the ICU project, as the source\n> instead. It's a much closer match to our mapping tables, containing\n> all but one of the additional characters. We were already using\n> gb-18030-2000.xml as the source in UCS_GB18030.pl, so parsing ICU's\n> XML files isn't a new thing.\n> \n> The GB2312.TXT source file seems to have disappeared from the Unicode\n> consortium's FTP site. I changed the UCS_to_EUC_CN.pl script to use\n> gb-18030-2000.xml as the source instead. GB-18030 is an extension of\n> GB-2312, UCS_to_EUC_CN.pl filters out the additional characters that\n> are not in GB-2312.\n> \n> This now forms a reasonable basis for switching to radix tree. Every\n> mapping table is now generated by the print_tables() perl function in\n> convutils.pm. To switch to a radix tree, you just need to swap that\n> function with one that produces a radix tree instead of the\n> current-format mapping tables.\n\nRADIXCONV.pm is merged into convutils.pm and the manner to\nresolve reference is unified from $$x{} to $x->{}. (subroutine\ncall by '&' is not unified..) Now radix trees files are written\nby the function with similar interface.\n\nprint_radix_trees($script_name, $encoding, \\@mapping);\n\n> The perl scripts are still quite messy. For example, I lost the checks\n> for duplicate mappings somewhere along the way - that ought to be put\n> back. My Perl skills are limited.\n\nPerl scripts are to be messy, I believe. Anyway the duplicate\ncheck as been built into the sub print_radix_trees. Maybe the\nsame check is needed by some plain map files but it would be just\nduplication for the maps having radix tree.\n\nThe attached patches apply on top your patches and changes all\npossible conversions to use radix tree (combined characters are\nstill using old-method). Addition to that, because of the\ndifficult-to-verify nature of the radix-tree data, I added\nmap_chekcer (make mapcheck) to check them agaist plain maps.\n\nI have briefly checked with real characters for\nSJIS/EUC-JP/BIG5/ISO8859-13 and radix conversion seems to work\ncorrectly for them.\n\n> This is now an orthogonal discussion, and doesn't need to block the\n> radix tree work, but we should consider what we want to base our\n> mapping tables on. Perhaps we could use the XML files from ICU as the\n> source for all of the mappings?\n> \n> ICU seems to use a BSD-like license, so we could even include the XML\n> files in our repository. Actually, looking at\n> http://www.unicode.org/copyright.html#License, I think we could\n> include the *.TXT files in our repository, too, if we wanted to. The\n> *.TXT files are found under www.unicode.org/Public/, so that license\n> applies. I think that has changed somewhat recently, because the\n> comments in our perl scripts claim that the license didn't allow that.\n\nFor the convenience, all the required files are downloaded by\ntyping 'make download-texts'.\n\n\nIn the following document,\n\nhttp://unicode.org/Public/ReadMe.txt\n\n| Terms of Use\n| \thttp://www.unicode.org/copyright.html\n\nhttp://www.unicode.org/copyright.html\n\n| EXHIBIT 1\n| UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE\n| Unicode Data Files include all data files under the directories\n| http://www.unicode.org/Public/, http://www.unicode.org/reports/,\n...\n\n| COPYRIGHT AND PERMISSION NOTICE\n| \n| Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\n| Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\n| \n| Permission is hereby granted, free of charge, to any person obtaining\n| a copy of the Unicode data files and any associated documentation\n| (the \"Data Files\") or Unicode software and any associated documentation\n| (the \"Software\") to deal in the Data Files or Software\n| without restriction, including without limitation the rights to use,\n| copy, modify, merge, publish, distribute, and/or sell copies of\n| the Data Files or Software, and to permit persons to whom the Data Files\n| or Software are furnished to do so, provided that either\n| (a) this copyright and permission notice appear with all copies\n| of the Data Files or Software, or\n| (b) this copyright and permission notice appear in associated\n| Documentation.\n\nPerhaps we can put the files into our repositoy by providing some\nnotifications.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 27 Oct 2016 16:23:37 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> | COPYRIGHT AND PERMISSION NOTICE\n> |\n> | Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\n> | Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\n> |\n> | Permission is hereby granted, free of charge, to any person obtaining\n> | a copy of the Unicode data files and any associated documentation\n> | (the \"Data Files\") or Unicode software and any associated documentation\n> | (the \"Software\") to deal in the Data Files or Software\n> | without restriction, including without limitation the rights to use,\n> | copy, modify, merge, publish, distribute, and/or sell copies of\n> | the Data Files or Software, and to permit persons to whom the Data Files\n> | or Software are furnished to do so, provided that either\n> | (a) this copyright and permission notice appear with all copies\n> | of the Data Files or Software, or\n> | (b) this copyright and permission notice appear in associated\n> | Documentation.\n>\n> Perhaps we can put the files into our repositoy by providing some\n> notifications.\n\nUggh, I don't much like advertising clauses.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 28 Oct 2016 09:18:08 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Robert Haas <robertmhaas@gmail.com> writes:\n> On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>> Perhaps we can put the files into our repositoy by providing some\n>> notifications.\n\n> Uggh, I don't much like advertising clauses.\n\nEven if the license were exactly compatible with ours, I'd be -1 on\nbloating our tarballs with these files. They're large and only a\ntiny fraction of developers, let alone end users, will ever care\nto look at them.\n\nI think it's fine as long as we have a README file that explains\nwhere to get them. (I'm not even very thrilled with the proposed\nauto-download script, as it makes undesirable assumptions about\nwhich internet tools you use, not to mention that it won't work\nat all on Windows.)\n\nI'd actually vote for getting rid of the reference files we\nhave in the tree now (src/backend/utils/mb/Unicode/*txt), on\nthe same grounds. That's 600K of stuff that does not need to\nbe in our tarballs.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 28 Oct 2016 09:42:25 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Fri, Oct 28, 2016 at 09:18:08AM -0400, Robert Haas wrote:\n> On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> > | COPYRIGHT AND PERMISSION NOTICE\n> > |\n> > | Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\n> > | Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\n> > |\n> > | Permission is hereby granted, free of charge, to any person obtaining\n> > | a copy of the Unicode data files and any associated documentation\n> > | (the \"Data Files\") or Unicode software and any associated documentation\n> > | (the \"Software\") to deal in the Data Files or Software\n> > | without restriction, including without limitation the rights to use,\n> > | copy, modify, merge, publish, distribute, and/or sell copies of\n> > | the Data Files or Software, and to permit persons to whom the Data Files\n> > | or Software are furnished to do so, provided that either\n> > | (a) this copyright and permission notice appear with all copies\n> > | of the Data Files or Software, or\n> > | (b) this copyright and permission notice appear in associated\n> > | Documentation.\n> >\n> > Perhaps we can put the files into our repositoy by providing some\n> > notifications.\n> \n> Uggh, I don't much like advertising clauses.\n\nYour dislike is pretty common.\n\nMight it be worth reaching out to the Unicode consortium about this?\nThey may well have added that as boilerplate without really\nconsidering the effects, and they even have a popup that specifically\naddresses licensing.\n\nhttp://www.unicode.org/reporting.html\n\nBest,\nDavid.\n-- \nDavid Fetter <david(at)fetter(dot)org> http://fetter.org/\nPhone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter\nSkype: davidfetter XMPP: david(dot)fetter(at)gmail(dot)com\n\nRemember to vote!\nConsider donating to Postgres: http://www.postgresql.org/about/donate\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 28 Oct 2016 10:12:39 -0700","msg_from":"David Fetter <david@fetter.org>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello,\n\nAt Fri, 28 Oct 2016 09:42:25 -0400, Tom Lane <tgl@sss.pgh.pa.us> wrote in <13049.1477662145@sss.pgh.pa.us>\n> Robert Haas <robertmhaas@gmail.com> writes:\n> > On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\n> > <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> >> Perhaps we can put the files into our repositoy by providing some\n> >> notifications.\n> \n> > Uggh, I don't much like advertising clauses.\n> \n> Even if the license were exactly compatible with ours, I'd be -1 on\n> bloating our tarballs with these files. They're large and only a\n> tiny fraction of developers, let alone end users, will ever care\n> to look at them.\n\nI understood that the intention of Heikki's suggestion, that is,\nthese might be included in PostgreSQL's repository, is looking\nfor a kind of stability, or consistency. The source files are not\nrevision-mangaged. In case where the authorities get unwanted\nchanges or no longer avaiable, .map files have to be edited\nirelevantly from the authority files maybe from the reason that\n. Actually some map files have lost their authority file or other\nmap files have got several direct modifications. We will be free\nfrom such disturbance by containing \"frozen\" authority files.\n\nOn the other hand, I also agree that the advertising or\nadditional bloats of source repositiry are a nuisance.\n\n> I think it's fine as long as we have a README file that explains\n> where to get them. (I'm not even very thrilled with the proposed\n> auto-download script, as it makes undesirable assumptions about\n> which internet tools you use, not to mention that it won't work\n> at all on Windows.)\n\nMmm. It would be a pain in the neck. Some of the files are\nalready stored in \"OBSOLETE\" directory in the Unicode consortium\nftp site, and one of them has been vanished and available from\nanother place, a part of ICU source tree. On the other hand map\nfiles are assumed to be generated from the scripts and are to\ndiscuraged to be directly edited. Radix map files are uneditable\nand currently made from the authority files. If some authority\nfiles are gone, the additional edit have to be done directly onto\nmap files, and they are in turn to be the authority for radix\nfiles. (it's quite easy to chage the authority to current map\nfiles, though).\n\nBy the way, the following phrase of the terms of license.\n\nhttp://www.unicode.org/copyright.html\n\n| COPYRIGHT AND PERMISSION NOTICE\n| \n| Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\n| Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\n| \n| Permission is hereby granted, free of charge, to any person obtaining\n| a copy of the Unicode data files and any associated documentation\n| (the \"Data Files\") or Unicode software and any associated documentation\n| (the \"Software\") to deal in the Data Files or Software\n| without restriction, including without limitation the rights to use,\n| copy, modify, merge, publish, distribute, and/or sell copies of\n| the Data Files or Software, and to permit persons to whom the Data Files\n| or Software are furnished to do so, provided that either\n| (a) this copyright and permission notice appear with all copies\n| of the Data Files or Software, or\n| (b) this copyright and permission notice appear in associated\n| Documentation.\n\nI'm afraid that the map (and _radix.map files) are the translates\nof the \"Data Files\", and 'translate' is a part of 'modify'.\n\nEither the notice is necessary or not, if we decide to wipe the\n'true' authority out from our source files, I'd like to make the\nmap files (preferably with comments) as the second authority,\n_radix.map files are to be getenerated from them, since they're\nnot editable.\n\n> I'd actually vote for getting rid of the reference files we\n> have in the tree now (src/backend/utils/mb/Unicode/*txt), on\n> the same grounds. That's 600K of stuff that does not need to\n> be in our tarballs.\n\nAnyway, I'd like to register this as an item of this CF.\n\nregares,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Oct 2016 09:59:15 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"> On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> \n> Hello, thank you very much for the work. My work became quite\n> easier with it.\n> \n> At Tue, 25 Oct 2016 12:23:48 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi>\n>> \n>> [..]\n>> The perl scripts are still quite messy. For example, I lost the checks\n>> for duplicate mappings somewhere along the way - that ought to be put\n>> back. My Perl skills are limited.\n> \n> Perl scripts are to be messy, I believe. Anyway the duplicate\n> check as been built into the sub print_radix_trees. Maybe the\n> same check is needed by some plain map files but it would be just\n> duplication for the maps having radix tree.\n\nI took a small stab at doing some cleaning of the Perl scripts, mainly around\nusing the more modern (well, modern as in +15 years old) form for open(..),\navoiding global filehandles for passing scalar references and enforcing use\nstrict. Some smaller typos and fixes were also included. It seems my Perl has\nbecome a bit rusty so I hope the changes make sense. The produced files are\nidentical with these patches applied, they are merely doing cleaning as opposed\nto bugfixing.\n\nThe attached patches are against the 0001-0006 patches from Heikki and you in\nthis series of emails, the separation is intended to make them easier to read.\n\ncheers ./daniel\n\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 31 Oct 2016 17:11:17 +0100","msg_from":"Daniel Gustafsson <daniel@yesql.se>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Thank you for looling this.\n\nAt Mon, 31 Oct 2016 17:11:17 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <3FC648B5-2B7F-4585-9615-207A44B730A9@yesql.se>\n> > On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> > Perl scripts are to be messy, I believe. Anyway the duplicate\n> > check as been built into the sub print_radix_trees. Maybe the\n> > same check is needed by some plain map files but it would be just\n> > duplication for the maps having radix tree.\n> \n> I took a small stab at doing some cleaning of the Perl scripts, mainly around\n> using the more modern (well, modern as in +15 years old) form for open(..),\n> avoiding global filehandles for passing scalar references and enforcing use\n> strict. Some smaller typos and fixes were also included. It seems my Perl has\n> become a bit rusty so I hope the changes make sense. The produced files are\n> identical with these patches applied, they are merely doing cleaning as opposed\n> to bugfixing.\n> \n> The attached patches are against the 0001-0006 patches from Heikki and you in\n> this series of emails, the separation is intended to make them easier to read.\n\nI'm not sure how the discussion about this goes, these patches\nmakes me think about coding style of Perl.\n\nThe distinction between executable script and library is by\nintention with an obscure basis. Existing scripts don't get less\nmodification, but library uses more restricted scopes to get rid\nof the troubles caused by using global scopes. But I don't have a\nclear preference on that. The TAP test scripts takes OO notations\nbut I'm not sure convutils.pl also be better to take the same\nnotation. It would be rarely edited hereafter and won't gets\ngrown any more.\n\nAs far as I see the obvious bug fixes in the patchset are the\nfollowing,\n\n- 0007: load_maptable fogets to close input file.\n- 0010: commment for load_maptables is wrong.\n- 0011: hash reference is incorrectly dereferenced\n\nAll other fixes other than the above three seem to be styling or\nsyntax-generation issues and I don't know whether any\nrecommendation exists...\n\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 04 Nov 2016 16:34:33 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"> On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> \n> Thank you for looling this.\n\nAnd thank you for taking the time to read my patches!\n\n> At Mon, 31 Oct 2016 17:11:17 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <3FC648B5-2B7F-4585-9615-207A44B730A9@yesql.se>\n>>> On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>>> Perl scripts are to be messy, I believe. Anyway the duplicate\n>>> check as been built into the sub print_radix_trees. Maybe the\n>>> same check is needed by some plain map files but it would be just\n>>> duplication for the maps having radix tree.\n>> \n>> I took a small stab at doing some cleaning of the Perl scripts, mainly around\n>> using the more modern (well, modern as in +15 years old) form for open(..),\n>> avoiding global filehandles for passing scalar references and enforcing use\n>> strict. Some smaller typos and fixes were also included. It seems my Perl has\n>> become a bit rusty so I hope the changes make sense. The produced files are\n>> identical with these patches applied, they are merely doing cleaning as opposed\n>> to bugfixing.\n>> \n>> The attached patches are against the 0001-0006 patches from Heikki and you in\n>> this series of emails, the separation is intended to make them easier to read.\n> \n> I'm not sure how the discussion about this goes, these patches\n> makes me think about coding style of Perl.\n\nSome of this can absolutely be considered style and more or less down to\npersonal preference. I haven’t seen any coding conventions for Perl so I\nassume it’s down to consensus among the committers. My rationale for these\npatches in the first place was that I perceived this thread to partly want to\nclean up the code and make it more modern Perl.\n\n> The distinction between executable script and library is by\n> intention with an obscure basis. Existing scripts don't get less\n> modification, but library uses more restricted scopes to get rid\n> of the troubles caused by using global scopes. But I don't have a\n> clear preference on that. The TAP test scripts takes OO notations\n> but I'm not sure convutils.pl also be better to take the same\n> notation. It would be rarely edited hereafter and won't gets\n> grown any more.\n\nI think the current convutils module is fine and converting it to OO would be\noverkill.\n\n> As far as I see the obvious bug fixes in the patchset are the\n> following,\n\nAgreed, with some comments:\n\n> - 0007: load_maptable fogets to close input file.\n\nAn interesting note on this is that it’s not even a bug =) Since $in is a\nscalar reference, there is no need to explicitly close() the filehandle since\nthe reference counter will close it on leaving scope, but there’s no harm in\ndoing it ourselves and it also makes for less confusion for anyone not familiar\nwith Perl internals.\n\n> - 0010: commment for load_maptables is wrong.\n\nThere is also a fix for a typo in make_mapchecker.pl\n\n> - 0011: hash reference is incorrectly dereferenced\n> \n> All other fixes other than the above three seem to be styling or\n> syntax-generation issues and I don't know whether any\n> recommendation exists…\n\nI think there are some more fixes that arent styling/syntax remaining. I’ll go\nthrough the patches one by one:\n\n0007 - While this might be considered styling/syntax, my $0.02 is that it’s not\nand instead a worthwhile change. I’ll illustrate with an example from the\npatch in question:\n\nUsing a bareword global variable in open() for the filehandle was replaced with\nthe three-part form in 5.6 and is now even actively discouraged from in the\nPerl documentation (and has been so since the 5.20 docs). The problem is that\nthey are global and can thus easily clash, so easily that the 0007 patch\nactually fixes one such occurrence:\n\nprint_radix_map() opens the file in the global filehandle OUT and passes it to\nprint_radix_table() with the typeglob *OUT; print_radit_table() in turn passes\nthe filehandle to print_segmented_table() which writes to the file using the\nparameter $hd, except in one case where it uses the global OUT variable without\nknowing it will be the right file. This is where the hunk below in 0007 comes\nin:\n\n- print OUT \"$line\\n\";\n+ print { $$hd } \"$line\\n\";\n\nIn this case OUT references the right file and it produces the right result,\nbut it illustrates how easy it is to get wrong (which can cause very subtle\nbugs). So, when poking at this code we might as well, IMHO, use what is today\nin Perl considered the right way to deal with filehandle references.\n\nUsing implicit filemodes can also introduce bugs when opening filenames passed\nin from the outside as we do in UCS_to_most.pl. Considering the use case of\nthese scripts it’s obviously quite low on the list of risks but still.\n\n0008 - I don’t think there are any recommendations whether or not to use use\nstrict; in the codebase, there certainly are lots of scripts not doing it.\nPersonally I think it’s good hygiene to always use strict but here it might\njust be janitorial nitpicking (which I too am guilty of liking.. =)).\n\n0009 - local $var; is to provide a temporary value of $var, where $var exists,\nfor the current scope (and was mostly used back in Perl 4). Since we are\npassing by value to ucs2utf(), and creating $utf inside it, using my to create\nthe variable is the right thing even though the end result is the same.\n\n0010 and 0011 are already dealt with above.\n\nSo to summarize, I think there are a few more (while not all) hunks that are of\ninterest which aren’t just syntax/style which can serve to make the code easer\nto read/work with down line should we need to.\n\ncheers ./daniel\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 7 Nov 2016 12:32:55 +0100","msg_from":"Daniel Gustafsson <daniel@yesql.se>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"> On 07 Nov 2016, at 12:32, Daniel Gustafsson <daniel@yesql.se> wrote:\n> \n>> On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>> \n>> I'm not sure how the discussion about this goes, these patches\n>> makes me think about coding style of Perl.\n> \n> Some of this can absolutely be considered style and more or less down to\n> personal preference. I haven’t seen any coding conventions for Perl so I\n> assume it’s down to consensus among the committers.\n\nActually, scratch that; there is of course a perltidy profile in the pgindent\ndirectory. I should avoid sending email before coffee..\n\ncheers ./daniel\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 7 Nov 2016 17:19:29 +0100","msg_from":"Daniel Gustafsson <daniel@yesql.se>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello,\r\n\r\nAt Mon, 7 Nov 2016 12:32:55 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <EE8775B6-BE30-459D-9DDB-F3D0B3FF573D@yesql.se>\r\n> > On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\r\n> > I'm not sure how the discussion about this goes, these patches\r\n> > makes me think about coding style of Perl.\r\n> \r\n> Some of this can absolutely be considered style and more or less down to\r\n> personal preference. I haven’t seen any coding conventions for Perl so I\r\n> assume it’s down to consensus among the committers. My rationale for these\r\n> patches in the first place was that I perceived this thread to partly want to\r\n> clean up the code and make it more modern Perl.\r\n> \r\n> > The distinction between executable script and library is by\r\n> > intention with an obscure basis. Existing scripts don't get less\r\n> > modification, but library uses more restricted scopes to get rid\r\n> > of the troubles caused by using global scopes. But I don't have a\r\n> > clear preference on that. The TAP test scripts takes OO notations\r\n> > but I'm not sure convutils.pl also be better to take the same\r\n> > notation. It would be rarely edited hereafter and won't gets\r\n> > grown any more.\r\n> \r\n> I think the current convutils module is fine and converting it to OO would be\r\n> overkill.\r\n\r\nAgreed.\r\n\r\n> > As far as I see the obvious bug fixes in the patchset are the\r\n> > following,\r\n> \r\n> Agreed, with some comments:\r\n> \r\n> > - 0007: load_maptable fogets to close input file.\r\n> \r\n> An interesting note on this is that it’s not even a bug =) Since $in is a\r\n> scalar reference, there is no need to explicitly close() the filehandle since\r\n> the reference counter will close it on leaving scope, but there’s no harm in\r\n> doing it ourselves and it also makes for less confusion for anyone not familiar\r\n> with Perl internals.\r\n\r\nWow. I didn't know that perl has such a hidden-OO\r\nfeature. Nevertheless, implicit close is not friendly to who are\r\nnot familiar with newer perl.\r\n\r\nYour comment led me to confirm the requirement to build PostgreSQL.\r\n\r\nhttps://www.postgresql.org/docs/devel/static/install-requirements.html\r\n\r\n| Perl 5.8 or later is needed to build from a Git checkout, or if\r\n| you changed the input files for any of the build steps that use\r\n| Perl scripts. If building on Windows you will need Perl in any\r\n| case. Perl is also required to run some test suites.\r\n\r\nSo, we should assume Perl 5.8 (released in 2002!) on build\r\ntime. And actually 5.10 on RedHat 6.4, 5.16 on my\r\nenvironment(ContOS 7.2), and the official doc is at 5.24. Active\r\nperl is 5.24. According to this, we should use syntax supported\r\nas of 5.8 and/but not obsolete until 5.24, then to follow the\r\nlatest convention. But not OO. (But I can't squeeze out a\r\nconcrete syntax set out of this requirements :( )\r\n\r\n\r\n> > - 0010: commment for load_maptables is wrong.\r\n> \r\n> There is also a fix for a typo in make_mapchecker.pl\r\n> \r\n> > - 0011: hash reference is incorrectly dereferenced\r\n> > \r\n> > All other fixes other than the above three seem to be styling or\r\n> > syntax-generation issues and I don't know whether any\r\n> > recommendation exists…\r\n> \r\n> I think there are some more fixes that arent styling/syntax remaining. I’ll go\r\n> through the patches one by one:\r\n> \r\n> 0007 - While this might be considered styling/syntax, my $0.02 is that it’s not\r\n> and instead a worthwhile change. I’ll illustrate with an example from the\r\n> patch in question:\r\n> \r\n> Using a bareword global variable in open() for the filehandle was replaced with\r\n> the three-part form in 5.6 and is now even actively discouraged from in the\r\n> Perl documentation (and has been so since the 5.20 docs). The problem is that\r\n> they are global and can thus easily clash, so easily that the 0007 patch\r\n> actually fixes one such occurrence:\r\n\r\nThat's what should be adopted in the criteria above.\r\n\r\n - Don't use bareword globals.\r\n - Use open() with separate MODE argument.\r\n\r\n> print_radix_map() opens the file in the global filehandle OUT and passes it to\r\n> print_radix_table() with the typeglob *OUT; print_radit_table() in turn passes\r\n> the filehandle to print_segmented_table() which writes to the file using the\r\n> parameter $hd, except in one case where it uses the global OUT variable without\r\n> knowing it will be the right file. This is where the hunk below in 0007 comes\r\n> in:\r\n> \r\n> - print OUT \"$line\\n\";\r\n> + print { $$hd } \"$line\\n\";\r\n> \r\n> In this case OUT references the right file and it produces the right result,\r\n> but it illustrates how easy it is to get wrong (which can cause very subtle\r\n> bugs). So, when poking at this code we might as well, IMHO, use what is today\r\n> in Perl considered the right way to deal with filehandle references.\r\n\r\nThanks for the detail. Ok, I'll change the style so in the next\r\npatch.\r\n\r\n> Using implicit filemodes can also introduce bugs when opening filenames passed\r\n> in from the outside as we do in UCS_to_most.pl. Considering the use case of\r\n> these scripts it’s obviously quite low on the list of risks but still.\r\n\r\nOk, I'll do that.\r\n\r\n> 0008 - I don’t think there are any recommendations whether or not to use use\r\n> strict; in the codebase, there certainly are lots of scripts not doing it.\r\n> Personally I think it’s good hygiene to always use strict but here it might\r\n> just be janitorial nitpicking (which I too am guilty of liking.. =)).\r\n\r\nI used strict as an amulet (or armor) not to type incorrect\r\nsymbols. Breaking well-working scripts by adding strict is not\r\nreasonable but using it in new or heavily rewritten scripts are\r\nreasonable. I changed my mind to use newer style in rewriting\r\nexisting scripts.\r\n\r\n> 0009 - local $var; is to provide a temporary value of $var, where $var exists,\r\n> for the current scope (and was mostly used back in Perl 4). Since we are\r\n> passing by value to ucs2utf(), and creating $utf inside it, using my to create\r\n> the variable is the right thing even though the end result is the same.\r\n\r\nYes, you're right. The point was that the deferrence between\r\nlexical and dynamic scopes doesn't make any difference in the\r\ncontext. But I'll rewrite it according to the new policy.\r\n\r\n> 0010 and 0011 are already dealt with above.\r\n> \r\n> So to summarize, I think there are a few more (while not all) hunks that are of\r\n> interest which aren’t just syntax/style which can serve to make the code easer\r\n> to read/work with down line should we need to.\r\n\r\nAddition to this, I'll remove existing authority files and modify\r\nradix generator so that it can read plain map files in the next\r\npatch.\r\n\r\nThank you for the significant comments.\r\n\r\nregards,\r\n\r\n-- \r\nKyotaro Horiguchi\r\nNTT Open Source Software Center\r\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 08 Nov 2016 10:43:56 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello,\r\n\r\nAt Mon, 7 Nov 2016 17:19:29 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <39E295B9-7391-40B6-911D-FE852E4604BD@yesql.se>\r\n> > On 07 Nov 2016, at 12:32, Daniel Gustafsson <daniel@yesql.se> wrote:\r\n> > \r\n> >> On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\r\n> >> \r\n> >> I'm not sure how the discussion about this goes, these patches\r\n> >> makes me think about coding style of Perl.\r\n> > \r\n> > Some of this can absolutely be considered style and more or less down to\r\n> > personal preference. I haven’t seen any coding conventions for Perl so I\r\n> > assume it’s down to consensus among the committers.\r\n> \r\n> Actually, scratch that; there is of course a perltidy profile in the pgindent\r\n> directory. I should avoid sending email before coffee..\r\n\r\nHmm. Somehow perl-mode on my Emacs is stirring with\r\nununderstandable indentation and I manually correct them so it is\r\nhighly probable that the style of this patch is not compatible\r\nwith the defined style. Anyway it is better that pgindent\r\ngenerates smaller patch so I'll try it.\r\n\r\nregards,\r\n\r\n-- \r\nKyotaro Horiguchi\r\nNTT Open Source Software Center\r\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 08 Nov 2016 11:02:58 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, this is the revising patch applies on top of the previous\npatch.\n\nDifferences on map files are enormous but useless for discussion\nso they aren't included in this. (but can be generated)\n\nThis still doesn't remove three .txt/.xml files since it heavily\nbloats the patch. I'm planning that they are removed in the final\nshape. All authority files including the removed files are\nautomatically downloaded by the Makefile in this patch.\n\nAt Tue, 08 Nov 2016 10:43:56 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161108.104356.265607041.horiguchi.kyotaro@lab.ntt.co.jp>\n> https://www.postgresql.org/docs/devel/static/install-requirements.html\n> \n> | Perl 5.8 or later is needed to build from a Git checkout, or if\n> | you changed the input files for any of the build steps that use\n> | Perl scripts. If building on Windows you will need Perl in any\n> | case. Perl is also required to run some test suites.\n> \n> So, we should assume Perl 5.8 (released in 2002!) on build\n> time. And actually 5.10 on RedHat 6.4, 5.16 on my\n> environment(ContOS 7.2), and the official doc is at 5.24. Active\n> perl is 5.24. According to this, we should use syntax supported\n> as of 5.8 and/but not obsolete until 5.24, then to follow the\n> latest convention. But not OO. (But I can't squeeze out a\n> concrete syntax set out of this requirements :( )\n...(forget this for a while..)\n\nFinally the attached patch contains most of (virtually all of)\nDaniel's suggestion and some modification by pgperltidy.\n\n> Addition to this, I'll remove existing authority files and modify\n> radix generator so that it can read plain map files in the next\n> patch.\n\nSo, I think the attached are in rather modern shape.\n\nAt Tue, 08 Nov 2016 11:02:58 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161108.110258.59832499.horiguchi.kyotaro@lab.ntt.co.jp>\n> Hmm. Somehow perl-mode on my Emacs is stirring with\n> ununderstandable indentation and I manually correct them so it is\n> highly probable that the style of this patch is not compatible\n> with the defined style. Anyway it is better that pgindent\n> generates smaller patch so I'll try it.\n\nThe attached are applied pgperltidy. Several regions such like\nadditional character list are marked not to be edited.\n\nOne concern is what to leave by 'make distclen' and 'make\nmaintainer-clean'. The former should remove authority *.TXT files\nsince it shouldn't be in source archive. On the other hand it is\nmore convenient that the latter leaves them. This seems somewhat\nstrange but I can't come up with better behavior for now.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 08 Nov 2016 20:21:22 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"> On 08 Nov 2016, at 12:21, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> \n> Hello, this is the revising patch applies on top of the previous\n> patch.\n> \n> ...\n> \n> Finally the attached patch contains most of (virtually all of)\n> Daniel's suggestion and some modification by pgperltidy.\n\nReading over this it looks good to me. I did spot one thing I had missed\nbefore though, the error message below should be referencing the scalar\nvariable ‘direction' unless I’m missing something:\n\n-\tdie \"unacceptable direction : %direction\"\n+\tdie \"unacceptable direction : $direction\"\n \t if ($direction ne \"to_unicode\" && $direction ne \"from_unicode\");\n\nWith this, I would consider this ready for committer.\n\n>> Addition to this, I'll remove existing authority files and modify\n>> radix generator so that it can read plain map files in the next\n>> patch.\n> \n> So, I think the attached are in rather modern shape.\n\n+1, nice work!\n\ncheers ./daniel\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 8 Nov 2016 14:06:29 +0100","msg_from":"Daniel Gustafsson <daniel@yesql.se>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\n> I took a small stab at doing some cleaning of the Perl scripts, mainly around\n> using the more modern (well, modern as in +15 years old) form for open(..),\n> avoiding global filehandles for passing scalar references and enforcing use\n> strict. Some smaller typos and fixes were also included. It seems my Perl has\n> become a bit rusty so I hope the changes make sense. The produced files are\n> identical with these patches applied, they are merely doing cleaning as opposed\n> to bugfixing.\n> \n> The attached patches are against the 0001-0006 patches from Heikki and you in\n> this series of emails, the separation is intended to make them easier to read.\n\nCool. See also here:\nhttps://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\n\n-- \nPeter Eisentraut http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 8 Nov 2016 11:37:58 -0500","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"> On 08 Nov 2016, at 17:37, Peter Eisentraut <peter.eisentraut@2ndquadrant.com> wrote:\n> \n> On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\n>> I took a small stab at doing some cleaning of the Perl scripts, mainly around\n>> using the more modern (well, modern as in +15 years old) form for open(..),\n>> avoiding global filehandles for passing scalar references and enforcing use\n>> strict. Some smaller typos and fixes were also included. It seems my Perl has\n>> become a bit rusty so I hope the changes make sense. The produced files are\n>> identical with these patches applied, they are merely doing cleaning as opposed\n>> to bugfixing.\n>> \n>> The attached patches are against the 0001-0006 patches from Heikki and you in\n>> this series of emails, the separation is intended to make them easier to read.\n> \n> Cool. See also here:\n> https://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\n\nNice, not having hacked much Perl in quite a while I had all but forgotten\nabout perlcritic.\n\nRunning it on the current version of the patchset yields mostly warnings on\nstring values used in the require “convutils.pm” statement. There were however\ntwo more interesting reports: one more open() call not using the three\nparameter form and an instance of map which alters the input value. The latter\nis not causing an issue since we don’t use the input list past the map but\nfixing it seems like good form.\n\nAttached is a patch that addresses the perlcritic reports (running without any\nspecial options).\n\ncheers ./daniel\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 9 Nov 2016 02:19:01 +0100","msg_from":"Daniel Gustafsson <daniel@yesql.se>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, thank you for polishing this.\r\n\r\nAt Wed, 9 Nov 2016 02:19:01 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <80F34F25-BF6D-4BCD-9C38-42ED10D3F453@yesql.se>\r\n> > On 08 Nov 2016, at 17:37, Peter Eisentraut <peter.eisentraut@2ndquadrant.com> wrote:\r\n> > \r\n> > On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\r\n> >> I took a small stab at doing some cleaning of the Perl scripts, mainly around\r\n> >> using the more modern (well, modern as in +15 years old) form for open(..),\r\n> >> avoiding global filehandles for passing scalar references and enforcing use\r\n> >> strict. Some smaller typos and fixes were also included. It seems my Perl has\r\n> >> become a bit rusty so I hope the changes make sense. The produced files are\r\n> >> identical with these patches applied, they are merely doing cleaning as opposed\r\n> >> to bugfixing.\r\n> >> \r\n> >> The attached patches are against the 0001-0006 patches from Heikki and you in\r\n> >> this series of emails, the separation is intended to make them easier to read.\r\n> > \r\n> > Cool. See also here:\r\n> > https://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\r\n\r\n> Nice, not having hacked much Perl in quite a while I had all but forgotten\r\n> about perlcritic.\r\n\r\nI tried it on CentOS7. Installation failed saying that\r\nModule::Build is too old. It is yum-inatlled so removed it and\r\ninstalled it with CPAN. Again failed with many 'Could not create\r\nMYMETA files'. Then tried to install CPAN::Meta and it failed\r\nsaying that CPAN::Meta::YAML is too *new*. That sucks.\r\n\r\nSo your patch is greately helpfull. Thank you.\r\n\r\n| -my @mapnames = map { s/\\.map//; $_ } values %plainmaps;\r\n| +my @mapnames = map { my $m = $_; $m =~ s/\\.map//; $m } values %plainmaps;\r\n\r\nIt surprised me to know that perlcritic does such things.\r\n\r\n> Running it on the current version of the patchset yields mostly warnings on\r\n> string values used in the require “convutils.pm” statement. There were however\r\n> two more interesting reports: one more open() call not using the three\r\n> parameter form and an instance of map which alters the input value. \r\n\r\nSorry for overlooking it.\r\n\r\n> The latter\r\n> is not causing an issue since we don’t use the input list past the map but\r\n> fixing it seems like good form.\r\n\r\nAgreed.\r\n\r\n> Attached is a patch that addresses the perlcritic reports (running without any\r\n> special options).\r\n\r\nThanks. The attached patch contains the patch by perlcritic.\r\n\r\n0001,2,3 are Heikki's patch that are not modified since it is\r\nfirst proposed. It's a bit too big so I don't attach them to this\r\nmail (again).\r\n\r\nhttps://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\r\n\r\n0004 is radix-tree stuff, applies on top of the three patches\r\nabove.\r\n\r\nThere's a hidden fifth patch which of 20MB in size. But it is\r\ngenerated by running make in the Unicode directory.\r\n\r\n[$(TOP)]$ ./configure ...\r\n[$(TOP)]$ make\r\n[Unicode]$ make\r\n[Unicode]$ make distclean\r\n[Unicode]$ git add .\r\n[Unicode]$ commit \r\n=== COMMITE MESSSAGE\r\nReplace map files with radix tree files.\r\n\r\nThese encodings no longer uses the former map files and uses new radix\r\ntree files. All existing authority files in this directory are removed.\r\n===\r\n\r\nregards,\r\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 09 Nov 2016 17:38:53 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello.\r\n\r\nI'll be off line until at least next Monday. So I move this to\r\nthe next CF by myself.\r\n\r\nAt Wed, 09 Nov 2016 17:38:53 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161109.173853.77274443.horiguchi.kyotaro@lab.ntt.co.jp>\r\n> Hello, thank you for polishing this.\r\n> \r\n> At Wed, 9 Nov 2016 02:19:01 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <80F34F25-BF6D-4BCD-9C38-42ED10D3F453@yesql.se>\r\n> > > On 08 Nov 2016, at 17:37, Peter Eisentraut <peter.eisentraut@2ndquadrant.com> wrote:\r\n> > > \r\n> > > On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\r\n> > >> I took a small stab at doing some cleaning of the Perl scripts, mainly around\r\n> > >> using the more modern (well, modern as in +15 years old) form for open(..),\r\n> > >> avoiding global filehandles for passing scalar references and enforcing use\r\n> > >> strict. Some smaller typos and fixes were also included. It seems my Perl has\r\n> > >> become a bit rusty so I hope the changes make sense. The produced files are\r\n> > >> identical with these patches applied, they are merely doing cleaning as opposed\r\n> > >> to bugfixing.\r\n> > >> \r\n> > >> The attached patches are against the 0001-0006 patches from Heikki and you in\r\n> > >> this series of emails, the separation is intended to make them easier to read.\r\n> > > \r\n> > > Cool. See also here:\r\n> > > https://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\r\n> \r\n> > Nice, not having hacked much Perl in quite a while I had all but forgotten\r\n> > about perlcritic.\r\n> \r\n> I tried it on CentOS7. Installation failed saying that\r\n> Module::Build is too old. It is yum-inatlled so removed it and\r\n> installed it with CPAN. Again failed with many 'Could not create\r\n> MYMETA files'. Then tried to install CPAN::Meta and it failed\r\n> saying that CPAN::Meta::YAML is too *new*. That sucks.\r\n> \r\n> So your patch is greately helpfull. Thank you.\r\n> \r\n> | -my @mapnames = map { s/\\.map//; $_ } values %plainmaps;\r\n> | +my @mapnames = map { my $m = $_; $m =~ s/\\.map//; $m } values %plainmaps;\r\n> \r\n> It surprised me to know that perlcritic does such things.\r\n> \r\n> > Running it on the current version of the patchset yields mostly warnings on\r\n> > string values used in the require “convutils.pm” statement. There were however\r\n> > two more interesting reports: one more open() call not using the three\r\n> > parameter form and an instance of map which alters the input value. \r\n> \r\n> Sorry for overlooking it.\r\n> \r\n> > The latter\r\n> > is not causing an issue since we don’t use the input list past the map but\r\n> > fixing it seems like good form.\r\n> \r\n> Agreed.\r\n> \r\n> > Attached is a patch that addresses the perlcritic reports (running without any\r\n> > special options).\r\n> \r\n> Thanks. The attached patch contains the patch by perlcritic.\r\n> \r\n> 0001,2,3 are Heikki's patch that are not modified since it is\r\n> first proposed. It's a bit too big so I don't attach them to this\r\n> mail (again).\r\n> \r\n> https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\r\n> \r\n> 0004 is radix-tree stuff, applies on top of the three patches\r\n> above.\r\n> \r\n> There's a hidden fifth patch which of 20MB in size. But it is\r\n> generated by running make in the Unicode directory.\r\n> \r\n> [$(TOP)]$ ./configure ...\r\n> [$(TOP)]$ make\r\n> [Unicode]$ make\r\n> [Unicode]$ make distclean\r\n> [Unicode]$ git add .\r\n> [Unicode]$ commit \r\n> === COMMITE MESSSAGE\r\n> Replace map files with radix tree files.\r\n> \r\n> These encodings no longer uses the former map files and uses new radix\r\n> tree files. All existing authority files in this directory are removed.\r\n> ===\r\n\r\n-- \r\nKyotaro Horiguchi\r\nNTT Open Source Software Center\r\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 28 Nov 2016 19:25:15 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 10/31/2016 06:11 PM, Daniel Gustafsson wrote:\n>> On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>>\n>> At Tue, 25 Oct 2016 12:23:48 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi>\n>>>\n>>> [..]\n>>> The perl scripts are still quite messy. For example, I lost the checks\n>>> for duplicate mappings somewhere along the way - that ought to be put\n>>> back. My Perl skills are limited.\n>>\n>> Perl scripts are to be messy, I believe. Anyway the duplicate\n>> check as been built into the sub print_radix_trees. Maybe the\n>> same check is needed by some plain map files but it would be just\n>> duplication for the maps having radix tree.\n>\n> I took a small stab at doing some cleaning of the Perl scripts, mainly around\n> using the more modern (well, modern as in +15 years old) form for open(..),\n> avoiding global filehandles for passing scalar references and enforcing use\n> strict. Some smaller typos and fixes were also included. It seems my Perl has\n> become a bit rusty so I hope the changes make sense. The produced files are\n> identical with these patches applied, they are merely doing cleaning as opposed\n> to bugfixing.\n>\n> The attached patches are against the 0001-0006 patches from Heikki and you in\n> this series of emails, the separation is intended to make them easier to read.\n\nThanks! Patches 0001-0003 seem to have been mostly unchanged for the \nlater discussion and everyone seems to be happy with those patches, so I \npicked the parts of these cleanups of yours that applied to my patches \n0001-0003, and pushed those. I'll continue reviewing the rest..\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 30 Nov 2016 14:59:44 +0200","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\n> Thanks. The attached patch contains the patch by perlcritic.\n>\n> 0001,2,3 are Heikki's patch that are not modified since it is\n> first proposed. It's a bit too big so I don't attach them to this\n> mail (again).\n>\n> https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\n\nI've now pushed these preliminary patches, with the applicable fixes \nfrom you and Daniel. The attached patch is now against git master.\n\n> 0004 is radix-tree stuff, applies on top of the three patches\n> above.\n\nI've spent the last couple of days reviewing this. While trying to \nunderstand how it works, I ended up dismantling, rewriting, and putting \nback together most of the added perl code. Attached is a new version, \nwith more straightforward logic, making it more understandable. I find \nit more understandable, anyway, I hope it's not only because I wrote it \nmyself :-). Let me know what you think.\n\nIn particular, I found the explanations of flat and segmented tables \nreally hard to understand. So in this version, the radix trees for a \nconversion are stored completely in one large array. Leaf and \nintermediate levels are all in the same array. When reading this \nversion, please note that I'm not sure if I mean the same thing with \n\"segment\" that you did in your version.\n\nI moved the \"lower\" and \"upper\" values in the structs. Also, there are \nnow also separate \"lower\" and \"upper\" values for the leaf levels of the \ntrees, for 1- 2-, 3- and 4-byte inputs. This made a huge difference to \nthe size of gb18030_to_utf8_radix.map, in particular: the source file \nshrank from about 2 MB to 1/2 MB. In that conversion, the valid range \nfor the last byte of 2-byte inputs is 0x40-0xfe, and the valid range for \nthe last byte of 4-byte inputs is 0x30-0x39. With the old patch version, \nthe \"chars\" range was therefore 0x30-0xfe, to cover both of those, and \nmost of the array was filled with zeros. With this new patch version, we \nstore separate ranges for those, and can leave out most of the zeros.\n\nThere's a segment full of zeros at the beginning of each conversion \narray now. The purpose of that is that when traversing the radix tree, \nyou don't need to check each intermediate value for 0. If you follow a 0 \noffset, it simply points to the dummy all-zeros segments in the \nbeginning. Seemed like a good idea to shave some cycles, although I'm \nnot sure if it made much difference in reality.\n\nI optimized pg_mb_radix_conv() a bit, too. We could do more. For \nexample, I think it would save some cycles to have specialized versions \nof UtfToLocal and LocalToUtf, moving the tests for whether a combined \ncharacter map and/or conversion callback is used, out of the loop. They \nfeel a bit ugly too, in their current form...\n\nI need a break now, but I'll try to pick this up again some time next \nweek. Meanwhile, please have a look and tell me what you think.\n\n- Heikki\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 2 Dec 2016 22:07:07 +0200","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Heikki Linnakangas wrote:\n> On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\n> > Thanks. The attached patch contains the patch by perlcritic.\n> > \n> > 0001,2,3 are Heikki's patch that are not modified since it is\n> > first proposed. It's a bit too big so I don't attach them to this\n> > mail (again).\n> > \n> > https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\n> \n> I've now pushed these preliminary patches, with the applicable fixes from\n> you and Daniel. The attached patch is now against git master.\n\nIs this the Nov. 30th commit? Because I don't see any other commits\nfrom you.\n\n-- \n�lvaro Herrera https://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 2 Dec 2016 17:18:46 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 12/02/2016 10:18 PM, Alvaro Herrera wrote:\n> Heikki Linnakangas wrote:\n>> On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\n>>> Thanks. The attached patch contains the patch by perlcritic.\n>>>\n>>> 0001,2,3 are Heikki's patch that are not modified since it is\n>>> first proposed. It's a bit too big so I don't attach them to this\n>>> mail (again).\n>>>\n>>> https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\n>>\n>> I've now pushed these preliminary patches, with the applicable fixes from\n>> you and Daniel. The attached patch is now against git master.\n>\n> Is this the Nov. 30th commit? Because I don't see any other commits\n> from you.\n\nYes. Sorry for the confusion.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 2 Dec 2016 22:49:52 +0200","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, thank you for reviewing this.\n\nI compared mine and yours. The new patch works fine and gives\nsmaller radix map files. It seems also to me more readable.\n\nAt Fri, 2 Dec 2016 22:07:07 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <da58a154-0b28-802e-5e82-5a205f53926e@iki.fi>\n> On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\n> > Thanks. The attached patch contains the patch by perlcritic.\n> >\n> > 0001,2,3 are Heikki's patch that are not modified since it is\n> > first proposed. It's a bit too big so I don't attach them to this\n> > mail (again).\n> >\n> > https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\n> \n> I've now pushed these preliminary patches, with the applicable fixes\n> from you and Daniel. The attached patch is now against git master.\n\nThanks for committing them.\n\n> > 0004 is radix-tree stuff, applies on top of the three patches\n> > above.\n> \n> I've spent the last couple of days reviewing this. While trying to\n> understand how it works, I ended up dismantling, rewriting, and\n> putting back together most of the added perl code. \n\nI might have been putting too much in one structure and a bit too\neager to conceal lower level from the upper level.\n\n> Attached is a new\n> version, with more straightforward logic, making it more\n> understandable. I find it more understandable, anyway, I hope it's not\n> only because I wrote it myself :-). Let me know what you think.\n\nFirst, thank you for the refactoring(?).\n\nI didn't intend to replace all of .map files with radix files at\nfirst. Finally my patch removes all old-style map file but I\nhaven't noticed that. So removing the old bsearch code seems\nreasonable. Avoiding redundant decomposition of multibyte\ncharacters into bytes seems reasonable from the view of\nefficiency.\n\nThe new patch decomposes the structured pg_mb_radix_tree into a\nseries of (basically) plain member variables in a struct. I'm not\nso in favor of the style but a radix tree of at least 4-levels is\neasily read in the style and maybe the code to handle it is\nrather easily readable. (So +1 for it)\n\n> In particular, I found the explanations of flat and segmented tables\n> really hard to understand. So in this version, the radix trees for a\n> conversion are stored completely in one large array. Leaf and\n> intermediate levels are all in the same array. When reading this\n> version, please note that I'm not sure if I mean the same thing with\n> \"segment\" that you did in your version.\n> I moved the \"lower\" and \"upper\" values in the structs. Also, there are\n> now also separate \"lower\" and \"upper\" values for the leaf levels of\n> the trees, for 1- 2-, 3- and 4-byte inputs. This made a huge\n\nThe \"segment\" there seems to mean definitely the same to\nmine. Flattening the on-memory structure is fine from the same\nreason to the above.\n\n> difference to the size of gb18030_to_utf8_radix.map, in particular:\n> the source file shrank from about 2 MB to 1/2 MB. In that conversion,\n> the valid range for the last byte of 2-byte inputs is 0x40-0xfe, and\n> the valid range for the last byte of 4-byte inputs is 0x30-0x39. With\n> the old patch version, the \"chars\" range was therefore 0x30-0xfe, to\n> cover both of those, and most of the array was filled with zeros. With\n> this new patch version, we store separate ranges for those, and can\n> leave out most of the zeros.\n\nGreat. I agree that the (logically) devided chartable is\nsignificantly space-efficient.\n\n> There's a segment full of zeros at the beginning of each conversion\n> array now. The purpose of that is that when traversing the radix tree,\n> you don't need to check each intermediate value for 0. If you follow a\n> 0 offset, it simply points to the dummy all-zeros segments in the\n> beginning. Seemed like a good idea to shave some cycles, although I'm\n> not sure if it made much difference in reality.\n\nAnd I like the zero page.\n\n> I optimized pg_mb_radix_conv() a bit, too. We could do more. For\n> example, I think it would save some cycles to have specialized\n> versions of UtfToLocal and LocalToUtf, moving the tests for whether a\n> combined character map and/or conversion callback is used, out of the\n> loop. They feel a bit ugly too, in their current form...\n\nHmm. Maybe decomposing iiso in pg_mb_radix_conv is faster than\npushing extra 3 (or 4) parameters into the stack (or it's wrong\nif they are passed using registers?) but I'm not sure.\n\n> I need a break now, but I'll try to pick this up again some time next\n> week. Meanwhile, please have a look and tell me what you think.\n\nThank you very much for the big effort on this patch.\n\nApart from the aboves, I have some trivial comments on the new\nversion.\n\n\n1. If we decide not to use old-style maps, UtfToLocal no longer\n need to take void * as map data. (Patch 0001)\n\n2. \"use Data::Dumper\" doesn't seem necessary. (Patch 0002)\n\n3. A comment contains a superfluous comma. (Patch 0002) (The last\n byte of the first line below)\n > ### The segments are written out physically to one big array in the final,\n > ### step, but logically, they form a radix tree. Or rather, four radix\n\n4. The following code doesn't seem so perl'ish.\n\n > for (my $i=0; $i <= 0xff; $i++)\n > {\n > my $val = $seg->{values}->{$i};\n > if ($val)\n > {\n > $this_min = $i if (!defined $this_min || $i < $this_min);\n\n Refraining from proposing extreme perl, the following would be\n reasonable as an equivalent. (Patch 0002)\n\n foreach $i (keys $seg->{values})\n {\n \n The 0002 patch contains the following change but this might be\n kinda extreme..\n\n - for (my $i=0; $i <= 0xff; $i++)\n + while ((my $i, my $val) = each $map)\n\n4. download_srctxts.sh is no longer needed. (No patch)\n\n\nI'll put more consideration on the new version and put another\nversion later.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 05 Dec 2016 19:29:54 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, I looked on this closer.\n\nThe attached is the revised version of this patch.\n\nAt Mon, 05 Dec 2016 19:29:54 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161205.192954.121855559.horiguchi.kyotaro@lab.ntt.co.jp>\n> Apart from the aboves, I have some trivial comments on the new\n> version.\n> \n> \n> 1. If we decide not to use old-style maps, UtfToLocal no longer\n> need to take void * as map data. (Patch 0001)\n> 2. \"use Data::Dumper\" doesn't seem necessary. (Patch 0002)\n> 3. A comment contains a superfluous comma. (Patch 0002) (The last\n> byte of the first line below)\n> 4. The following code doesn't seem so perl'ish.\n> 4. download_srctxts.sh is no longer needed. (No patch)\n\n6. Fixed some inconsistent indentation/folding.\n7. Fix handling of $verbose.\n8. Sort segments using leading bytes.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 13 Dec 2016 15:11:03 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, I found a bug in my portion while rebasing.\n\nThe attached patches apply on top of the current master HEAD, not\non Heikki's previous one. And separated into 4 parts.\n\nAt Tue, 13 Dec 2016 15:11:03 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161213.151103.157484378.horiguchi.kyotaro@lab.ntt.co.jp>\n> > Apart from the aboves, I have some trivial comments on the new\n> > version.\n> > \n> > \n> > 1. If we decide not to use old-style maps, UtfToLocal no longer\n> > need to take void * as map data. (Patch 0001)\n\nI changed the pointer type wrongly. Combined maps are of the type\n*_combined.\n\n> > 2. \"use Data::Dumper\" doesn't seem necessary. (Patch 0002)\n> > 3. A comment contains a superfluous comma. (Patch 0002) (The last\n> > byte of the first line below)\n> > 4. The following code doesn't seem so perl'ish.\n> > 5. download_srctxts.sh is no longer needed. (No patch)\n> \n> 6. Fixed some inconsistent indentation/folding.\n> 7. Fix handling of $verbose.\n> 8. Sort segments using leading bytes.\n\nThe attached files are the following. This patchset is not\ncomplete missing changes of map files. The change is tremendously\nlarge but generatable.\n\n0001-Add-missing-semicolon.patch\n\n UCS_to_EUC_JP.pl has a line missing teminating semicolon. This\n doesn't harm but surely a syntax error. This patch fixes it.\n This might should be a separate patch.\n\n0002-Correct-reference-resolution-syntax.patch\n\n convutils.pm has lines with different syntax of reference\n resolution. This unifies the syntax.\n\n0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n\n Before adding radix tree stuff, applied pgperltidy and inserted\n format-skipping pragma for the parts where perltidy seems to do\n too much.\n\n0004-Use-radix-tree-for-character-conversion.patch\n\n Radix tree body.\n\n\nThe unattached fifth patch is generated by the following steps.\n\n[$(TOP)]$ ./configure\n[Unicode]$ make\n[Unicode]$ make distclean\n[Unicode]$ git add .\n[Unicode]$ commit \n=== COMMITE MESSSAGE\nReplace map files with radix tree files.\n\nThese encodings no longer uses the former map files and uses new radix\ntree files.\n===\n\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 10 Jan 2017 20:22:23 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"HI,\n\nI patched 4 patchset and run \"make\", but I got failed.\nIs this a bug or my mistake ?\nI'm sorry if I'm wrong.\n\n[$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\n[$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\n[$(TOP)]$ patch -p1 <\n../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n[$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\n[$(TOP)]$ ./configure\n[Unicode]$ make\n'/usr/bin/perl' UCS_to_most.pl\nType of arg 1 to keys must be hash (not hash element) at convutils.pm\nline 443, near \"})\n \"\nType of arg 1 to values must be hash (not hash element) at\nconvutils.pm line 596, near \"})\n \"\nType of arg 1 to each must be hash (not private variable) at\nconvutils.pm line 755, near \"$map)\n \"\nCompilation failed in require at UCS_to_most.pl line 19.\nmake: *** [iso8859_2_to_utf8.map] Error 255\n\nRegars,\n-- \nAyumi Ishii\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 25 Jan 2017 19:18:26 +0900","msg_from":"Ishii Ayumi <ayumi.ishii.pg@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, thank you for looking this.\n\nAt Wed, 25 Jan 2017 19:18:26 +0900, Ishii Ayumi <ayumi.ishii.pg@gmail.com> wrote in <CAOu5J714+w-TRSNHbsS+aBVE5LdsR3CEZ6w4QLQ=9NrAJNavTA@mail.gmail.com>\n> I patched 4 patchset and run \"make\", but I got failed.\n> Is this a bug or my mistake ?\n> I'm sorry if I'm wrong.\n> \n> [$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\n> [$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\n> [$(TOP)]$ patch -p1 <\n> ../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n> [$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\n> [$(TOP)]$ ./configure\n> [Unicode]$ make\n\nThe directory src/backend/mb/uilts/Unicode is not built as a part\nof the top-level build, and it would be preferable that the\npreexisting map files are removed.\n\n$ cd src/backend/utils/mb/Unicode\n$ make distclean # this would require ./configure\n$ make maintainer-clean\n$ cd ../../../../.. # go to top\n$ make clean\n(make'ing here will give you an error saying a .map file is not found)\n$ cd src/backend/utils/mb/Unicode # again\n$ make\n$ cd ../../../../.. # go to top\n$ make\n\nThis steps still suceeds for me, even with the patches on the\ncurrent master.\n\nThe cause of the the following errors seems the other things.\n\n> '/usr/bin/perl' UCS_to_most.pl\n> Type of arg 1 to keys must be hash (not hash element) at convutils.pm\n> line 443, near \"})\n> \"\n> Type of arg 1 to values must be hash (not hash element) at\n> convutils.pm line 596, near \"})\n> \"\n> Type of arg 1 to each must be hash (not private variable) at\n> convutils.pm line 755, near \"$map)\n> \"\n> Compilation failed in require at UCS_to_most.pl line 19.\n> make: *** [iso8859_2_to_utf8.map] Error 255\n\nSurely perl 5.8.9 complained just as above but 5.16\ndoesn't. Google told me that at least 5.10 behaves as the same\nway. The *current* requirement for perl verion to build is 5.8.\n\nhttps://www.postgresql.org/docs/current/static/install-requirements.html\n\nFortunately, only three lines of change suffices 5.8 so I've\nchosen to flatter perl 5.8.\n\nAs the result, no changes has been made on 0001-0003 so I\nattached only 0004 to this mail.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 26 Jan 2017 16:16:56 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Tue, Jan 10, 2017 at 8:22 PM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> [...patch...]\n\nNobody has showed up yet to review this patch, so I am giving it a shot.\n\nThe patch file sizes are scary at first sight, but after having a look:\n 36 files changed, 1411 insertions(+), 54398 deletions(-)\nYes that's a surprise, something like git diff --irreversible-delete\nwould have helped as most of the diffs are just caused by 3 files\nbeing deleted in patch 0004, making 50k lines going to the abyss of\ndeletion.\n\n> Hello, I found a bug in my portion while rebasing.\n\nRight, that's 0001. Nice catch.\n\n> The attached files are the following. This patchset is not\n> complete missing changes of map files. The change is tremendously\n> large but generatable.\n>\n> 0001-Add-missing-semicolon.patch\n>\n> UCS_to_EUC_JP.pl has a line missing teminating semicolon. This\n> doesn't harm but surely a syntax error. This patch fixes it.\n> This might should be a separate patch.\n\nThis requires a back-patch. This makes me wonder how long this script\nhas actually not run...\n\n> 0002-Correct-reference-resolution-syntax.patch\n>\n> convutils.pm has lines with different syntax of reference\n> resolution. This unifies the syntax.\n\nYes that looks right to me. I am the best perl guru on this list but\nlooking around $$var{foo} is bad, ${$var}{foo} is better, and\n$var->{foo} is even better. This also generates no diffs when running\nmake in src/backend/utils/mb/Unicode/. So no objections to that.\n\n> 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n>\n> Before adding radix tree stuff, applied pgperltidy and inserted\n> format-skipping pragma for the parts where perltidy seems to do\n> too much.\n\nWhich version of perltidy did you use? Looking at the archives, the\nperl code is cleaned up with a specific version, v20090616. See\nhttps://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\nfor example on the matter. As perltidy changes over time, this may be\na sensitive change if done this way.\n\n> 0004-Use-radix-tree-for-character-conversion.patch\n>\n> Radix tree body.\n\nWell, here a lot of diffs could have been saved.\n\n> The unattached fifth patch is generated by the following steps.\n>\n> [$(TOP)]$ ./configure\n> [Unicode]$ make\n> [Unicode]$ make distclean\n> [Unicode]$ git add .\n> [Unicode]$ commit\n> === COMMITE MESSSAGE\n> Replace map files with radix tree files.\n>\n> These encodings no longer uses the former map files and uses new radix\n> tree files.\n> ===\n\nOK, I can see that working, with 200k of maps generated.. So going\nthrough the important bits of this jungle..\n\n+/*\n+ * radix tree conversion function - this should be identical to the function in\n+ * ../conv.c with the same name\n+ */\n+static inline uint32\n+pg_mb_radix_conv(const pg_mb_radix_tree *rt,\n+ int l,\n+ unsigned char b1,\n+ unsigned char b2,\n+ unsigned char b3,\n+ unsigned char b4)\nThis is not nice. Having a duplication like that is a recipe to forget\nabout it as this patch introduces a dependency with conv.c and the\nradix tree generation.\n\nHaving a .gitignore in Unicode/ would be nice, particularly to avoid\ncommitting map_checker.\n\nA README documenting things may be welcome, or at least comments at\nthe top of map_checker.c. Why is map_checker essential? What does it\ndo? There is no way to understand that easily, except that it includes\na \"radix tree conversion function\", and that it performs sanity checks\non the radix trees to be sure that they are on a good shape. But as\nthis something that one would guess only after looking at your patch\nand the code (at least I will sleep less stupid tonight after reading\nthis stuff).\n\n--- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n+++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n # Drop these SJIS codes from the source for UTF8=>SJIS conversion\n #<<< do not let perltidy touch this\n-my @reject_sjis =(\n+my @reject_sjis = (\n 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\n- 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n+ 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n 0x879a..0x879c\n-);\n+ );\nThis is not generated, it would be nice to drop the noise from the patch.\n\nHere is another one:\n- $i->{code} = $jis | (\n- $jis < 0x100\n- ? 0x8e00\n- : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n-\n+#<<< do not let perltidy touch this\n+ $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\n+ ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n+#>>>\n\n if (l == 2)\n {\n- iutf = *utf++ << 8;\n- iutf |= *utf++;\n+ b3 = *utf++;\n+ b4 = *utf++;\n }\nAh, OK. This conversion is important so as it performs a minimum of\nbitwise operations. Yes let's keep that. That's pretty cool to get a\nfaster operation.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 26 Jan 2017 16:28:16 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Wed, Jan 25, 2017 at 7:18 PM, Ishii Ayumi <ayumi.ishii.pg@gmail.com> wrote:\n> I patched 4 patchset and run \"make\", but I got failed.\n> Is this a bug or my mistake ?\n> I'm sorry if I'm wrong.\n>\n> [$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\n> [$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\n> [$(TOP)]$ patch -p1 <\n> ../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n> [$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\n> [$(TOP)]$ ./configure\n> [Unicode]$ make\n> '/usr/bin/perl' UCS_to_most.pl\n> Type of arg 1 to keys must be hash (not hash element) at convutils.pm\n> line 443, near \"})\n> \"\n> Type of arg 1 to values must be hash (not hash element) at\n> convutils.pm line 596, near \"})\n> \"\n> Type of arg 1 to each must be hash (not private variable) at\n> convutils.pm line 755, near \"$map)\n> \"\n> Compilation failed in require at UCS_to_most.pl line 19.\n> make: *** [iso8859_2_to_utf8.map] Error 255\n\nHm, I am not sure what you are missing. I was able to get things to build.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 26 Jan 2017 16:29:10 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"At Thu, 26 Jan 2017 16:29:10 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqQd860tOC17O3Qs3+dzZTYbXrXxVD9Tfph0pJ9LAYZ=Ww@mail.gmail.com>\n> On Wed, Jan 25, 2017 at 7:18 PM, Ishii Ayumi <ayumi.ishii.pg@gmail.com> wrote:\n> > I patched 4 patchset and run \"make\", but I got failed.\n> > Is this a bug or my mistake ?\n> > I'm sorry if I'm wrong.\n> >\n> > [$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\n> > [$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\n> > [$(TOP)]$ patch -p1 <\n> > ../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n> > [$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\n> > [$(TOP)]$ ./configure\n> > [Unicode]$ make\n> > '/usr/bin/perl' UCS_to_most.pl\n> > Type of arg 1 to keys must be hash (not hash element) at convutils.pm\n> > line 443, near \"})\n> > \"\n> > Type of arg 1 to values must be hash (not hash element) at\n> > convutils.pm line 596, near \"})\n> > \"\n> > Type of arg 1 to each must be hash (not private variable) at\n> > convutils.pm line 755, near \"$map)\n> > \"\n> > Compilation failed in require at UCS_to_most.pl line 19.\n> > make: *** [iso8859_2_to_utf8.map] Error 255\n> \n> Hm, I am not sure what you are missing. I was able to get things to build.\n\nAs I posted, it should be caused by older perl, at least 5.8\ncomplains so and 5.16 doesn't.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 26 Jan 2017 21:17:37 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Thank you for looking this.\n\nAt Thu, 26 Jan 2017 16:28:16 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqREL1fsDBGv4zRvaXY+UKtS0wzkamJcnYhX0--OZvpUUQ@mail.gmail.com>\n> On Tue, Jan 10, 2017 at 8:22 PM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> > [...patch...]\n> \n> Nobody has showed up yet to review this patch, so I am giving it a shot.\n> \n> The patch file sizes are scary at first sight, but after having a look:\n> 36 files changed, 1411 insertions(+), 54398 deletions(-)\n> Yes that's a surprise, something like git diff --irreversible-delete\n> would have helped as most of the diffs are just caused by 3 files\n> being deleted in patch 0004, making 50k lines going to the abyss of\n> deletion.\n\nThank you. Good to hear that. I'll try that at the next chance.\n\n> > Hello, I found a bug in my portion while rebasing.\n> \n> Right, that's 0001. Nice catch.\n> \n> > The attached files are the following. This patchset is not\n> > complete missing changes of map files. The change is tremendously\n> > large but generatable.\n> >\n> > 0001-Add-missing-semicolon.patch\n> >\n> > UCS_to_EUC_JP.pl has a line missing teminating semicolon. This\n> > doesn't harm but surely a syntax error. This patch fixes it.\n> > This might should be a separate patch.\n> \n> This requires a back-patch. This makes me wonder how long this script\n> has actually not run...\n> \n> > 0002-Correct-reference-resolution-syntax.patch\n> >\n> > convutils.pm has lines with different syntax of reference\n> > resolution. This unifies the syntax.\n> \n> Yes that looks right to me.\n\nYes, I thoght that the three patches can be back-patched, a kind\nof bug fix.\n\n> I am the best perl guru on this list but\n> looking around $$var{foo} is bad, ${$var}{foo} is better, and\n> $var->{foo} is even better. This also generates no diffs when running\n> make in src/backend/utils/mb/Unicode/. So no objections to that.\n\nThank you for the explanation. I think no '$$'s is left alone.\n\n> > 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n> >\n> > Before adding radix tree stuff, applied pgperltidy and inserted\n> > format-skipping pragma for the parts where perltidy seems to do\n> > too much.\n> \n> Which version of perltidy did you use? Looking at the archives, the\n> perl code is cleaned up with a specific version, v20090616. See\n> https://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\n> for example on the matter. As perltidy changes over time, this may be\n> a sensitive change if done this way.\n\nHmm. I will make a confirmation on that.. tomorrow.\n\n> > 0004-Use-radix-tree-for-character-conversion.patch\n> >\n> > Radix tree body.\n> \n> Well, here a lot of diffs could have been saved.\n> \n> > The unattached fifth patch is generated by the following steps.\n> >\n> > [$(TOP)]$ ./configure\n> > [Unicode]$ make\n> > [Unicode]$ make distclean\n> > [Unicode]$ git add .\n> > [Unicode]$ commit\n> > === COMMITE MESSSAGE\n> > Replace map files with radix tree files.\n> >\n> > These encodings no longer uses the former map files and uses new radix\n> > tree files.\n> > ===\n> \n> OK, I can see that working, with 200k of maps generated.. So going\n> through the important bits of this jungle..\n\nMany thaks for the exploration.\n\n> +/*\n> + * radix tree conversion function - this should be identical to the function in\n> + * ../conv.c with the same name\n> + */\n> +static inline uint32\n> +pg_mb_radix_conv(const pg_mb_radix_tree *rt,\n> + int l,\n> + unsigned char b1,\n> + unsigned char b2,\n> + unsigned char b3,\n> + unsigned char b4)\n> This is not nice. Having a duplication like that is a recipe to forget\n> about it as this patch introduces a dependency with conv.c and the\n> radix tree generation.\n\nMmmmm. I agree to you, but conv.c contains unwanted reference to\nelog or other sutff of the core. Separating the function in a\ndedicate source file named such as \"../pg_mb_radix_conv.c\" will\nwork. If it is not so bad, I'll do that in the next version.\n\n> Having a .gitignore in Unicode/ would be nice, particularly to avoid\n> committing map_checker.\n> \n> A README documenting things may be welcome, or at least comments at\n> the top of map_checker.c. Why is map_checker essential? What does it\n> do? There is no way to understand that easily, except that it includes\n> a \"radix tree conversion function\", and that it performs sanity checks\n> on the radix trees to be sure that they are on a good shape. But as\n> this something that one would guess only after looking at your patch\n> and the code (at least I will sleep less stupid tonight after reading\n> this stuff).\n\nOkay, I'll do that.\n\n> --- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n> +++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n> # Drop these SJIS codes from the source for UTF8=>SJIS conversion\n> #<<< do not let perltidy touch this\n> -my @reject_sjis =(\n> +my @reject_sjis = (\n> 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\n> - 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n> + 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n> 0x879a..0x879c\n> -);\n> + );\n> This is not generated, it would be nice to drop the noise from the patch.\n\nMmm. I'm not sure how this is generated but I'll care for that.\n\n> Here is another one:\n> - $i->{code} = $jis | (\n> - $jis < 0x100\n> - ? 0x8e00\n> - : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n> -\n> +#<<< do not let perltidy touch this\n> + $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\n> + ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n> +#>>>\n\nOk. Will revert this.\n\n> if (l == 2)\n> {\n> - iutf = *utf++ << 8;\n> - iutf |= *utf++;\n> + b3 = *utf++;\n> + b4 = *utf++;\n> }\n> Ah, OK. This conversion is important so as it performs a minimum of\n> bitwise operations. Yes let's keep that. That's pretty cool to get a\n> faster operation.\n\nIt is Heikki's work:p\n\nI'll address them and repost the next version sooner.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 26 Jan 2017 21:42:12 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hi, this is an intermediate report without a patch.\n\nAt Thu, 26 Jan 2017 21:42:12 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170126.214212.111556326.horiguchi.kyotaro@lab.ntt.co.jp>\n> > > 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n> > >\n> > > Before adding radix tree stuff, applied pgperltidy and inserted\n> > > format-skipping pragma for the parts where perltidy seems to do\n> > > too much.\n> > \n> > Which version of perltidy did you use? Looking at the archives, the\n> > perl code is cleaned up with a specific version, v20090616. See\n> > https://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\n> > for example on the matter. As perltidy changes over time, this may be\n> > a sensitive change if done this way.\n> \n> Hmm. I will make a confirmation on that.. tomorrow.\n\nMy perltidy -v said \"v20121207'. Anyway, I gave up to apply\nperltidy by myself. So I'll just drop 0003 and new 0004 (name\nchanged to 0003) is made immediately on 0002.\n\n> > > 0004-Use-radix-tree-for-character-conversion.patch\n> > >\n> > > Radix tree body.\n> > \n> > Well, here a lot of diffs could have been saved.\n> > \n> > > The unattached fifth patch is generated by the following steps.\n> > >\n> > > [$(TOP)]$ ./configure\n> > > [Unicode]$ make\n> > > [Unicode]$ make distclean\n> > > [Unicode]$ git add .\n> > > [Unicode]$ commit\n> > > === COMMITE MESSSAGE\n> > > Replace map files with radix tree files.\n> > >\n> > > These encodings no longer uses the former map files and uses new radix\n> > > tree files.\n> > > ===\n> > \n> > OK, I can see that working, with 200k of maps generated.. So going\n> > through the important bits of this jungle..\n> \n> Many thaks for the exploration.\n> \n> > +/*\n> > + * radix tree conversion function - this should be identical to the function in\n> > + * ../conv.c with the same name\n..\n> > This is not nice. Having a duplication like that is a recipe to forget\n> > about it as this patch introduces a dependency with conv.c and the\n> > radix tree generation.\n\nIn the attatched patch, mb/char_conveter.c which contains one\ninline function is created and it is includ'ed from mb/conv.c and\nmb/Unicode/map_checker.c.\n\n> > Having a .gitignore in Unicode/ would be nice, particularly to avoid\n> > committing map_checker.\n\nI missed this. I added .gitignore to ignore map_checker stuff\nand authority files and old-style map files.\n\n> > A README documenting things may be welcome, or at least comments at\n> > the top of map_checker.c. Why is map_checker essential? What does it\n> > do? There is no way to understand that easily, except that it includes\n> > a \"radix tree conversion function\", and that it performs sanity checks\n> > on the radix trees to be sure that they are on a good shape. But as\n> > this something that one would guess only after looking at your patch\n> > and the code (at least I will sleep less stupid tonight after reading\n> > this stuff).\n> \n> Okay, I'll do that.\n\nThe patch has not been provided yet, I'm going to put the\nfollowing comment just before the main() in map_checker.c.\n\n/*\n * The old-style plain map files were error-resistant due to its\n * straight-forward way for generation from authority files. In contrast the\n * radix tree maps are generated by a rather complex calculation and have a\n * complex, hard-to-confirm format.\n *\n * This program runs sanity check of the radix tree maps by confirming all\n * characters in the plain map files to be converted to the same code by the\n * corresponding radix tree map.\n *\n * All map files are included by map_checker.h that is generated by the script\n * make_mapchecker.pl as the variable mappairs.\n *\n */\n\n\nI'll do the following things later.\n\n> > --- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n> > +++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n> > # Drop these SJIS codes from the source for UTF8=>SJIS conversion\n> > #<<< do not let perltidy touch this\n> > -my @reject_sjis =(\n> > +my @reject_sjis = (\n> > 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\n> > - 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n> > + 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n> > 0x879a..0x879c\n> > -);\n> > + );\n> > This is not generated, it would be nice to drop the noise from the patch.\n> \n> Mmm. I'm not sure how this is generated but I'll care for that.\n> \n> > Here is another one:\n> > - $i->{code} = $jis | (\n> > - $jis < 0x100\n> > - ? 0x8e00\n> > - : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n> > -\n> > +#<<< do not let perltidy touch this\n> > + $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\n> > + ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n> > +#>>>\n> \n> Ok. Will revert this.\n> \n> > if (l == 2)\n> > {\n> > - iutf = *utf++ << 8;\n> > - iutf |= *utf++;\n> > + b3 = *utf++;\n> > + b4 = *utf++;\n> > }\n> > Ah, OK. This conversion is important so as it performs a minimum of\n> > bitwise operations. Yes let's keep that. That's pretty cool to get a\n> > faster operation.\n> \n> It is Heikki's work:p\n> \n> I'll address them and repost the next version sooner.\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 27 Jan 2017 17:33:57 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello, this is the revised version of character conversion using radix tree.\n\nAt Fri, 27 Jan 2017 17:33:57 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170127.173357.221584433.horiguchi.kyotaro@lab.ntt.co.jp>\n> Hi, this is an intermediate report without a patch.\n> \n> At Thu, 26 Jan 2017 21:42:12 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170126.214212.111556326.horiguchi.kyotaro@lab.ntt.co.jp>\n> > > > 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\n> > > >\n> > > > Before adding radix tree stuff, applied pgperltidy and inserted\n> > > > format-skipping pragma for the parts where perltidy seems to do\n> > > > too much.\n> > > \n> > > Which version of perltidy did you use? Looking at the archives, the\n> > > perl code is cleaned up with a specific version, v20090616. See\n> > > https://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\n> > > for example on the matter. As perltidy changes over time, this may be\n> > > a sensitive change if done this way.\n> \n> My perltidy -v said \"v20121207'. Anyway, I gave up to apply\n> perltidy by myself. So I'll just drop 0003 and new 0004 (name\n> changed to 0003) is made immediately on 0002.\n\nI'm not sure what to handle this so I just removed the perltidy\nstuff from this patchset.\n\n> > > > 0004-Use-radix-tree-for-character-conversion.patch\n> > > >\n> > > > Radix tree body.\n> > > \n> > > Well, here a lot of diffs could have been saved.\n> > > \n> > > > The unattached fifth patch is generated by the following steps.\n> > > >\n> > > > [$(TOP)]$ ./configure\n> > > > [Unicode]$ make\n> > > > [Unicode]$ make distclean\n> > > > [Unicode]$ git add .\n> > > > [Unicode]$ commit\n> > > > === COMMITE MESSSAGE\n> > > > Replace map files with radix tree files.\n> > > >\n> > > > These encodings no longer uses the former map files and uses new radix\n> > > > tree files.\n> > > > ===\n> > > \n> > > OK, I can see that working, with 200k of maps generated.. So going\n> > > through the important bits of this jungle..\n> > \n> > Many thaks for the exploration.\n> > \n> > > +/*\n> > > + * radix tree conversion function - this should be identical to the function in\n> > > + * ../conv.c with the same name\n> ..\n> > > This is not nice. Having a duplication like that is a recipe to forget\n> > > about it as this patch introduces a dependency with conv.c and the\n> > > radix tree generation.\n> \n> In the attatched patch, mb/char_conveter.c which contains one\n> inline function is created and it is includ'ed from mb/conv.c and\n> mb/Unicode/map_checker.c.\n> \n> > > Having a .gitignore in Unicode/ would be nice, particularly to avoid\n> > > committing map_checker.\n> \n> I missed this. I added .gitignore to ignore map_checker stuff\n> and authority files and old-style map files.\n> \n> > > A README documenting things may be welcome, or at least comments at\n> > > the top of map_checker.c. Why is map_checker essential? What does it\n> > > do? There is no way to understand that easily, except that it includes\n> > > a \"radix tree conversion function\", and that it performs sanity checks\n> > > on the radix trees to be sure that they are on a good shape. But as\n> > > this something that one would guess only after looking at your patch\n> > > and the code (at least I will sleep less stupid tonight after reading\n> > > this stuff).\n> > \n> > Okay, I'll do that.\n> \n> The patch has not been provided yet, I'm going to put the\n> following comment just before the main() in map_checker.c.\n> \n> /*\n> * The old-style plain map files were error-resistant due to its\n> * straight-forward way for generation from authority files. In contrast the\n> * radix tree maps are generated by a rather complex calculation and have a\n> * complex, hard-to-confirm format.\n> *\n> * This program runs sanity check of the radix tree maps by confirming all\n> * characters in the plain map files to be converted to the same code by the\n> * corresponding radix tree map.\n> *\n> * All map files are included by map_checker.h that is generated by the script\n> * make_mapchecker.pl as the variable mappairs.\n> *\n> */\n> \n> \n> I'll do the following things later.\n\nThe following is the continuation.\n\n> > --- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n> > +++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\n> > # Drop these SJIS codes from the source for UTF8=>SJIS conversion\n> > #<<< do not let perltidy touch this\n> > -my @reject_sjis =(\n> > +my @reject_sjis = (\n> > 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\n> > - 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n> > + 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\n> > 0x879a..0x879c\n> > -);\n> > + );\n> > This is not generated, it would be nice to drop the noise from the patch.\n> \n> Mmm. I'm not sure how this is generated but I'll care for that.\n\nI don't still understand what what the intermediate diff comes\nfrom but copy-n-pasting from master silenced it...\n\n> > Here is another one:\n> > - $i->{code} = $jis | (\n> > - $jis < 0x100\n> > - ? 0x8e00\n> > - : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n> > -\n> > +#<<< do not let perltidy touch this\n> > + $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\n> > + ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\n> > +#>>>\n> \n> Ok. Will revert this.\n\nThe \"previous\" code (prefixed with a minus sign) is \"my\"\nperltidy's work. Preltidy step is just removed from the patchset.\n\n> > if (l == 2)\n> > {\n> > - iutf = *utf++ << 8;\n> > - iutf |= *utf++;\n> > + b3 = *utf++;\n> > + b4 = *utf++;\n> > }\n> > Ah, OK. This conversion is important so as it performs a minimum of\n> > bitwise operations. Yes let's keep that. That's pretty cool to get a\n> > faster operation.\n> \n> It is Heikki's work:p\n> \n> I'll address them and repost the next version sooner.\n\n\nFinally, the patchset had the following changes from the previous\nshape.\n\n- Avoid syntaxes perl 5.8 complains about\n\n- The perltidy step has been removed.\n\n- pg_mb_radix_conv is now a separate .c file (but included from\n other c files)\n\n- Added Unicode/.gitignore. The line for [~#] might be needless.\n\n- The patchset are made with --irreversible-delete. This is just\n what I wanted (but counldn't find by myself..)\n\n- Semicolon-fix patch(0001) gets several additional fixes.\n\n\n\nThis patchset consists of four patches. The first two are bug\nfixes back-patchable to older versions. The third one is the\npatch that adds radix tree feature. The forth one is not attached\nto this mail but generatable.\n\n0001-Add-missing-semicolon.patch\n\n Adds missing semicolon found in three files.\n\n0002-Correct-reference-resolution-syntax.patch\n\n Changes reference syntax to more preferable style.\n\n0003-Use-radix-tree-for-character-conversion.patch\n\n Radix tree conversion patch. The size has been reduced from\n 1.6MB to 91KB.\n\n0004: Replace map files\n\n This is not attached but generatable. This shouldn't fail even\n on the environment with perl 5.8.\n\n [$(TOP)]$ ./configure\n [$(TOP)]$ cd src/backend/utils/mb/Unicode\n [Unicode]$ make distclean maintainer-clean all\n [Unicode]$ make mapcheck\n ...\n All radix trees are perfect!\n [Unicode]$ make distclean\n [Unicode]$ git add .\n [Unicode]$ git commit\n ...\n\n The size of the forth patch was about 7.6MB using --irreversible-delete.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 30 Jan 2017 15:37:38 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Mon, Jan 30, 2017 at 3:37 PM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> Hello, this is the revised version of character conversion using radix tree.\n\nThanks for the new version, I'll look at it once I am done with the\ncleanup of the current CF. For now I have moved it to the CF 2017-03.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 31 Jan 2017 12:25:46 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"At Tue, 31 Jan 2017 12:25:46 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqSGWmHwZqaOA--EHCveG9m77pjWRzxZ6B5iUSJ7GKz-4w@mail.gmail.com>\n> On Mon, Jan 30, 2017 at 3:37 PM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> > Hello, this is the revised version of character conversion using radix tree.\n> \n> Thanks for the new version, I'll look at it once I am done with the\n> cleanup of the current CF. For now I have moved it to the CF 2017-03.\n\nAgreed. Thank you.\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 31 Jan 2017 19:06:09 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Tnanks to that Heikki have pushed the first two patches and a\npart of the third, only one patch is remaining now.\n\n# Sorry for not separating KOI8 stuffs.\n\nAt Tue, 31 Jan 2017 19:06:09 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170131.190609.254672218.horiguchi.kyotaro@lab.ntt.co.jp>\n> > Thanks for the new version, I'll look at it once I am done with the\n> > cleanup of the current CF. For now I have moved it to the CF 2017-03.\n> \n> Agreed. Thank you.\n\nAttached is the latest version on the current master (555494d).\n\nNote: since this patch is created by git diff --irreversble-delete,\nthree files mb/Unicode/*.(txt|xml) to be deleted are left alone.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 03 Feb 2017 13:18:26 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Fri, Feb 3, 2017 at 1:18 PM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> Thanks to that Heikki have pushed the first two patches and a\n> part of the third, only one patch is remaining now.\n>\n> # Sorry for not separating KOI8 stuffs.\n>\n> At Tue, 31 Jan 2017 19:06:09 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170131.190609.254672218.horiguchi.kyotaro@lab.ntt.co.jp>\n>> > Thanks for the new version, I'll look at it once I am done with the\n>> > cleanup of the current CF. For now I have moved it to the CF 2017-03.\n>>\n>> Agreed. Thank you.\n>\n> Attached is the latest version on the current master (555494d).\n>\n> Note: since this patch is created by git diff --irreversble-delete,\n> three files mb/Unicode/*.(txt|xml) to be deleted are left alone.\n\nThanks for the rebase. I have been spending sore time looking at this\npatch. The new stuff in convutils.pm is by far the interesting part of\nthe patch, where the building of the radix trees using a byte\nstructure looks in pretty good shape after eyeballing the logic for a\ncouple of hours.\n\n+# ignore backup files of editors\n+/*[~#]\n+\nThis does not belong to Postgres core code. You could always set up\nthat in a global exclude file with core.excludefiles.\n\nIn order to conduct sanity checks on the shape of the radix tree maps\ncompared to the existing maps, having map_checker surely makes sense.\nNow in the final result I don't think we need it. The existing map\nfiles ought to be replaced by their radix versions at the end, and\nmap_checker should be removed. This leads to a couple of\nsimplifications, like Makefile, and reduces the maintenance to one\nmechanism.\n\n+sub print_radix_trees\n+{\n+ my ($this_script, $csname, $charset) = @_;\n+\n+ &print_radix_map($this_script, $csname, \"from_unicode\", $charset, 78);\n+ &print_radix_map($this_script, $csname, \"to_unicode\", $charset, 78);\n+}\nThere is no need for the table width to be defined as a variable (5th\nargument). Similarly, to_unicode/from_unicode require checks in\nmultiple places, this could be just a simple boolean flag. Or if you\nwant to go to the road of non-simple things, you could have two\narguments: an origin and a target. If one is UTF8 the other is the\nmapping name.\n\n+sub dump_charset\n+{\n+ my ($list, $filt) = @_;\n+\n+ foreach my $i (@$list)\n+ {\n+ next if (defined $filt && !&$filt($i));\n+ if (!defined $i->{ucs}) { $i->{ucs} = &utf2ucs($i->{utf8}); }\n+ printf \"ucs=%x, code=%x, direction=%s %s:%d %s\\n\",\n+ $i->{ucs}, $i->{code}, $i->{direction},\n+ $i->{f}, $i->{l}, $i->{comment};\n+ }\n+}\nThis is used nowhere. Perhaps it was useful for debugging at some point?\n\n+# make_charmap - convert charset table to charmap hash\n+# with checking duplicate source code\nMaybe this should be \"with checking of duplicated source codes\".\n\n+# print_radix_map($this_script, $csname, $direction, \\%charset, $tblwidth)\n+#\n+# this_script - the name of the *caller script* of this feature\n$this_script is not needed at all, you could just use basename($0) and\nreduce the number of arguments of the different functions of the\nstack.\n\n+ ### amount of zeros that can be ovarlaid.\ns/ovarlaid/overlaid.\n\n+# make_mapchecker.pl - Gerates map_checker.h file included by map_checker.c\ns/gerates/generates/\n\n+ if (s < 0x80)\n+ {\n+ fprintf(stderr, \"\\nASCII character ? (%x)\", s);\n+ exit(1);\n+ }\nMost likely a newline at the end of the error string is better here.\n\n+ $charmap{ ucs2utf($src) } = $dst;\n+ }\n+\n+ }\nUnnecessary newline here.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 22 Feb 2017 16:06:14 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Thank you for the comment.\n\nAt Wed, 22 Feb 2017 16:06:14 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqRTQ+7ZjxuPTbsr18MXvW7mTd29mN+91N7AG8fe5aCeAA@mail.gmail.com>\n> Thanks for the rebase. I have been spending sore time looking at this\n> patch. The new stuff in convutils.pm is by far the interesting part of\n> the patch, where the building of the radix trees using a byte\n> structure looks in pretty good shape after eyeballing the logic for a\n> couple of hours.\n> \n> +# ignore backup files of editors\n> +/*[~#]\n> +\n> This does not belong to Postgres core code. You could always set up\n> that in a global exclude file with core.excludefiles.\n\nThank you for letting me know about it. I removed that.\n\n> In order to conduct sanity checks on the shape of the radix tree maps\n> compared to the existing maps, having map_checker surely makes sense.\n> Now in the final result I don't think we need it. The existing map\n> files ought to be replaced by their radix versions at the end, and\n> map_checker should be removed. This leads to a couple of\n> simplifications, like Makefile, and reduces the maintenance to one\n> mechanism.\n\nHmm.. Though I don't remember clearly what the radix map of the\nfirst version looked like, the current radix map seems\nhuman-readable for me. It might be by practice or by additional\ncomments in map files. Anyway I removed all of the stuff so as\nnot to generate the plain maps. But I didn't change the names of\n_radix.map and just commented out the line to output the plain\nmaps in UCS_to_*.pl. Combined maps are still in the plain format\nso print_tables was changed to take character tables separately\nfor regular (non-combined) characters and combined characters.\n\n> +sub print_radix_trees\n> +{\n> + my ($this_script, $csname, $charset) = @_;\n> +\n> + &print_radix_map($this_script, $csname, \"from_unicode\", $charset, 78);\n> + &print_radix_map($this_script, $csname, \"to_unicode\", $charset, 78);\n> +}\n> There is no need for the table width to be defined as a variable (5th\n> argument).\n\nThe table width was already useless.. Removed.\n\n> Similarly, to_unicode/from_unicode require checks in\n> multiple places, this could be just a simple boolean flag.\n\nThe direction is a tristate (to/from/both) variable so cannot be\nreplaced with a boolean. But I agree that comparing with free\nstring is not so good. This is a change already committed in the\nmaster but it is changed in the attached patch.\n\n# Perhaps it is easier to read in string form..\n\n> Or if you want to go to the road of non-simple things, you\n> could have two arguments: an origin and a target. If one is\n> UTF8 the other is the mapping name.\n\nMmmm. It seems (even) to me to give more harm than good. I can\nguess two alternatives for this.\n\n- Split the property {direction} into two boolean properties\n {to_unicode} and {from_unicode}.\n\n- Make the {direction} property an integer and compared with\n defined constants $BOTH, $TO_UNICODE and $FROM_UNICODE using\n the '=' operator.\n\nI choosed the former in this patch.\n\n> +sub dump_charset\n> +{\n> + my ($list, $filt) = @_;\n> +\n> + foreach my $i (@$list)\n> + {\n> + next if (defined $filt && !&$filt($i));\n> + if (!defined $i->{ucs}) { $i->{ucs} = &utf2ucs($i->{utf8}); }\n> + printf \"ucs=%x, code=%x, direction=%s %s:%d %s\\n\",\n> + $i->{ucs}, $i->{code}, $i->{direction},\n> + $i->{f}, $i->{l}, $i->{comment};\n> + }\n> +}\n> This is used nowhere. Perhaps it was useful for debugging at some point?\n\nYes, it was quite useful. Removed.\n\n> +# make_charmap - convert charset table to charmap hash\n> +# with checking duplicate source code\n> Maybe this should be \"with checking of duplicated source codes\".\n\nEven though I'm not good English writer, 'duplicated codes' looks\nas multiple copies of the original 'code' (for me, of\ncourse). And the 'checking' is a (pure) verbal noun (means not a\ndeverbal noun) so 'of' is not required. But, of course, I'm not\nsure which sounds more natural as English.\n\nThis comment is not changed.\n\n> +# print_radix_map($this_script, $csname, $direction, \\%charset, $tblwidth)\n> +#\n> +# this_script - the name of the *caller script* of this feature\n> $this_script is not needed at all, you could just use basename($0) and\n> reduce the number of arguments of the different functions of the\n> stack.\n\nI avoided relying on global stuff by that but I accept the\nsuggestion. Fixed in this version.\n\n> + ### amount of zeros that can be ovarlaid.\n> s/ovarlaid/overlaid.\n> \n> +# make_mapchecker.pl - Gerates map_checker.h file included by map_checker.c\n> s/gerates/generates/\n\nmake_mapcheker.pl is a tool only for map_checker.c so this files\nis removed.\n\n> + if (s < 0x80)\n> + {\n> + fprintf(stderr, \"\\nASCII character ? (%x)\", s);\n> + exit(1);\n> + }\n> Most likely a newline at the end of the error string is better here.\n\nmap_checker.c is removed.\n\n> + $charmap{ ucs2utf($src) } = $dst;\n> + }\n> +\n> + }\n> Unnecessary newline here.\n\nremoved in convutils.pm.\n\nSince Makefile ignores old .map files, the steps to generate a\npatch for map files was a bit chaged.\n\n$ rm *.map\n$ make distclean maintainer-clean all\n$ make distclean\n$ git add .\n$ git commit\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 27 Feb 2017 17:37:33 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Mon, Feb 27, 2017 at 2:07 PM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>> +# make_charmap - convert charset table to charmap hash\n>> +# with checking duplicate source code\n>> Maybe this should be \"with checking of duplicated source codes\".\n>\n> Even though I'm not good English writer, 'duplicated codes' looks\n> as multiple copies of the original 'code' (for me, of\n> course). And the 'checking' is a (pure) verbal noun (means not a\n> deverbal noun) so 'of' is not required. But, of course, I'm not\n> sure which sounds more natural as English\n\nThe problem is that, because \"checking\" is a noun in this sentence, it\ncan't be followed by a direct object so you need \"of\" to connect\n\"checking\" with the thing that is being checked. However, what I\nwould do is rearrange this sentence slightly as to use \"checking\" as a\nverb, like this:\n\nconvert charset table to charmap hash, checking for duplicate source\ncodes along the way\n\nWhile I don't think Michael's suggestion is wrong, I find the above a\nlittle more natural.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 28 Feb 2017 08:00:22 +0530","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello,\n\nAt Tue, 28 Feb 2017 08:00:22 +0530, Robert Haas <robertmhaas@gmail.com> wrote in <CA+TgmoYheGx+knBQAMBm+nr8Cnr7e2RZm1BEwgK5AGMx4MKv9A@mail.gmail.com>\n> On Mon, Feb 27, 2017 at 2:07 PM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> >> +# make_charmap - convert charset table to charmap hash\n> >> +# with checking duplicate source code\n> >> Maybe this should be \"with checking of duplicated source codes\".\n> >\n> > Even though I'm not good English writer, 'duplicated codes' looks\n> > as multiple copies of the original 'code' (for me, of\n> > course). And the 'checking' is a (pure) verbal noun (means not a\n> > deverbal noun) so 'of' is not required. But, of course, I'm not\n> > sure which sounds more natural as English\n> \n> The problem is that, because \"checking\" is a noun in this sentence, it\n> can't be followed by a direct object so you need \"of\" to connect\n> \"checking\" with the thing that is being checked. However, what I\n> would do is rearrange this sentence slightly as to use \"checking\" as a\n> verb, like this:\n> \n> convert charset table to charmap hash, checking for duplicate source\n> codes along the way\n> \n> While I don't think Michael's suggestion is wrong, I find the above a\n> little more natural.\n\nThank you for the suggestion and explantion. I leaned that,\nmaybe. I'll send the version with the revised comment.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 28 Feb 2017 13:19:10 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Mon, Feb 27, 2017 at 5:37 PM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> At Wed, 22 Feb 2017 16:06:14 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqRTQ+7ZjxuPTbsr18MXvW7mTd29mN+91N7AG8fe5aCeAA@mail.gmail.com>\n>> In order to conduct sanity checks on the shape of the radix tree maps\n>> compared to the existing maps, having map_checker surely makes sense.\n>> Now in the final result I don't think we need it. The existing map\n>> files ought to be replaced by their radix versions at the end, and\n>> map_checker should be removed. This leads to a couple of\n>> simplifications, like Makefile, and reduces the maintenance to one\n>> mechanism.\n>\n> Hmm.. Though I don't remember clearly what the radix map of the\n> first version looked like, the current radix map seems\n> human-readable for me. It might be by practice or by additional\n> comments in map files. Anyway I removed all of the stuff so as\n> not to generate the plain maps. But I didn't change the names of\n> _radix.map and just commented out the line to output the plain\n> maps in UCS_to_*.pl. Combined maps are still in the plain format\n> so print_tables was changed to take character tables separately\n> for regular (non-combined) characters and combined characters.\n\nDo others have thoughts to offer on the matter? I would think that the\nnew radix maps should just replace by the old plain ones, and that the\nonly way to build the maps going forward is to use the new methods.\nThe radix trees is the only thing used in the backend code as well\n(conv.c). We could keep the way to build the old maps, with the\nmap_checker in module out of the core code. FWIW, I am fine to add the\nold APIs in my plugin repository on github and have the sanity checks\nin that as well. And of course also publish on this thread a module to\ndo that.\n\n>> Or if you want to go to the road of non-simple things, you\n>> could have two arguments: an origin and a target. If one is\n>> UTF8 the other is the mapping name.\n>\n> Mmmm. It seems (even) to me to give more harm than good. I can\n> guess two alternatives for this.\n>\n> - Split the property {direction} into two boolean properties\n> {to_unicode} and {from_unicode}.\n>\n> - Make the {direction} property an integer and compared with\n> defined constants $BOTH, $TO_UNICODE and $FROM_UNICODE using\n> the '=' operator.\n>\n> I choosed the former in this patch.\n\nFine for me.\n\n>> + $charmap{ ucs2utf($src) } = $dst;\n>> + }\n>> +\n>> + }\n>> Unnecessary newline here.\n>\n> removed in convutils.pm.\n>\n> Since Makefile ignores old .map files, the steps to generate a\n> patch for map files was a bit chaged.\n>\n> $ rm *.map\n> $ make distclean maintainer-clean all\n> $ make distclean\n> $ git add .\n> $ git commit\n\n+# ignore generated files\n+/map_checker\n+/map_checker.h\n[...]\n+map_checker.h: make_mapchecker.pl $(MAPS) $(RADIXMAPS)\n+ $(PERL) $<\n+\n+map_checker.o: map_checker.c map_checker.h ../char_converter.c\n+\n+map_checker: map_checker.o\nWith map_checker out of the game, those things are not needed.\n\n+++ b/src/backend/utils/mb/char_converter.c\n@@ -0,0 +1,116 @@\n+/*-------------------------------------------------------------------------\n+ *\n+ * Character converter function using radix tree\nIn the simplified version of the patch, pg_mb_radix_conv() being only\nneeded in conv.c I think that this could just be a static local\nroutine.\n\n-#include \"../../Unicode/utf8_to_koi8r.map\"\n-#include \"../../Unicode/koi8r_to_utf8.map\"\n-#include \"../../Unicode/utf8_to_koi8u.map\"\n-#include \"../../Unicode/koi8u_to_utf8.map\"\n+#include \"../../Unicode/utf8_to_koi8r_radix.map\"\n+#include \"../../Unicode/koi8r_to_utf8_radix.map\"\n+#include \"../../Unicode/utf8_to_koi8u_radix.map\"\n+#include \"../../Unicode/koi8u_to_utf8_radix.map\"\nFWIW, I am fine to use those new names as include points.\n\n-distclean: clean\n+distclean:\n rm -f $(TEXTS)\n-maintainer-clean: distclean\n+# maintainer-clean intentionally leaves $(TEXTS)\n+maintainer-clean:\nWhy is that? There is also a useless diff down that code block.\n\n+conv.o: conv.c char_converter.c\nThis also can go away.\n\n-print_tables(\"EUC_JIS_2004\", \\@all, 1);\n+# print_tables(\"EUC_JIS_2004\", \\@regular, undef, 1);\n+print_radix_trees(\"EUC_JIS_2004\", \\@regular);\n+print_tables(\"EUC_JIS_2004\", undef, \\@combined, 1);\n[...]\n sub print_tables\n {\n- my ($charset, $table, $verbose) = @_;\n+ my ($charset, $regular, $combined, $verbose) = @_;\nprint_tables is only used for combined maps, you could remove $regular\nfrom it and just keep $combined around, perhaps renaming print_tables\nto print_combined_maps?\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 28 Feb 2017 15:20:06 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"At Tue, 28 Feb 2017 15:20:06 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqR49krGP6qaaKaL2v3HCnn+dnzv8Dq_ySGbDSr6b_ywrw@mail.gmail.com>\n> On Mon, Feb 27, 2017 at 5:37 PM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> > At Wed, 22 Feb 2017 16:06:14 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqRTQ+7ZjxuPTbsr18MXvW7mTd29mN+91N7AG8fe5aCeAA@mail.gmail.com>\n> >> In order to conduct sanity checks on the shape of the radix tree maps\n> >> compared to the existing maps, having map_checker surely makes sense.\n> >> Now in the final result I don't think we need it. The existing map\n> >> files ought to be replaced by their radix versions at the end, and\n> >> map_checker should be removed. This leads to a couple of\n> >> simplifications, like Makefile, and reduces the maintenance to one\n> >> mechanism.\n> >\n> > Hmm.. Though I don't remember clearly what the radix map of the\n> > first version looked like, the current radix map seems\n> > human-readable for me. It might be by practice or by additional\n> > comments in map files. Anyway I removed all of the stuff so as\n> > not to generate the plain maps. But I didn't change the names of\n> > _radix.map and just commented out the line to output the plain\n> > maps in UCS_to_*.pl. Combined maps are still in the plain format\n> > so print_tables was changed to take character tables separately\n> > for regular (non-combined) characters and combined characters.\n> \n> Do others have thoughts to offer on the matter? I would think that the\n> new radix maps should just replace by the old plain ones, and that the\n> only way to build the maps going forward is to use the new methods.\n> The radix trees is the only thing used in the backend code as well\n> (conv.c). We could keep the way to build the old maps, with the\n> map_checker in module out of the core code. FWIW, I am fine to add the\n> old APIs in my plugin repository on github and have the sanity checks\n> in that as well. And of course also publish on this thread a module to\n> do that.\n\nI couldn't make out my mind to move to radix tree completely, but\nUtfToLocal/LocalToUtf no longer handle the \"plain map\"s for\nnon-combined character so they have lost their planground. Okay,\nI think I removed all the trace of the plain map era.\n\nEvery characters in a mapping has a comment that describes what\nthe character is or where it is defined. This information is no\nlonger useful (radix map doesn't have a plance to show it) but\nI left it for debug use. (This might just be justification..)\n\n> > - Split the property {direction} into two boolean properties\n> > {to_unicode} and {from_unicode}.\n> >\n> > - Make the {direction} property an integer and compared with\n> > defined constants $BOTH, $TO_UNICODE and $FROM_UNICODE using\n> > the '=' operator.\n> >\n> > I choosed the former in this patch.\n> \n> Fine for me.\n\nThanks.\n\n> >> + $charmap{ ucs2utf($src) } = $dst;\n> >> + }\n> >> +\n> >> + }\n> >> Unnecessary newline here.\n> >\n> > removed in convutils.pm.\n> >\n> > Since Makefile ignores old .map files, the steps to generate a\n> > patch for map files was a bit chaged.\n> >\n> > $ rm *.map\n> > $ make distclean maintainer-clean all\n> > $ make distclean\n> > $ git add .\n> > $ git commit\n> \n> +# ignore generated files\n> +/map_checker\n> +/map_checker.h\n> [...]\n> +map_checker.h: make_mapchecker.pl $(MAPS) $(RADIXMAPS)\n> + $(PERL) $<\n> +\n> +map_checker.o: map_checker.c map_checker.h ../char_converter.c\n> +\n> +map_checker: map_checker.o\n> With map_checker out of the game, those things are not needed.\n\nOuch! Thanks for pointing out it. Removed.\n\n> +++ b/src/backend/utils/mb/char_converter.c\n> @@ -0,0 +1,116 @@\n> +/*-------------------------------------------------------------------------\n> + *\n> + * Character converter function using radix tree\n> In the simplified version of the patch, pg_mb_radix_conv() being only\n> needed in conv.c I think that this could just be a static local\n> routine.\n> \n> -#include \"../../Unicode/utf8_to_koi8r.map\"\n> -#include \"../../Unicode/koi8r_to_utf8.map\"\n> -#include \"../../Unicode/utf8_to_koi8u.map\"\n> -#include \"../../Unicode/koi8u_to_utf8.map\"\n> +#include \"../../Unicode/utf8_to_koi8r_radix.map\"\n> +#include \"../../Unicode/koi8r_to_utf8_radix.map\"\n> +#include \"../../Unicode/utf8_to_koi8u_radix.map\"\n> +#include \"../../Unicode/koi8u_to_utf8_radix.map\"\n> FWIW, I am fine to use those new names as include points.\n> \n> -distclean: clean\n> +distclean:\n> rm -f $(TEXTS)\n> -maintainer-clean: distclean\n> +# maintainer-clean intentionally leaves $(TEXTS)\n> +maintainer-clean:\n> Why is that? There is also a useless diff down that code block.\n\nIt *was* for convenience but now it is automatically downloaded\nso such distinction donsn't offer anything good. Changed it to\nremove $(TEXTS).\n\n> +conv.o: conv.c char_converter.c\n> This also can go away.\n\nTouching char_converter.c will be ignored if it is removed. Did\nyou mistake it for map_checker?\n\n> -print_tables(\"EUC_JIS_2004\", \\@all, 1);\n> +# print_tables(\"EUC_JIS_2004\", \\@regular, undef, 1);\n> +print_radix_trees(\"EUC_JIS_2004\", \\@regular);\n> +print_tables(\"EUC_JIS_2004\", undef, \\@combined, 1);\n> [...]\n> sub print_tables\n> {\n> - my ($charset, $table, $verbose) = @_;\n> + my ($charset, $regular, $combined, $verbose) = @_;\n> print_tables is only used for combined maps, you could remove $regular\n> from it and just keep $combined around, perhaps renaming print_tables\n> to print_combined_maps?\n\nRenamed to print_combied_maps.\n\nAnd the code-comment pointed in the comment by the previous mail\nis rewritten as Robert's suggestion.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 28 Feb 2017 17:34:02 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Tue, Feb 28, 2017 at 5:34 PM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> At Tue, 28 Feb 2017 15:20:06 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqR49krGP6qaaKaL2v3HCnn+dnzv8Dq_ySGbDSr6b_ywrw@mail.gmail.com>\n>> +conv.o: conv.c char_converter.c\n>> This also can go away.\n>\n> Touching char_converter.c will be ignored if it is removed. Did\n> you mistake it for map_checker?\n\nThat was not what I meant: as pg_mb_radix_conv() is only used in\nconv.c, it may be better to just remove completely char_converter.c.\n\n> And the code-comment pointed in the comment by the previous mail\n> is rewritten as Robert's suggestion.\n\nFine for me.\n\n-distclean: clean\n+distclean:\n rm -f $(TEXTS)\n\n-maintainer-clean: distclean\n- rm -f $(MAPS)\n-\n+maintainer-clean:\n+ rm -f $(TEXTS) $(MAPS)\nWell, I would have assumed that this should not change..\n\nThe last version of the patch looks in rather good shape to me, we are\nalso sure that the sanity checks on the old maps and the new maps\nmatch per the previous runs with map_checker. One thing that still\nneed some extra opinions is what to do with the old maps:\n1) Just remove them, replacing the old maps by the new radix tree maps.\n2) Keep them around in the backend code, even if they are useless.\n3) Use a GUC to be able to switch from one to the other, giving a\nfallback method in case of emergency.\n4) Use an extension module to store the old maps with as well the\nprevious build code, so as sanity checks can still be performed on the\nnew maps.\n\nI would vote for 2), to reduce long term maintenance burdens and after\nseeing all the sanity checks that have been done in previous versions.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 1 Mar 2017 14:34:23 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"At Wed, 1 Mar 2017 14:34:23 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqQ_4n+FDWi5Xiueo68i=fTmdg1Wx+y6XWWX=8rAhKRtFw@mail.gmail.com>\n> On Tue, Feb 28, 2017 at 5:34 PM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> > At Tue, 28 Feb 2017 15:20:06 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqR49krGP6qaaKaL2v3HCnn+dnzv8Dq_ySGbDSr6b_ywrw@mail.gmail.com>\n> >> +conv.o: conv.c char_converter.c\n> >> This also can go away.\n> >\n> > Touching char_converter.c will be ignored if it is removed. Did\n> > you mistake it for map_checker?\n> \n> That was not what I meant: as pg_mb_radix_conv() is only used in\n> conv.c, it may be better to just remove completely char_converter.c.\n\nOuch! You're right. Sorry for my short-sight. char_converter.c is\nremoved and related description in Makefile is removed.\n\n> > And the code-comment pointed in the comment by the previous mail\n> > is rewritten as Robert's suggestion.\n> \n> Fine for me.\n> \n> -distclean: clean\n> +distclean:\n> rm -f $(TEXTS)\n> \n> -maintainer-clean: distclean\n> - rm -f $(MAPS)\n> -\n> +maintainer-clean:\n> + rm -f $(TEXTS) $(MAPS)\n> Well, I would have assumed that this should not change..\n\nI should have reverted there but actually the patch somehow does\nthe different thing.. Surely reverted it this time.\n\n> The last version of the patch looks in rather good shape to me, we are\n> also sure that the sanity checks on the old maps and the new maps\n> match per the previous runs with map_checker.\n\nAgreed.\n\n> One thing that still\n> need some extra opinions is what to do with the old maps:\n> 1) Just remove them, replacing the old maps by the new radix tree maps.\n> 2) Keep them around in the backend code, even if they are useless.\n> 3) Use a GUC to be able to switch from one to the other, giving a\n> fallback method in case of emergency.\n> 4) Use an extension module to store the old maps with as well the\n> previous build code, so as sanity checks can still be performed on the\n> new maps.\n> \n> I would vote for 2), to reduce long term maintenance burdens and after\n> seeing all the sanity checks that have been done in previous versions.\n\nI don't vote 3 and 4. And I did 1 in the last patch.\n\nAbout 2, any change in the authority files rarely but possiblly\nhappens. Even in the case the plain map files are no longer can\nbe generated. (but can with a bit tweak of convutils.pm) If the\nradix-tree file generator is under a suspicion, the \"plain\" map\nfile generator (and the map_checker) or some other means to\nsanity check might be required.\n\nThat being said, when something occurs in radix files, we can\nfind it in the radix file and can find the corresponding lines in\nthe aurhority file. The remaining problem is the case where some\nsubstantial change in authority files doesn't affect radix\nfiles. We can detect such mistake by detecting changes in\nauthority files. So I propose the 5th option.\n\n5) Just remove plain map files and all related code. Addition to\n that, Makefile stores hash digest of authority files in\n Unicode/authoriy_hashes.txt or something that is managed by\n git.\n\nThis digest may differ among platforms (typically from cr/nl\ndifference) but we can assume *nix for the usage.\n\nI will send the next version after this discussion is settled.\n\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 02 Mar 2017 14:20:00 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Thu, Mar 2, 2017 at 2:20 PM, Kyotaro HORIGUCHI\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> 5) Just remove plain map files and all related code. Addition to\n> that, Makefile stores hash digest of authority files in\n> Unicode/authoriy_hashes.txt or something that is managed by\n> git.\n\nThat may be an idea to check for differences across upstream versions.\nBut that sounds like a separate discussion to me.\n\n> This digest may differ among platforms (typically from cr/nl\n> difference) but we can assume *nix for the usage.\n>\n> I will send the next version after this discussion is settled.\n\nSure. There is not much point to move on without Heikki's opinion at\nleast, or anybody else like Ishii-san or Tom who are familiar with\nthis code. I would think that Heikki would be the committer to pick up\nthis change though.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 3 Mar 2017 12:53:04 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello,\n\nAt Fri, 3 Mar 2017 12:53:04 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqSQaLozFNg+5Tf9s1TZs2pcE-GHhnMG31qnsusV9vMUOw@mail.gmail.com>\n> On Thu, Mar 2, 2017 at 2:20 PM, Kyotaro HORIGUCHI\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n> > 5) Just remove plain map files and all related code. Addition to\n> > that, Makefile stores hash digest of authority files in\n> > Unicode/authoriy_hashes.txt or something that is managed by\n> > git.\n> \n> That may be an idea to check for differences across upstream versions.\n> But that sounds like a separate discussion to me.\n\nFine with me either.\n\n> > This digest may differ among platforms (typically from cr/nl\n> > difference) but we can assume *nix for the usage.\n> >\n> > I will send the next version after this discussion is settled.\n> \n> Sure. There is not much point to move on without Heikki's opinion at\n> least, or anybody else like Ishii-san or Tom who are familiar with\n> this code. I would think that Heikki would be the committer to pick up\n> this change though.\n\nSo, this is the latest version of this patch in the shape of the\noption 1.\n\n\n| need some extra opinions is what to do with the old maps:\n| 1) Just remove them, replacing the old maps by the new radix tree maps.\n| 2) Keep them around in the backend code, even if they are useless.\n| 3) Use a GUC to be able to switch from one to the other, giving a\n| fallback method in case of emergency.\n| 4) Use an extension module to store the old maps with as well the\n| previous build code, so as sanity checks can still be performed on the\n| new maps.\n\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 06 Mar 2017 17:16:09 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 03/06/2017 10:16 AM, Kyotaro HORIGUCHI wrote:\n> At Fri, 3 Mar 2017 12:53:04 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqSQaLozFNg+5Tf9s1TZs2pcE-GHhnMG31qnsusV9vMUOw@mail.gmail.com>\n>> On Thu, Mar 2, 2017 at 2:20 PM, Kyotaro HORIGUCHI\n>> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\n>>> 5) Just remove plain map files and all related code. Addition to\n>>> that, Makefile stores hash digest of authority files in\n>>> Unicode/authoriy_hashes.txt or something that is managed by\n>>> git.\n>>\n>> That may be an idea to check for differences across upstream versions.\n>> But that sounds like a separate discussion to me.\n>\n> Fine with me either.\n\nI did some more kibitzing here and there, and committed. Thanks everyone!\n\nI agree the new maps should just replace the old maps altogether, so \ncommitted that way. I also moved the combined map files to the same .map \nfiles as the main radix trees. Seems more clear that way to me.\n\nI changed the to/from_unicode properties back to a single direction \nproperty, with Perl constants BOTH, TO_UNICODE and FROM_UNICODE, per \nyour alternative suggestion upthread. Seems more clear to me.\n\nIt would be nice to run the map_checker tool one more time, though, to \nverify that the mappings match those from PostgreSQL 9.6. Just to be \nsure, and after that the map checker can go to the dustbin.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 13 Mar 2017 20:48:07 +0200","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Heikki Linnakangas <hlinnaka@iki.fi> writes:\n> I did some more kibitzing here and there, and committed. Thanks everyone!\n\n111 files changed, 147742 insertions(+), 367346 deletions(-)\n\nNice.\n\n> It would be nice to run the map_checker tool one more time, though, to \n> verify that the mappings match those from PostgreSQL 9.6.\n\n+1\n\n> Just to be sure, and after that the map checker can go to the dustbin.\n\nHm, maybe we should keep it around for the next time somebody has a bright\nidea in this area?\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 13 Mar 2017 14:53:17 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 03/13/2017 08:53 PM, Tom Lane wrote:\n> Heikki Linnakangas <hlinnaka@iki.fi> writes:\n>> It would be nice to run the map_checker tool one more time, though, to\n>> verify that the mappings match those from PostgreSQL 9.6.\n>\n> +1\n>\n>> Just to be sure, and after that the map checker can go to the dustbin.\n>\n> Hm, maybe we should keep it around for the next time somebody has a bright\n> idea in this area?\n\nThe map checker compares old-style maps with the new radix maps. The \nnext time 'round, we'll need something that compares the radix maps with \nthe next great thing. Not sure how easy it would be to adapt.\n\nHmm. A somewhat different approach might be more suitable for testing \nacross versions, though. We could modify the perl scripts slightly to \nprint out SQL statements that exercise every mapping. For every \nsupported conversion, the SQL script could:\n\n1. create a database in the source encoding.\n2. set client_encoding='<target encoding>'\n3. SELECT a string that contains every character in the source encoding.\n\nYou could then run those SQL statements against old and new server \nversion, and verify that you get the same results.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 13 Mar 2017 21:07:39 +0200","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On Tue, Mar 14, 2017 at 4:07 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> On 03/13/2017 08:53 PM, Tom Lane wrote:\n>> Heikki Linnakangas <hlinnaka@iki.fi> writes:\n>>>\n>>> It would be nice to run the map_checker tool one more time, though, to\n>>> verify that the mappings match those from PostgreSQL 9.6.\n>>\n>> +1\n\nNice to login and see that committed!\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 14 Mar 2017 08:59:42 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Thank you for committing this.\n\nAt Mon, 13 Mar 2017 21:07:39 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <d5b70078-9f57-0f63-3462-1e564a57739f@iki.fi>\n> On 03/13/2017 08:53 PM, Tom Lane wrote:\n> > Heikki Linnakangas <hlinnaka@iki.fi> writes:\n> >> It would be nice to run the map_checker tool one more time, though, to\n> >> verify that the mappings match those from PostgreSQL 9.6.\n> >\n> > +1\n> >\n> >> Just to be sure, and after that the map checker can go to the dustbin.\n> >\n> > Hm, maybe we should keep it around for the next time somebody has a\n> > bright\n> > idea in this area?\n> \n> The map checker compares old-style maps with the new radix maps. The\n> next time 'round, we'll need something that compares the radix maps\n> with the next great thing. Not sure how easy it would be to adapt.\n> \n> Hmm. A somewhat different approach might be more suitable for testing\n> across versions, though. We could modify the perl scripts slightly to\n> print out SQL statements that exercise every mapping. For every\n> supported conversion, the SQL script could:\n> \n> 1. create a database in the source encoding.\n> 2. set client_encoding='<target encoding>'\n> 3. SELECT a string that contains every character in the source\n> encoding.\n\nThere are many encodings that can be client-encoding but cannot\nbe database-encoding. And some encodings such as UTF-8 has\nseveral one-way conversion. If we do something like this, it\nwould be as the following.\n\n1. Encoding test\n1-1. create a database in UTF-8\n1-2. set client_encoding='<source encoding>'\n1-3. INSERT all characters defined in the source encoding.\n1-4. set client_encoding='UTF-8'\n1-5. SELECT a string that contains every character in UTF-8.\n2. Decoding test\n\n.... sucks!\n\n\nI would like to use convert() function. It can be a large\nPL/PgSQL function or a series of \"SELECT convert(...)\"s. The\nlatter is doable on-the-fly (by not generating/storing the whole\nscript).\n\n| -- Test for SJIS->UTF-8 conversion\n| ...\n| SELECT convert('\\0000', 'SJIS', 'UTF-8'); -- results in error\n| ...\n| SELECT convert('\\897e', 'SJIS', 'UTF-8');\n\n> You could then run those SQL statements against old and new server\n> version, and verify that you get the same results.\n\nIncluding the result files in the repository will make this easy\nbut unacceptably bloats. Put mb/Unicode/README.sanity_check?\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 17 Mar 2017 14:19:31 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"On 03/17/2017 07:19 AM, Kyotaro HORIGUCHI wrote:\n> At Mon, 13 Mar 2017 21:07:39 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <d5b70078-9f57-0f63-3462-1e564a57739f@iki.fi>\n>> Hmm. A somewhat different approach might be more suitable for testing\n>> across versions, though. We could modify the perl scripts slightly to\n>> print out SQL statements that exercise every mapping. For every\n>> supported conversion, the SQL script could:\n>>\n>> 1. create a database in the source encoding.\n>> 2. set client_encoding='<target encoding>'\n>> 3. SELECT a string that contains every character in the source\n>> encoding.\n>\n> There are many encodings that can be client-encoding but cannot\n> be database-encoding.\n\nGood point.\n\n> I would like to use convert() function. It can be a large\n> PL/PgSQL function or a series of \"SELECT convert(...)\"s. The\n> latter is doable on-the-fly (by not generating/storing the whole\n> script).\n>\n> | -- Test for SJIS->UTF-8 conversion\n> | ...\n> | SELECT convert('\\0000', 'SJIS', 'UTF-8'); -- results in error\n> | ...\n> | SELECT convert('\\897e', 'SJIS', 'UTF-8');\n\nMakes sense.\n\n>> You could then run those SQL statements against old and new server\n>> version, and verify that you get the same results.\n>\n> Including the result files in the repository will make this easy\n> but unacceptably bloats. Put mb/Unicode/README.sanity_check?\n\nYeah, a README with instructions on how to do sounds good. No need to \ninclude the results in the repository, you can run the script against an \nolder version when you need something to compare with.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 17 Mar 2017 13:03:35 +0200","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hello,\n\nAt Fri, 17 Mar 2017 13:03:35 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <01efd334-b839-0450-1b63-f2dea9326a7e@iki.fi>\n> On 03/17/2017 07:19 AM, Kyotaro HORIGUCHI wrote:\n> > I would like to use convert() function. It can be a large\n> > PL/PgSQL function or a series of \"SELECT convert(...)\"s. The\n> > latter is doable on-the-fly (by not generating/storing the whole\n> > script).\n> >\n> > | -- Test for SJIS->UTF-8 conversion\n> > | ...\n> > | SELECT convert('\\0000', 'SJIS', 'UTF-8'); -- results in error\n> > | ...\n> > | SELECT convert('\\897e', 'SJIS', 'UTF-8');\n> \n> Makes sense.\n> \n> >> You could then run those SQL statements against old and new server\n> >> version, and verify that you get the same results.\n> >\n> > Including the result files in the repository will make this easy\n> > but unacceptably bloats. Put mb/Unicode/README.sanity_check?\n> \n> Yeah, a README with instructions on how to do sounds good. No need to\n> include the results in the repository, you can run the script against\n> an older version when you need something to compare with.\n\nOk, I'll write a small script to generate a set of \"conversion\ndump\" and try to write README.sanity_check describing how to use\nit.\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 21 Mar 2017 13:10:48 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"At Tue, 21 Mar 2017 13:10:48 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170321.131048.150321071.horiguchi.kyotaro@lab.ntt.co.jp>\n> At Fri, 17 Mar 2017 13:03:35 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <01efd334-b839-0450-1b63-f2dea9326a7e@iki.fi>\n> > On 03/17/2017 07:19 AM, Kyotaro HORIGUCHI wrote:\n> > > I would like to use convert() function. It can be a large\n> > > PL/PgSQL function or a series of \"SELECT convert(...)\"s. The\n> > > latter is doable on-the-fly (by not generating/storing the whole\n> > > script).\n> > >\n> > > | -- Test for SJIS->UTF-8 conversion\n> > > | ...\n> > > | SELECT convert('\\0000', 'SJIS', 'UTF-8'); -- results in error\n> > > | ...\n> > > | SELECT convert('\\897e', 'SJIS', 'UTF-8');\n> > \n> > Makes sense.\n> > \n> > >> You could then run those SQL statements against old and new server\n> > >> version, and verify that you get the same results.\n> > >\n> > > Including the result files in the repository will make this easy\n> > > but unacceptably bloats. Put mb/Unicode/README.sanity_check?\n> > \n> > Yeah, a README with instructions on how to do sounds good. No need to\n> > include the results in the repository, you can run the script against\n> > an older version when you need something to compare with.\n> \n> Ok, I'll write a small script to generate a set of \"conversion\n> dump\" and try to write README.sanity_check describing how to use\n> it.\n\nI found that there's no way to identify the character domain of a\nconversion on SQL interface. Unconditionally giving from 0 to\n0xffffffff as a bytea string yields too-bloat result by containg\nmany bogus lines. (If \\x40 is a character, convert() also\naccepts \\x4040, \\x404040 and \\x40404040)\n\nOne more annoyance is the fact that mappings and conversion\nprocedures are not in one-to-one correspondence. The\ncorresnponcence is hidden in conversion_procs/*.c files so we\nshould extract it from them or provide as knowledge. Both don't\nseem good.\n\nFinally, it seems that I have no choice than resurrecting\nmap_checker. The exactly the same one no longer works but\nmap_dumper.c with almost the same structure will work.\n\nIf no one objects to adding map_dumper.c and\ngen_mapdumper_header.pl (tentavie name, of course), I'll make a\npatch to do that.\n\nAny suggestions?\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 23 Mar 2017 12:13:07 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"},{"msg_contents":"Hmm, things are bit different.\n\nAt Thu, 23 Mar 2017 12:13:07 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170323.121307.241436413.horiguchi.kyotaro@lab.ntt.co.jp>\n> > Ok, I'll write a small script to generate a set of \"conversion\n> > dump\" and try to write README.sanity_check describing how to use\n> > it.\n> \n> I found that there's no way to identify the character domain of a\n> conversion on SQL interface. Unconditionally giving from 0 to\n> 0xffffffff as a bytea string yields too-bloat result by containg\n> many bogus lines. (If \\x40 is a character, convert() also\n> accepts \\x4040, \\x404040 and \\x40404040)\n> \n> One more annoyance is the fact that mappings and conversion\n> procedures are not in one-to-one correspondence. The\n> corresnponcence is hidden in conversion_procs/*.c files so we\n> should extract it from them or provide as knowledge. Both don't\n> seem good.\n> \n> Finally, it seems that I have no choice than resurrecting\n> map_checker. The exactly the same one no longer works but\n> map_dumper.c with almost the same structure will work.\n> \n> If no one objects to adding map_dumper.c and\n> gen_mapdumper_header.pl (tentavie name, of course), I'll make a\n> patch to do that.\n\nThe scirpt or executable should be compatible between versions\nbut pg_mb_radix_conv is not. On the other hand more upper level\nAPI reuiqres server stuff.\n\nFinally I made an extension that dumps encoding conversion.\n\nencoding_dumper('SJIS', 'UTF-8') or encoding_dumper(35, 6)\n\nThen it returns the following output consists of two BYTEAs.\n\n srccode | dstcode \n---------+----------\n \\x01 | \\x01\n \\x02 | \\x02\n...\n \\xfc4a | \\xe9b899\n \\xfc4b | \\xe9bb91\n(7914 rows)\n\nThis returns in a very short time but doesn't when srccode\nextends to 4 bytes. As an extreme example the following,\n\n> =# select * from encoding_dumper('UTF-8', 'LATIN1');\n\ntakes over 2 minutes to return only 255 rows. We cannot determine\nthe exact domain without looking into map data so the function\ncannot do other than looping through all the four-byte values.\nProviding a function that gives the domain for a conversion was a\nmess, especially for artithmetic-conversions. The following query\ntook 94 minutes to give 25M lines/125MB. In short, that's a\ncrap. (the first attached)\n\nSELECT x.conname, y.srccode, y.dstcode\nFROM\n (\n SELECT conname, conforencoding, contoencoding\n FROM pg_conversion c\n WHERE pg_char_to_encoding('UTF-8') IN (c.conforencoding, c.contoencoding)\n AND pg_char_to_encoding('SQL_ASCII')\n NOT IN (c.conforencoding, c.contoencoding)) as x,\n LATERAL (\n SELECT srccode, dstcode\n FROM encoding_dumper(x.conforencoding, x.contoencoding)) as y\nORDER BY x.conforencoding, x.contoencoding, y.srccode;\n\n\nAs the another way, I added a measure to generate plain mapping\nlists corresponding to .map files (similar to old maps but\nsimpler) and this finishes the work within a second.\n\n$ make mapdumps\n\nIf we will not shortly change the framework of mapped character\nconversion, the dumper program may be useful but I'm not sure\nthis is reasonable as sanity check for future modifications. In\nthe PoC, pg_mb_radix_tree() is copied into map_checker.c but this\nneeds to be a separate file again. (the second attached)\n\n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open Source Software Center\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 27 Mar 2017 19:05:43 +0900 (Tokyo Standard Time)","msg_from":"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Radix tree for character conversion"}],"string":"[\n {\n \"msg_contents\": \"Hello,\\n\\nI'd like to propose adding SJIS as a database encoding. You may wonder why SJIS is still necessary in the world of Unicode. The purpose is to achieve comparable performance when migrating legacy database systems from other DBMSs without little modification of applications.\\n\\nRecently, we failed to migrate some customer's legacy database from DBMS-X to PostgreSQL. That customer wished for PostgreSQL, but PostgreSQL couldn't meet the performance requirement.\\n\\nThe system uses DBMS-X with the database character set being SJIS. The main applications are written in embedded SQL, which require SJIS in their host variables. They insisted they cannot use UTF8 for the host variables because that would require large modification of applications due to character handling. So no character set conversion is necessary between the clients and the server.\\n\\nOn the other hand, PostgreSQL doesn't support SJIS as a database encoding. Therefore, character set conversion from UTF-8 to SJIS has to be performed. The batch application runs millions of SELECTS each of which retrieves more than 100 columns. And many of those columns are of character type.\\n\\nIf PostgreSQL supports SJIS, PostgreSQL will match or outperform the performance of DBMS-X with regard to the applications. We confirmed it by using psql to run a subset of the batch processing. When the client encoding is SJIS, one FETCH of 10,000 rows took about 500ms. When the client encoding is UTF8 (the same as the database encoding), the same FETCH took 270ms.\\n\\nSupporting SJIS may somewhat regain attention to PostgreSQL here in Japan, in the context of database migration. BTW, MySQL supports SJIS as a database encoding. PostgreSQL used to be the most popular open source database in Japan, but MySQL is now more popular.\\n\\n\\nBut what I'm wondering is why PostgreSQL doesn't support SJIS. Was there any technical difficulty? Is there anything you are worried about if adding SJIS?\\n\\nI'd like to write a patch for adding SJIS if there's no strong objection. I'd appreciate it if you could let me know good design information to add a server encoding (e.g. the URL of the most recent patch to add a new server encoding)\\n\\nRegards\\nTakayuki Tsunakawa\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 07:23:21 +0000\",\n \"msg_from\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"> But what I'm wondering is why PostgreSQL doesn't support SJIS. Was there any technical difficulty? Is there anything you are worried about if adding SJIS?\\n\\nYes, there's a technical difficulty with backend code. In many places\\nit is assumed that any string is \\\"ASCII compatible\\\", which means no\\nASCII character is used as a part of multi byte string. Here is such a\\nrandom example from src/backend/util/adt/varlena.c:\\n\\n\\t/* Else, it's the traditional escaped style */\\n\\tfor (bc = 0, tp = inputText; *tp != '\\\\0'; bc++)\\n\\t{\\n\\t\\tif (tp[0] != '\\\\\\\\')\\n\\t\\t\\ttp++;\\n\\nSometimes SJIS uses '\\\\' as the second byte of it.\\n\\nBest regards,\\n--\\nTatsuo Ishii\\nSRA OSS, Inc. Japan\\nEnglish: http://www.sraoss.co.jp/index_en.php\\nJapanese:http://www.sraoss.co.jp\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 05 Sep 2016 16:38:54 +0900 (JST)\",\n \"msg_from\": \"Tatsuo Ishii <ishii@sraoss.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"> From: pgsql-hackers-owner@postgresql.org\\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Tatsuo Ishii\\n> > But what I'm wondering is why PostgreSQL doesn't support SJIS. Was there\\n> any technical difficulty? Is there anything you are worried about if adding\\n> SJIS?\\n> \\n> Yes, there's a technical difficulty with backend code. In many places it\\n> is assumed that any string is \\\"ASCII compatible\\\", which means no ASCII\\n> character is used as a part of multi byte string. Here is such a random\\n> example from src/backend/util/adt/varlena.c:\\n> \\n> \\t/* Else, it's the traditional escaped style */\\n> \\tfor (bc = 0, tp = inputText; *tp != '\\\\0'; bc++)\\n> \\t{\\n> \\t\\tif (tp[0] != '\\\\\\\\')\\n> \\t\\t\\ttp++;\\n> \\n> Sometimes SJIS uses '\\\\' as the second byte of it.\\n\\nThanks, I'll try to understand the seriousness of the problem as I don't have good knowledge of character sets. But your example seems to be telling everything about the difficulty...\\n\\nBefore digging into the problem, could you share your impression on whether PostgreSQL can support SJIS? Would it be hopeless? Can't we find any direction to go? Can I find relevant source code by searching specific words like \\\"ASCII\\\", \\\"HIGH_BIT\\\", \\\"\\\\\\\\\\\" etc?\\n\\nRegards\\nTakayuki Tsunakawa\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 08:00:06 +0000\",\n \"msg_from\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"> Before digging into the problem, could you share your impression on whether PostgreSQL can support SJIS? Would it be hopeless? Can't we find any direction to go? Can I find relevant source code by searching specific words like \\\"ASCII\\\", \\\"HIGH_BIT\\\", \\\"\\\\\\\\\\\" etc?\\n\\nFor starters, you could grep \\\"multibyte\\\".\\n\\nBest regards,\\n--\\nTatsuo Ishii\\nSRA OSS, Inc. Japan\\nEnglish: http://www.sraoss.co.jp/index_en.php\\nJapanese:http://www.sraoss.co.jp\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 05 Sep 2016 17:19:25 +0900 (JST)\",\n \"msg_from\": \"Tatsuo Ishii <ishii@sraoss.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com> writes:\\n> Before digging into the problem, could you share your impression on\\n> whether PostgreSQL can support SJIS? Would it be hopeless?\\n\\nI think it's pretty much hopeless. Even if we were willing to make every\\nbit of code that looks for '\\\\' and other specific at-risk characters\\nmulti-byte aware (with attendant speed penalties), we could expect that\\nthird-party extensions would still contain vulnerable code. More, we\\ncould expect that new bugs of the same ilk would get introduced all the\\ntime. Many such bugs would amount to security problems. So the amount of\\neffort and vigilance required seems out of proportion to the benefits.\\n\\nMost of the recent discussion about allowed backend encodings has run\\nmore in the other direction, ie, \\\"why don't we disallow everything but\\nUTF8 and get rid of all the infrastructure for multiple backend\\nencodings?\\\". I'm not personally in favor of that, but there are very\\nfew hackers who want to add any more overhead in this area.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 05 Sep 2016 10:47:15 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"On 09/05/2016 05:47 PM, Tom Lane wrote:\\n> \\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com> writes:\\n>> Before digging into the problem, could you share your impression on\\n>> whether PostgreSQL can support SJIS? Would it be hopeless?\\n>\\n> I think it's pretty much hopeless.\\n\\nAgreed.\\n\\nBut one thing that would help a little, would be to optimize the UTF-8 \\n-> SJIS conversion. It uses a very generic routine, with a binary search \\nover a large array of mappings. I bet you could do better than that, \\nmaybe using a hash table or a radix tree instead of the large \\nbinary-searched array.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 19:38:33 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"From: Tom Lane [mailto:tgl@sss.pgh.pa.us]\\n> \\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com> writes:\\n> > Before digging into the problem, could you share your impression on\\n> > whether PostgreSQL can support SJIS? Would it be hopeless?\\n> \\n> I think it's pretty much hopeless. Even if we were willing to make every\\n> bit of code that looks for '\\\\' and other specific at-risk characters\\n> multi-byte aware (with attendant speed penalties), we could expect that\\n> third-party extensions would still contain vulnerable code. More, we could\\n> expect that new bugs of the same ilk would get introduced all the time.\\n> Many such bugs would amount to security problems. So the amount of effort\\n> and vigilance required seems out of proportion to the benefits.\\n\\nHmm, this sounds like a death sentence. But as I don't have good knowledge of character set handling yet, I'm not completely convinced about why PostgreSQL cannot support SJIS. I wonder why and how other DBMSs support SJIS and what's the difference of the implementation. Using multibyte-functions like mb... to process characters would solve the problem? Isn't the current implementation blocking the support of other character sets that have similar characteristics? I'll learn the character set handling...\\n\\n> Most of the recent discussion about allowed backend encodings has run more\\n> in the other direction, ie, \\\"why don't we disallow everything but\\n> UTF8 and get rid of all the infrastructure for multiple backend encodings?\\\".\\n> I'm not personally in favor of that, but there are very few hackers who\\n> want to add any more overhead in this area.\\n\\nPersonally, I totally agree. I want non-Unicode character sets to disappear from the world. But the real business doesn't seem to forgive the lack of SJIS...\\n\\nRegards\\nTakayuki Tsunakawa\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 02:51:13 +0000\",\n \"msg_from\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"From: pgsql-hackers-owner@postgresql.org\\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Heikki\\n> But one thing that would help a little, would be to optimize the UTF-8\\n> -> SJIS conversion. It uses a very generic routine, with a binary search\\n> over a large array of mappings. I bet you could do better than that, maybe\\n> using a hash table or a radix tree instead of the large binary-searched\\n> array.\\n\\nThat sounds worth pursuing. Thanks!\\n\\n\\nRegards\\nTakayuki Tsunakawa\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 02:57:01 +0000\",\n \"msg_from\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com> writes:\\n> Using multibyte-functions like mb... to process characters would solve\\n> the problem?\\n\\nWell, sure. The problem is (1) finding all the places that need that\\n(I'd estimate dozens to hundreds of places in the core code, and then\\nthere's the question of extensions); (2) preventing new\\nnon-multibyte-aware code from being introduced after you've fixed those\\nplaces; and (3) the performance penalties you'd take, because a lot of\\nthose places are bottlenecks and it's much cheaper to not worry about\\ncharacter lengths in an inner loop.\\n\\n> Isn't the current implementation blocking the support of\\n> other character sets that have similar characteristics?\\n\\nSure, SJIS is not the only encoding that we consider frontend-only.\\nSee\\n\\nhttps://www.postgresql.org/docs/devel/static/multibyte.html#MULTIBYTE-CHARSET-SUPPORTED\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 05 Sep 2016 23:10:14 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Mon, 5 Sep 2016 19:38:33 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <529db688-72fc-1ca2-f898-b0b99e30076f@iki.fi>\\n> On 09/05/2016 05:47 PM, Tom Lane wrote:\\n> > \\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com> writes:\\n> >> Before digging into the problem, could you share your impression on\\n> >> whether PostgreSQL can support SJIS? Would it be hopeless?\\n> >\\n> > I think it's pretty much hopeless.\\n> \\n> Agreed.\\n\\n+1, even as a user of SJIS:)\\n\\n> But one thing that would help a little, would be to optimize the UTF-8\\n> -> SJIS conversion. It uses a very generic routine, with a binary\\n> search over a large array of mappings. I bet you could do better than\\n> that, maybe using a hash table or a radix tree instead of the large\\n> binary-searched array.\\n\\nI'm very impressed by the idea. Mean number of iterations for\\nbinsearch on current conversion table with 8000 characters is\\nabout 13 and the table size is under 100kBytes (maybe).\\n\\nA three-level array with 2 byte values will take about 1.6~2MB of memory.\\n\\nA radix tree for UTF-8->some-encoding conversion requires about,\\nor up to.. (using 1 byte index to point the next level)\\n\\n(1 * ((7f + 1) +\\n (df - c2 + 1) * (bf - 80 + 1) +\\n (ef - e0 + 1) * (bf - 80 + 1)^2)) = 67 kbytes.\\n\\nSJIS characters are 2byte length at longest so about 8000\\ncharacters takes extra 16 k Bytes. And some padding space will be\\nadded on them.\\n\\nAs the result, radix tree seems to be promising because of small\\nrequirement of additional memory and far less comparisons. Also\\nBig5 and other encodings including EUC-* will get benefit from\\nit.\\n\\nImplementing radix tree code, then redefining the format of\\nmapping table to suppot radix tree, then modifying mapping\\ngenerator script are needed.\\n\\nIf no one oppse to this, I'll do that.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 12:29:04 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"> From: pgsql-hackers-owner@postgresql.org\\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\\n> HORIGUCHI\\nImplementing radix tree code, then redefining the format of mapping table\\n> to suppot radix tree, then modifying mapping generator script are needed.\\n> \\n> If no one oppse to this, I'll do that.\\n\\n+100\\nGreat analysis and your guts. I very much appreciate your trial!\\n\\nRegards\\nTakayuki Tsunakawa\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 03:43:46 +0000\",\n \"msg_from\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Tue, 6 Sep 2016 03:43:46 +0000, \\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com> wrote in <0A3221C70F24FB45833433255569204D1F5E66CE@G01JPEXMBYT05>\\n> > From: pgsql-hackers-owner@postgresql.org\\n> > [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\\n> > HORIGUCHI\\n> Implementing radix tree code, then redefining the format of mapping table\\n> > to suppot radix tree, then modifying mapping generator script are needed.\\n> > \\n> > If no one oppse to this, I'll do that.\\n> \\n> +100\\n> Great analysis and your guts. I very much appreciate your trial!\\n\\nThanks, by the way, there's another issue related to SJIS\\nconversion. MS932 has several characters that have multiple code\\npoints. By converting texts in this encoding to and from Unicode\\ncauses a round-trop problem. For example,\\n\\n8754(ROMAN NUMERICAL I in NEC specials)\\n => U+2160(ROMAN NUMERICAL I)\\n => FA4A (ROMAN NUMERICA I in IBM extension)\\n\\nMy counting said that 398 characters are affected by this kind of\\nreplacement. Addition to that, \\\"GAIJI\\\" (Private usage area) is\\nnot allowed. Is this meet your purpose?\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 07 Sep 2016 16:13:04 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"From: pgsql-hackers-owner@postgresql.org\\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\\n> Thanks, by the way, there's another issue related to SJIS conversion. MS932\\n> has several characters that have multiple code points. By converting texts\\n> in this encoding to and from Unicode causes a round-trop problem. For\\n> example,\\n> \\n> 8754(ROMAN NUMERICAL I in NEC specials)\\n> => U+2160(ROMAN NUMERICAL I)\\n> => FA4A (ROMAN NUMERICA I in IBM extension)\\n> \\n> My counting said that 398 characters are affected by this kind of replacement.\\n> Addition to that, \\\"GAIJI\\\" (Private usage area) is not allowed. Is this meet\\n> your purpose?\\n\\nSupporting GAIJI is not a requirement as far as I know. Thank you for sharing information.\\n\\n# I realize my lack of knowledge about character sets...\\n\\nRegards\\nTakayuki Tsunakawa\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 07:39:09 +0000\",\n \"msg_from\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Wed, 07 Sep 2016 16:13:04 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20160907.161304.112519789.horiguchi.kyotaro@lab.ntt.co.jp>\\n> > Implementing radix tree code, then redefining the format of mapping table\\n> > > to suppot radix tree, then modifying mapping generator script are needed.\\n> > > \\n> > > If no one oppse to this, I'll do that.\\n\\nSo, I did that as a PoC. The radix tree takes a little less than\\n100k bytes (far smaller than expected:) and it is defnitely\\nfaster than binsearch.\\n\\n\\nThe attached patch does the following things.\\n\\n- Defines a struct for static radix tree\\n (utf_radix_tree). Currently it supports up to 3-byte encodings.\\n\\n- Adds a map generator script UCS_to_SJIS_radix.pl, which\\n generates utf8_to_sjis_radix.map from utf8_to_sjis.map.\\n\\n- Adds a new conversion function utf8_to_sjis_radix.\\n\\n- Modifies UtfToLocal so as to allow map to be NULL.\\n\\n- Modifies utf8_to_sjis to use the new conversion function\\n instead of ULmapSJIS.\\n\\n\\nThe followings are to be done.\\n\\n- utf8_to_sjis_radix could be more generic.\\n\\n- SJIS->UTF8 is not implemented but it would be easily done since\\n there's no difference in using the radix tree mechanism.\\n (but the output character is currently assumed to be 2-byte long)\\n\\n- It doesn't support 4-byte codes so this is not applicable to\\n sjis_2004. Extending the radix tree to support 4-byte wouldn't\\n be hard.\\n\\n\\nThe following is the result of a simple test.\\n\\n=# create table t (a text); alter table t alter column a storage plain;\\n=# insert into t values ('... 7130 cahracters containing (I believe) all characters in SJIS encoding');\\n=# insert into t values ('... 7130 cahracters containing (I believe) all characters in SJIS encoding');\\n\\n# Doing that twice is just my mistake.\\n\\n$ export PGCLIENTENCODING=SJIS\\n\\n$ time psql postgres -c '\\n$ psql -c '\\\\encoding' postgres\\nSJIS\\n\\n<Using radix tree>\\n$ time psql postgres -c 'select t.a from t, generate_series(0, 9999)' > /dev/null\\n\\nreal\\t0m22.696s\\nuser\\t0m16.991s\\nsys\\t0m0.182s>\\n\\nUsing binsearch the result for the same operation was \\nreal\\t0m35.296s\\nuser\\t0m17.166s\\nsys\\t0m0.216s\\n\\nReturning in UTF-8 bloats the result string by about 1.5 times so\\nit doesn't seem to make sense comparing with it. But it takes\\nreal = 47.35s.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 08 Sep 2016 15:35:46 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"From: pgsql-hackers-owner@postgresql.org\\n> [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\\n> HORIGUCHI\\n> <Using radix tree>\\n> $ time psql postgres -c 'select t.a from t, generate_series(0, 9999)' >\\n> /dev/null\\n> \\n> real\\t0m22.696s\\n> user\\t0m16.991s\\n> sys\\t0m0.182s>\\n> \\n> Using binsearch the result for the same operation was\\n> real\\t0m35.296s\\n> user\\t0m17.166s\\n> sys\\t0m0.216s\\n> \\n> Returning in UTF-8 bloats the result string by about 1.5 times so it doesn't\\n> seem to make sense comparing with it. But it takes real = 47.35s.\\n\\nCool, 36% speedup! Does this difference vary depending on the actual characters used, e.g. the speedup would be greater if most of the characters are ASCII?\\n\\nRegards\\nTakayuki Tsunakawa\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 07:09:51 +0000\",\n \"msg_from\": \"\\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"At Thu, 8 Sep 2016 07:09:51 +0000, \\\"Tsunakawa, Takayuki\\\" <tsunakawa.takay@jp.fujitsu.com> wrote in <0A3221C70F24FB45833433255569204D1F5E7D4A@G01JPEXMBYT05>\\n> From: pgsql-hackers-owner@postgresql.org\\n> > [mailto:pgsql-hackers-owner@postgresql.org] On Behalf Of Kyotaro\\n> > HORIGUCHI\\n> > <Using radix tree>\\n> > $ time psql postgres -c 'select t.a from t, generate_series(0, 9999)' >\\n> > /dev/null\\n> > \\n> > real\\t0m22.696s\\n> > user\\t0m16.991s\\n> > sys\\t0m0.182s>\\n> > \\n> > Using binsearch the result for the same operation was\\n> > real\\t0m35.296s\\n> > user\\t0m17.166s\\n> > sys\\t0m0.216s\\n> > \\n> > Returning in UTF-8 bloats the result string by about 1.5 times so it doesn't\\n> > seem to make sense comparing with it. But it takes real = 47.35s.\\n> \\n> Cool, 36% speedup! Does this difference vary depending on the actual characters used, e.g. the speedup would be greater if most of the characters are ASCII?\\n\\nBinsearch on JIS X 0208 always needs about 10 times of comparison\\nand bisecting and the radix tree requires three hops on arrays\\nfor most of the characters and two hops for some. In sort, this\\neffect won't be differ among 2 and 3 byte characters in UTF-8.\\n\\nThe translation speed of ASCII cahracters (U+20 - U+7f) is not\\naffected by the character conversion mechanism. They are just\\ncopied without conversion.\\n\\nAs the result, there's no speedup if the output consists only of\\nASCII characters and maximum speedup when the output consists\\nonly of 2 byte UTF-8 characters.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 13 Sep 2016 11:04:27 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"On 09/08/2016 09:35 AM, Kyotaro HORIGUCHI wrote:\\n> Returning in UTF-8 bloats the result string by about 1.5 times so\\n> it doesn't seem to make sense comparing with it. But it takes\\n> real = 47.35s.\\n\\nNice!\\n\\nI was hoping that this would also make the binaries smaller. A few dozen \\nkB of storage is perhaps not a big deal these days, but still. And \\nsmaller tables would also consume less memory and CPU cache.\\n\\nI removed the #include \\\"../../Unicode/utf8_to_sjis.map\\\" line, so that \\nthe old table isn't included anymore, compiled, and ran \\\"strip \\nutf8_and_sjis.so\\\". Without this patch, it's 126 kB, and with it, it's \\n160 kB. So the radix tree takes a little bit more space.\\n\\nThat's not too bad, and I'm sure we could live with that, but with a few \\nsimple tricks, we could do better. First, since all the values we store \\nin the tree are < 0xffff, we could store them in int16 instead of int32, \\nand halve the size of the table right off the bat. That won't work for \\nall encodings, of course, but it might be worth it to have two versions \\nof the code, one for int16 and another for int32.\\n\\nAnother trick is to eliminate redundancies in the tables. Many of the \\ntables contain lots of zeros, as in:\\n\\n> /* c3xx */{\\n> /* c380 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* c388 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* c390 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x817e,\\n> /* c398 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* c3a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* c3a8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* c3b0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8180,\\n> /* c3b8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000\\n> },\\n\\nand\\n\\n> /* e388xx */{\\n> /* e38880 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* e38888 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* e38890 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* e38898 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* e388a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* e388a8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* e388b0 */ 0x0000, 0xfa58, 0x878b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> /* e388b8 */ 0x0000, 0x878c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000\\n> },\\n\\nYou could overlay the last row of the first table, which is all zeros, \\nwith the first row of the second table, which is also all zeros. (Many \\nof the tables have a lot more zero-rows than this example.)\\n\\nBut yes, this patch looks very promising in general. I think we should \\nswitch over to radix trees for the all the encodings.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 13 Sep 2016 11:44:01 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Tue, 13 Sep 2016 11:44:01 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <7ff67a45-a53e-4d38-e25d-3a121afea47c@iki.fi>\\n> On 09/08/2016 09:35 AM, Kyotaro HORIGUCHI wrote:\\n> > Returning in UTF-8 bloats the result string by about 1.5 times so\\n> > it doesn't seem to make sense comparing with it. But it takes\\n> > real = 47.35s.\\n> \\n> Nice!\\n\\nThanks!\\n\\n> I was hoping that this would also make the binaries smaller. A few\\n> dozen kB of storage is perhaps not a big deal these days, but\\n> still. And smaller tables would also consume less memory and CPU\\n> cache.\\n\\nAgreed.\\n\\n> I removed the #include \\\"../../Unicode/utf8_to_sjis.map\\\" line, so that\\n> the old table isn't included anymore, compiled, and ran \\\"strip\\n> utf8_and_sjis.so\\\". Without this patch, it's 126 kB, and with it, it's\\n> 160 kB. So the radix tree takes a little bit more space.\\n> \\n> That's not too bad, and I'm sure we could live with that, but with a\\n> few simple tricks, we could do better. First, since all the values we\\n> store in the tree are < 0xffff, we could store them in int16 instead\\n> of int32, and halve the size of the table right off the bat. won't work\\n> for all encodings, of course, but it might be worth it to\\n> have two versions of the code, one for int16 and another for int32.\\n\\nThat's right. I used int imprudently. All of the character in the\\npatch, and most of characters in other than Unicode-related\\nencodings are in 2 bytes. 3 bytes characters can be in separate\\ntable in the struct for the case. Othersise two or more versions\\nof the structs is possible since currently the radix struct is\\nutf8_and_sjis's own in spite of the fact that it is in pg_wchar.h\\nin the patch.\\n\\n> Another trick is to eliminate redundancies in the tables. Many of the\\n> tables contain lots of zeros, as in:\\n> \\n> > /* c3xx */{\\n...\\n> > 0x817e,\\n> > /* c398 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n> > /* c3a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n> > /* c3a8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n> > /* c3b0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x8180,\\n> > /* c3b8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000\\n> > },\\n> \\n> and\\n> \\n> > /* e388xx */{\\n> > /* e38880 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n> > /* e38888 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n> > /* e38890 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n> > /* e38898 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n> > /* e388a0 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,\\n> > 0x0000,\\n...\\n> > },\\n> \\n> You could overlay the last row of the first table, which is all zeros,\\n> with the first row of the second table, which is also all zeros. (Many\\n> of the tables have a lot more zero-rows than this example.)\\n\\nYes, the bunch of zeros was annoyance. Several or many\\ncompression techniques are available in exchange for some\\nadditional CPU time. But the technique you suggested doesn't\\nneed such sacrifice, sounds nice.\\n\\n> But yes, this patch looks very promising in general. I think we should\\n> switch over to radix trees for the all the encodings.\\n\\nThe result was more than I expected for a character set with\\nabout 7000 characters. We can expect certain amount of advangate\\neven for character sets that have less than a hundred of\\ncharacters.\\n\\n\\nI'll work on this for the next CF.\\n\\nThanks.\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 21 Sep 2016 15:14:27 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"Hello, did this.\\n\\nAs a result, radix tree is about 1.5 times faster and needs a\\nhalf memory.\\n\\nAt Wed, 21 Sep 2016 15:14:27 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20160921.151427.265121484.horiguchi.kyotaro@lab.ntt.co.jp>\\n> I'll work on this for the next CF.\\n\\nThe radix conversion function and map conversion script became\\nmore generic than the previous state. So I could easily added\\nradix conversion of EUC_JP in addition to SjiftJIS.\\n\\nnm -S said that the size of radix tree data for sjis->utf8\\nconversion is 34kB and that for utf8->sjis is 46kB. (eucjp->utf8\\n57kB, utf8->eucjp 93kB) LUmapSJIS and ULmapSJIS was 62kB and\\n59kB, and LUmapEUC_JP and ULmapEUC_JP was 106kB and 105kB. If I'm\\nnot missing something, radix tree is faster and require less\\nmemory.\\n\\nA simple test where 'select '7070 sjis chars' x 100' (I'm not\\nsure, but the size is 1404kB) on local connection shows that this\\nis fast enough.\\n\\nradix: real 0m0.285s / user 0m0.199s / sys 0m0.006s\\nmaster: real 0m0.418s / user 0m0.180s / sys 0m0.004s\\n\\nTo make sure, the result of a test of sending the same amount of\\nASCII string (1404kB) on SJIS and UTF8(no-conversion) encoding is\\nas follows.\\n\\nascii/utf8-sjis: real 0m0.220s / user 0m0.176s / sys 0m0.011s\\nascii/utf8-utf8: real 0m0.137s / user 0m0.111s / sys 0m0.008s\\n\\n======\\nRandom discussions -\\n\\nCurrently the tree structure is devided into several elements,\\nOne for 2-byte, other ones for 3-byte and 4-byte codes and output\\ntable. The other than the last one is logically and technically\\nmerged into single table but it makes the generator script far\\ncomplex than the current complexity. I no longer want to play\\nhide'n seek with complex perl object..\\n\\nIt might be better that combining this as a native feature of the\\ncore. Currently the helper function is in core but that function\\nis given as conv_func on calling LocalToUtf.\\n\\nCurrent implement uses *.map files of pg_utf_to_local as\\ninput. It seems not good but the radix tree files is completely\\nuneditable. Provide custom made loading functions for every\\nsource instead of load_chartable() would be the way to go.\\n\\n# However, for example utf8_to_sjis.map, it doesn't seem to have\\n# generated from the source mentioned in UCS_to_SJIS.pl\\n\\nI'm not sure that compilers other than gcc accepts generated map\\nfile content.\\n\\nThe RADIXTREE.pm is in rather older style but seem no problem.\\n\\nI haven't tried this for charsets that contains 4-byte code.\\n\\nI haven't consider charset with conbined characters. I don't\\nthink it is needed so immediately.\\n\\nThough I believe that this is easily applied to other\\nconversions, I tried this only with character sets that I know\\nabout it.\\n\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 07 Oct 2016 17:32:00 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Supporting SJIS as a database encoding\"\n },\n {\n \"msg_contents\": \"This is a differnet topic from the original thread so I renamed\\nthe subject and repost. Sorry for duplicate posting.\\n\\n======================\\nHello, I did this.\\n\\nAs a result, radix tree is about 1.5 times faster and needs a\\nhalf memory.\\n\\nAt Wed, 21 Sep 2016 15:14:27 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20160921.151427.265121484.horiguchi.kyotaro@lab.ntt.co.jp>\\n> I'll work on this for the next CF.\\n\\nThe radix conversion function and map conversion script became\\nmore generic than the previous state. So I could easily added\\nradix conversion of EUC_JP in addition to SjiftJIS.\\n\\nnm -S said that the size of radix tree data for sjis->utf8\\nconversion is 34kB and that for utf8->sjis is 46kB. (eucjp->utf8\\n57kB, utf8->eucjp 93kB) LUmapSJIS and ULmapSJIS was 62kB and\\n59kB, and LUmapEUC_JP and ULmapEUC_JP was 106kB and 105kB. If I'm\\nnot missing something, radix tree is faster and require less\\nmemory.\\n\\nA simple test where 'select '7070 sjis chars' x 100' (I'm not\\nsure, but the size is 1404kB) on local connection shows that this\\nis fast enough.\\n\\nradix: real 0m0.285s / user 0m0.199s / sys 0m0.006s\\nmaster: real 0m0.418s / user 0m0.180s / sys 0m0.004s\\n\\nTo make sure, the result of a test of sending the same amount of\\nASCII string (1404kB) on SJIS and UTF8(no-conversion) encoding is\\nas follows.\\n\\nascii/utf8-sjis: real 0m0.220s / user 0m0.176s / sys 0m0.011s\\nascii/utf8-utf8: real 0m0.137s / user 0m0.111s / sys 0m0.008s\\n\\n======\\nRandom discussions -\\n\\nCurrently the tree structure is devided into several elements,\\nOne for 2-byte, other ones for 3-byte and 4-byte codes and output\\ntable. The other than the last one is logically and technically\\nmerged into single table but it makes the generator script far\\ncomplex than the current complexity. I no longer want to play\\nhide'n seek with complex perl object..\\n\\nIt might be better that combining this as a native feature of the\\ncore. Currently the helper function is in core but that function\\nis given as conv_func on calling LocalToUtf.\\n\\nCurrent implement uses *.map files of pg_utf_to_local as\\ninput. It seems not good but the radix tree files is completely\\nuneditable. Provide custom made loading functions for every\\nsource instead of load_chartable() would be the way to go.\\n\\n# However, for example utf8_to_sjis.map, it doesn't seem to have\\n# generated from the source mentioned in UCS_to_SJIS.pl\\n\\nI'm not sure that compilers other than gcc accepts generated map\\nfile content.\\n\\nThe RADIXTREE.pm is in rather older style but seem no problem.\\n\\nI haven't tried this for charsets that contains 4-byte code.\\n\\nI haven't consider charset with conbined characters. I don't\\nthink it is needed so immediately.\\n\\nThough I believe that this is easily applied to other\\nconversions, I tried this only with character sets that I know\\nabout it.\\n\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 07 Oct 2016 17:36:06 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 10/07/2016 11:36 AM, Kyotaro HORIGUCHI wrote:\\n> The radix conversion function and map conversion script became\\n> more generic than the previous state. So I could easily added\\n> radix conversion of EUC_JP in addition to SjiftJIS.\\n>\\n> nm -S said that the size of radix tree data for sjis->utf8\\n> conversion is 34kB and that for utf8->sjis is 46kB. (eucjp->utf8\\n> 57kB, utf8->eucjp 93kB) LUmapSJIS and ULmapSJIS was 62kB and\\n> 59kB, and LUmapEUC_JP and ULmapEUC_JP was 106kB and 105kB. If I'm\\n> not missing something, radix tree is faster and require less\\n> memory.\\n\\nCool!\\n\\n> Currently the tree structure is devided into several elements,\\n> One for 2-byte, other ones for 3-byte and 4-byte codes and output\\n> table. The other than the last one is logically and technically\\n> merged into single table but it makes the generator script far\\n> complex than the current complexity. I no longer want to play\\n> hide'n seek with complex perl object..\\n\\nI think that's OK. There isn't really anything to gain by merging them.\\n\\n> It might be better that combining this as a native feature of the\\n> core. Currently the helper function is in core but that function\\n> is given as conv_func on calling LocalToUtf.\\n\\nYeah, I think we want to completely replace the current binary-search \\nbased code with this. I would rather maintain just one mechanism.\\n\\n> Current implement uses *.map files of pg_utf_to_local as\\n> input. It seems not good but the radix tree files is completely\\n> uneditable. Provide custom made loading functions for every\\n> source instead of load_chartable() would be the way to go.\\n>\\n> # However, for example utf8_to_sjis.map, it doesn't seem to have\\n> # generated from the source mentioned in UCS_to_SJIS.pl\\n\\nOuch. We should find and document an authoritative source for all the \\nmappings we have...\\n\\nI think the next steps here are:\\n\\n1. Find an authoritative source for all the existing mappings.\\n2. Generate the radix tree files directly from the authoritative \\nsources, instead of the existing *.map files.\\n3. Completely replace the existing binary-search code with this.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Oct 2016 13:46:31 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Fri, Oct 7, 2016 at 6:46 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Ouch. We should find and document an authoritative source for all the\\n> mappings we have...\\n>\\n> I think the next steps here are:\\n>\\n> 1. Find an authoritative source for all the existing mappings.\\n> 2. Generate the radix tree files directly from the authoritative sources,\\n> instead of the existing *.map files.\\n> 3. Completely replace the existing binary-search code with this.\\n\\nIt might be best to convert using the existing map files, and then\\nupdate the mappings later. Otherwise, when things break, you won't\\nknow what to blame.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Oct 2016 11:55:10 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Robert Haas <robertmhaas@gmail.com> writes:\\n> On Fri, Oct 7, 2016 at 6:46 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Ouch. We should find and document an authoritative source for all the\\n>> mappings we have...\\n>> \\n>> I think the next steps here are:\\n>> \\n>> 1. Find an authoritative source for all the existing mappings.\\n>> 2. Generate the radix tree files directly from the authoritative sources,\\n>> instead of the existing *.map files.\\n>> 3. Completely replace the existing binary-search code with this.\\n\\n> It might be best to convert using the existing map files, and then\\n> update the mappings later. Otherwise, when things break, you won't\\n> know what to blame.\\n\\nI think I went through this exercise last year or so, and updated the\\nnotes about the authoritative sources where I was able to find one.\\nIn the remaining cases, I believe that the maps have been intentionally\\ntweaked and we should be cautious about undoing that. Tatsuo-san might\\nremember more about why they are the way they are.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 07 Oct 2016 12:19:23 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 10/07/2016 06:55 PM, Robert Haas wrote:\\n> On Fri, Oct 7, 2016 at 6:46 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Ouch. We should find and document an authoritative source for all the\\n>> mappings we have...\\n>>\\n>> I think the next steps here are:\\n>>\\n>> 1. Find an authoritative source for all the existing mappings.\\n>> 2. Generate the radix tree files directly from the authoritative sources,\\n>> instead of the existing *.map files.\\n>> 3. Completely replace the existing binary-search code with this.\\n>\\n> It might be best to convert using the existing map files, and then\\n> update the mappings later. Otherwise, when things break, you won't\\n> know what to blame.\\n\\nI was thinking that we keep the mappings unchanged, but figure out where \\nwe got the mappings we have. An authoritative source may well be \\\"file X \\nfrom unicode, with the following tweaks: ...\\\". As long as we have some \\nway of representing that, in text files, or in perl code, that's OK.\\n\\nWhat I don't want is that the current *.map files are turned into the \\nauthoritative source files, that we modify by hand. There are no \\ncomments in them, for starters, which makes hand-editing cumbersome. It \\nseems that we have edited some of them by hand already, but we should \\nrectify that.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 8 Oct 2016 00:37:28 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, this is new version of radix charconv.\\n\\nAt Sat, 8 Oct 2016 00:37:28 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <6d85d710-9554-a928-29ff-b2d3b80b01c9@iki.fi>\\n> What I don't want is that the current *.map files are turned into the\\n> authoritative source files, that we modify by hand. There are no\\n> comments in them, for starters, which makes hand-editing\\n> cumbersome. It seems that we have edited some of them by hand already,\\n> but we should rectify that.\\n\\nAgreed. So, I identifed source files of each character for EUC_JP\\nand SJIS conversions to clarify what has been done on them.\\n\\nSJIS conversion is made from CP932.TXT and 8 additional\\nconversions for UTF8->SJIS and none for SJIS->UTF8.\\n\\nEUC_JP is made from CP932.TXT and JIS0212.TXT. JIS0201.TXT and\\nJIS0208.TXT are useless. It adds 83 or 86 (different by\\ndirection) conversion entries.\\n\\nhttp://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP932.TXT\\nhttp://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0212.TXT\\n\\nNow the generator scripts don't use *.map as source and in turn\\ngenerates old-style map files as well as radix tree files.\\n\\nFor convenience, UCS_to_(SJIS|EUC_JP).pl takes parater --flat and\\n-v. The format generates the old-style flat map as well as radix\\nmap file and additional -v adds source description for each line\\nin the flat map file.\\n\\nDuring working on this, EUC_JP map lacks some conversions but it\\nis another issue.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 21 Oct 2016 17:33:21 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 10/21/2016 11:33 AM, Kyotaro HORIGUCHI wrote:\\n> Hello, this is new version of radix charconv.\\n>\\n> At Sat, 8 Oct 2016 00:37:28 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <6d85d710-9554-a928-29ff-b2d3b80b01c9@iki.fi>\\n>> What I don't want is that the current *.map files are turned into the\\n>> authoritative source files, that we modify by hand. There are no\\n>> comments in them, for starters, which makes hand-editing\\n>> cumbersome. It seems that we have edited some of them by hand already,\\n>> but we should rectify that.\\n>\\n> Agreed. So, I identifed source files of each character for EUC_JP\\n> and SJIS conversions to clarify what has been done on them.\\n>\\n> SJIS conversion is made from CP932.TXT and 8 additional\\n> conversions for UTF8->SJIS and none for SJIS->UTF8.\\n>\\n> EUC_JP is made from CP932.TXT and JIS0212.TXT. JIS0201.TXT and\\n> JIS0208.TXT are useless. It adds 83 or 86 (different by\\n> direction) conversion entries.\\n>\\n> http://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP932.TXT\\n> http://unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/JIS0212.TXT\\n>\\n> Now the generator scripts don't use *.map as source and in turn\\n> generates old-style map files as well as radix tree files.\\n>\\n> For convenience, UCS_to_(SJIS|EUC_JP).pl takes parater --flat and\\n> -v. The format generates the old-style flat map as well as radix\\n> map file and additional -v adds source description for each line\\n> in the flat map file.\\n>\\n> During working on this, EUC_JP map lacks some conversions but it\\n> is another issue.\\n\\nThanks!\\n\\nI'd reallly like to clean up all the current perl scripts, before we \\nstart to do the radix tree stuff. I worked through the rest of the \\nconversions, and fixed/hacked the perl scripts so that they faithfully \\nre-produce the mapping tables that we have in the repository currently. \\nWhether those are the best mappings or not, or whether we should update \\nthem based on some authoritative source is another question, but let's \\ntry to nail down the process of creating the mapping tables.\\n\\nTom Lane looked into this in Nov 2015 \\n(https://www.postgresql.org/message-id/28825.1449076551%40sss.pgh.pa.us). \\nThis is a continuation of that, to actually fix the scripts. This patch \\nseries doesn't change any of the mappings, only the way we produce the \\nmapping tables.\\n\\nOur UHC conversion tables contained a lot more characters than the \\nCP949.TXT file it's supposedly based on. I rewrote the script to use \\n\\\"windows-949-2000.xml\\\" file, from the ICU project, as the source \\ninstead. It's a much closer match to our mapping tables, containing all \\nbut one of the additional characters. We were already using \\ngb-18030-2000.xml as the source in UCS_GB18030.pl, so parsing ICU's XML \\nfiles isn't a new thing.\\n\\nThe GB2312.TXT source file seems to have disappeared from the Unicode \\nconsortium's FTP site. I changed the UCS_to_EUC_CN.pl script to use \\ngb-18030-2000.xml as the source instead. GB-18030 is an extension of \\nGB-2312, UCS_to_EUC_CN.pl filters out the additional characters that are \\nnot in GB-2312.\\n\\nThis now forms a reasonable basis for switching to radix tree. Every \\nmapping table is now generated by the print_tables() perl function in \\nconvutils.pm. To switch to a radix tree, you just need to swap that \\nfunction with one that produces a radix tree instead of the \\ncurrent-format mapping tables.\\n\\nThe perl scripts are still quite messy. For example, I lost the checks \\nfor duplicate mappings somewhere along the way - that ought to be put \\nback. My Perl skills are limited.\\n\\n\\nThis is now an orthogonal discussion, and doesn't need to block the \\nradix tree work, but we should consider what we want to base our mapping \\ntables on. Perhaps we could use the XML files from ICU as the source for \\nall of the mappings?\\n\\nICU seems to use a BSD-like license, so we could even include the XML \\nfiles in our repository. Actually, looking at \\nhttp://www.unicode.org/copyright.html#License, I think we could include \\nthe *.TXT files in our repository, too, if we wanted to. The *.TXT files \\nare found under www.unicode.org/Public/, so that license applies. I \\nthink that has changed somewhat recently, because the comments in our \\nperl scripts claim that the license didn't allow that.\\n\\n- Heikki\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 25 Oct 2016 12:23:48 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, thank you very much for the work. My work became quite\\neasier with it.\\n\\nAt Tue, 25 Oct 2016 12:23:48 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi>\\n> I'd reallly like to clean up all the current perl scripts, before we\\n> start to do the radix tree stuff. I worked through the rest of the\\n> conversions, and fixed/hacked the perl scripts so that they faithfully\\n> re-produce the mapping tables that we have in the repository\\n> currently. Whether those are the best mappings or not, or whether we\\n> should update them based on some authoritative source is another\\n> question, but let's try to nail down the process of creating the\\n> mapping tables.\\n> \\n> Tom Lane looked into this in Nov 2015\\n> (https://www.postgresql.org/message-id/28825.1449076551%40sss.pgh.pa.us). This\\n> is a continuation of that, to actually fix the scripts. This patch\\n> series doesn't change any of the mappings, only the way we produce the\\n> mapping tables.\\n> \\n> > Our UHC conversion tables contained a lot more characters than the\\n> CP949.TXT file it's supposedly based on. I rewrote the script to use\\n> \\\"windows-949-2000.xml\\\" file, from the ICU project, as the source\\n> instead. It's a much closer match to our mapping tables, containing\\n> all but one of the additional characters. We were already using\\n> gb-18030-2000.xml as the source in UCS_GB18030.pl, so parsing ICU's\\n> XML files isn't a new thing.\\n> \\n> The GB2312.TXT source file seems to have disappeared from the Unicode\\n> consortium's FTP site. I changed the UCS_to_EUC_CN.pl script to use\\n> gb-18030-2000.xml as the source instead. GB-18030 is an extension of\\n> GB-2312, UCS_to_EUC_CN.pl filters out the additional characters that\\n> are not in GB-2312.\\n> \\n> This now forms a reasonable basis for switching to radix tree. Every\\n> mapping table is now generated by the print_tables() perl function in\\n> convutils.pm. To switch to a radix tree, you just need to swap that\\n> function with one that produces a radix tree instead of the\\n> current-format mapping tables.\\n\\nRADIXCONV.pm is merged into convutils.pm and the manner to\\nresolve reference is unified from $$x{} to $x->{}. (subroutine\\ncall by '&' is not unified..) Now radix trees files are written\\nby the function with similar interface.\\n\\nprint_radix_trees($script_name, $encoding, \\\\@mapping);\\n\\n> The perl scripts are still quite messy. For example, I lost the checks\\n> for duplicate mappings somewhere along the way - that ought to be put\\n> back. My Perl skills are limited.\\n\\nPerl scripts are to be messy, I believe. Anyway the duplicate\\ncheck as been built into the sub print_radix_trees. Maybe the\\nsame check is needed by some plain map files but it would be just\\nduplication for the maps having radix tree.\\n\\nThe attached patches apply on top your patches and changes all\\npossible conversions to use radix tree (combined characters are\\nstill using old-method). Addition to that, because of the\\ndifficult-to-verify nature of the radix-tree data, I added\\nmap_chekcer (make mapcheck) to check them agaist plain maps.\\n\\nI have briefly checked with real characters for\\nSJIS/EUC-JP/BIG5/ISO8859-13 and radix conversion seems to work\\ncorrectly for them.\\n\\n> This is now an orthogonal discussion, and doesn't need to block the\\n> radix tree work, but we should consider what we want to base our\\n> mapping tables on. Perhaps we could use the XML files from ICU as the\\n> source for all of the mappings?\\n> \\n> ICU seems to use a BSD-like license, so we could even include the XML\\n> files in our repository. Actually, looking at\\n> http://www.unicode.org/copyright.html#License, I think we could\\n> include the *.TXT files in our repository, too, if we wanted to. The\\n> *.TXT files are found under www.unicode.org/Public/, so that license\\n> applies. I think that has changed somewhat recently, because the\\n> comments in our perl scripts claim that the license didn't allow that.\\n\\nFor the convenience, all the required files are downloaded by\\ntyping 'make download-texts'.\\n\\n\\nIn the following document,\\n\\nhttp://unicode.org/Public/ReadMe.txt\\n\\n| Terms of Use\\n| \\thttp://www.unicode.org/copyright.html\\n\\nhttp://www.unicode.org/copyright.html\\n\\n| EXHIBIT 1\\n| UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE\\n| Unicode Data Files include all data files under the directories\\n| http://www.unicode.org/Public/, http://www.unicode.org/reports/,\\n...\\n\\n| COPYRIGHT AND PERMISSION NOTICE\\n| \\n| Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\\n| Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\\n| \\n| Permission is hereby granted, free of charge, to any person obtaining\\n| a copy of the Unicode data files and any associated documentation\\n| (the \\\"Data Files\\\") or Unicode software and any associated documentation\\n| (the \\\"Software\\\") to deal in the Data Files or Software\\n| without restriction, including without limitation the rights to use,\\n| copy, modify, merge, publish, distribute, and/or sell copies of\\n| the Data Files or Software, and to permit persons to whom the Data Files\\n| or Software are furnished to do so, provided that either\\n| (a) this copyright and permission notice appear with all copies\\n| of the Data Files or Software, or\\n| (b) this copyright and permission notice appear in associated\\n| Documentation.\\n\\nPerhaps we can put the files into our repositoy by providing some\\nnotifications.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 27 Oct 2016 16:23:37 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> | COPYRIGHT AND PERMISSION NOTICE\\n> |\\n> | Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\\n> | Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\\n> |\\n> | Permission is hereby granted, free of charge, to any person obtaining\\n> | a copy of the Unicode data files and any associated documentation\\n> | (the \\\"Data Files\\\") or Unicode software and any associated documentation\\n> | (the \\\"Software\\\") to deal in the Data Files or Software\\n> | without restriction, including without limitation the rights to use,\\n> | copy, modify, merge, publish, distribute, and/or sell copies of\\n> | the Data Files or Software, and to permit persons to whom the Data Files\\n> | or Software are furnished to do so, provided that either\\n> | (a) this copyright and permission notice appear with all copies\\n> | of the Data Files or Software, or\\n> | (b) this copyright and permission notice appear in associated\\n> | Documentation.\\n>\\n> Perhaps we can put the files into our repositoy by providing some\\n> notifications.\\n\\nUggh, I don't much like advertising clauses.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 28 Oct 2016 09:18:08 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Robert Haas <robertmhaas@gmail.com> writes:\\n> On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>> Perhaps we can put the files into our repositoy by providing some\\n>> notifications.\\n\\n> Uggh, I don't much like advertising clauses.\\n\\nEven if the license were exactly compatible with ours, I'd be -1 on\\nbloating our tarballs with these files. They're large and only a\\ntiny fraction of developers, let alone end users, will ever care\\nto look at them.\\n\\nI think it's fine as long as we have a README file that explains\\nwhere to get them. (I'm not even very thrilled with the proposed\\nauto-download script, as it makes undesirable assumptions about\\nwhich internet tools you use, not to mention that it won't work\\nat all on Windows.)\\n\\nI'd actually vote for getting rid of the reference files we\\nhave in the tree now (src/backend/utils/mb/Unicode/*txt), on\\nthe same grounds. That's 600K of stuff that does not need to\\nbe in our tarballs.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 28 Oct 2016 09:42:25 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Fri, Oct 28, 2016 at 09:18:08AM -0400, Robert Haas wrote:\\n> On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> > | COPYRIGHT AND PERMISSION NOTICE\\n> > |\\n> > | Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\\n> > | Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\\n> > |\\n> > | Permission is hereby granted, free of charge, to any person obtaining\\n> > | a copy of the Unicode data files and any associated documentation\\n> > | (the \\\"Data Files\\\") or Unicode software and any associated documentation\\n> > | (the \\\"Software\\\") to deal in the Data Files or Software\\n> > | without restriction, including without limitation the rights to use,\\n> > | copy, modify, merge, publish, distribute, and/or sell copies of\\n> > | the Data Files or Software, and to permit persons to whom the Data Files\\n> > | or Software are furnished to do so, provided that either\\n> > | (a) this copyright and permission notice appear with all copies\\n> > | of the Data Files or Software, or\\n> > | (b) this copyright and permission notice appear in associated\\n> > | Documentation.\\n> >\\n> > Perhaps we can put the files into our repositoy by providing some\\n> > notifications.\\n> \\n> Uggh, I don't much like advertising clauses.\\n\\nYour dislike is pretty common.\\n\\nMight it be worth reaching out to the Unicode consortium about this?\\nThey may well have added that as boilerplate without really\\nconsidering the effects, and they even have a popup that specifically\\naddresses licensing.\\n\\nhttp://www.unicode.org/reporting.html\\n\\nBest,\\nDavid.\\n-- \\nDavid Fetter <david(at)fetter(dot)org> http://fetter.org/\\nPhone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter\\nSkype: davidfetter XMPP: david(dot)fetter(at)gmail(dot)com\\n\\nRemember to vote!\\nConsider donating to Postgres: http://www.postgresql.org/about/donate\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 28 Oct 2016 10:12:39 -0700\",\n \"msg_from\": \"David Fetter <david@fetter.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Fri, 28 Oct 2016 09:42:25 -0400, Tom Lane <tgl@sss.pgh.pa.us> wrote in <13049.1477662145@sss.pgh.pa.us>\\n> Robert Haas <robertmhaas@gmail.com> writes:\\n> > On Thu, Oct 27, 2016 at 3:23 AM, Kyotaro HORIGUCHI\\n> > <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> >> Perhaps we can put the files into our repositoy by providing some\\n> >> notifications.\\n> \\n> > Uggh, I don't much like advertising clauses.\\n> \\n> Even if the license were exactly compatible with ours, I'd be -1 on\\n> bloating our tarballs with these files. They're large and only a\\n> tiny fraction of developers, let alone end users, will ever care\\n> to look at them.\\n\\nI understood that the intention of Heikki's suggestion, that is,\\nthese might be included in PostgreSQL's repository, is looking\\nfor a kind of stability, or consistency. The source files are not\\nrevision-mangaged. In case where the authorities get unwanted\\nchanges or no longer avaiable, .map files have to be edited\\nirelevantly from the authority files maybe from the reason that\\n. Actually some map files have lost their authority file or other\\nmap files have got several direct modifications. We will be free\\nfrom such disturbance by containing \\\"frozen\\\" authority files.\\n\\nOn the other hand, I also agree that the advertising or\\nadditional bloats of source repositiry are a nuisance.\\n\\n> I think it's fine as long as we have a README file that explains\\n> where to get them. (I'm not even very thrilled with the proposed\\n> auto-download script, as it makes undesirable assumptions about\\n> which internet tools you use, not to mention that it won't work\\n> at all on Windows.)\\n\\nMmm. It would be a pain in the neck. Some of the files are\\nalready stored in \\\"OBSOLETE\\\" directory in the Unicode consortium\\nftp site, and one of them has been vanished and available from\\nanother place, a part of ICU source tree. On the other hand map\\nfiles are assumed to be generated from the scripts and are to\\ndiscuraged to be directly edited. Radix map files are uneditable\\nand currently made from the authority files. If some authority\\nfiles are gone, the additional edit have to be done directly onto\\nmap files, and they are in turn to be the authority for radix\\nfiles. (it's quite easy to chage the authority to current map\\nfiles, though).\\n\\nBy the way, the following phrase of the terms of license.\\n\\nhttp://www.unicode.org/copyright.html\\n\\n| COPYRIGHT AND PERMISSION NOTICE\\n| \\n| Copyright (c) 1991-2016 Unicode, Inc. All rights reserved.\\n| Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\\n| \\n| Permission is hereby granted, free of charge, to any person obtaining\\n| a copy of the Unicode data files and any associated documentation\\n| (the \\\"Data Files\\\") or Unicode software and any associated documentation\\n| (the \\\"Software\\\") to deal in the Data Files or Software\\n| without restriction, including without limitation the rights to use,\\n| copy, modify, merge, publish, distribute, and/or sell copies of\\n| the Data Files or Software, and to permit persons to whom the Data Files\\n| or Software are furnished to do so, provided that either\\n| (a) this copyright and permission notice appear with all copies\\n| of the Data Files or Software, or\\n| (b) this copyright and permission notice appear in associated\\n| Documentation.\\n\\nI'm afraid that the map (and _radix.map files) are the translates\\nof the \\\"Data Files\\\", and 'translate' is a part of 'modify'.\\n\\nEither the notice is necessary or not, if we decide to wipe the\\n'true' authority out from our source files, I'd like to make the\\nmap files (preferably with comments) as the second authority,\\n_radix.map files are to be getenerated from them, since they're\\nnot editable.\\n\\n> I'd actually vote for getting rid of the reference files we\\n> have in the tree now (src/backend/utils/mb/Unicode/*txt), on\\n> the same grounds. That's 600K of stuff that does not need to\\n> be in our tarballs.\\n\\nAnyway, I'd like to register this as an item of this CF.\\n\\nregares,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Oct 2016 09:59:15 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"> On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> \\n> Hello, thank you very much for the work. My work became quite\\n> easier with it.\\n> \\n> At Tue, 25 Oct 2016 12:23:48 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi>\\n>> \\n>> [..]\\n>> The perl scripts are still quite messy. For example, I lost the checks\\n>> for duplicate mappings somewhere along the way - that ought to be put\\n>> back. My Perl skills are limited.\\n> \\n> Perl scripts are to be messy, I believe. Anyway the duplicate\\n> check as been built into the sub print_radix_trees. Maybe the\\n> same check is needed by some plain map files but it would be just\\n> duplication for the maps having radix tree.\\n\\nI took a small stab at doing some cleaning of the Perl scripts, mainly around\\nusing the more modern (well, modern as in +15 years old) form for open(..),\\navoiding global filehandles for passing scalar references and enforcing use\\nstrict. Some smaller typos and fixes were also included. It seems my Perl has\\nbecome a bit rusty so I hope the changes make sense. The produced files are\\nidentical with these patches applied, they are merely doing cleaning as opposed\\nto bugfixing.\\n\\nThe attached patches are against the 0001-0006 patches from Heikki and you in\\nthis series of emails, the separation is intended to make them easier to read.\\n\\ncheers ./daniel\\n\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 31 Oct 2016 17:11:17 +0100\",\n \"msg_from\": \"Daniel Gustafsson <daniel@yesql.se>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Thank you for looling this.\\n\\nAt Mon, 31 Oct 2016 17:11:17 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <3FC648B5-2B7F-4585-9615-207A44B730A9@yesql.se>\\n> > On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> > Perl scripts are to be messy, I believe. Anyway the duplicate\\n> > check as been built into the sub print_radix_trees. Maybe the\\n> > same check is needed by some plain map files but it would be just\\n> > duplication for the maps having radix tree.\\n> \\n> I took a small stab at doing some cleaning of the Perl scripts, mainly around\\n> using the more modern (well, modern as in +15 years old) form for open(..),\\n> avoiding global filehandles for passing scalar references and enforcing use\\n> strict. Some smaller typos and fixes were also included. It seems my Perl has\\n> become a bit rusty so I hope the changes make sense. The produced files are\\n> identical with these patches applied, they are merely doing cleaning as opposed\\n> to bugfixing.\\n> \\n> The attached patches are against the 0001-0006 patches from Heikki and you in\\n> this series of emails, the separation is intended to make them easier to read.\\n\\nI'm not sure how the discussion about this goes, these patches\\nmakes me think about coding style of Perl.\\n\\nThe distinction between executable script and library is by\\nintention with an obscure basis. Existing scripts don't get less\\nmodification, but library uses more restricted scopes to get rid\\nof the troubles caused by using global scopes. But I don't have a\\nclear preference on that. The TAP test scripts takes OO notations\\nbut I'm not sure convutils.pl also be better to take the same\\nnotation. It would be rarely edited hereafter and won't gets\\ngrown any more.\\n\\nAs far as I see the obvious bug fixes in the patchset are the\\nfollowing,\\n\\n- 0007: load_maptable fogets to close input file.\\n- 0010: commment for load_maptables is wrong.\\n- 0011: hash reference is incorrectly dereferenced\\n\\nAll other fixes other than the above three seem to be styling or\\nsyntax-generation issues and I don't know whether any\\nrecommendation exists...\\n\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 04 Nov 2016 16:34:33 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"> On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> \\n> Thank you for looling this.\\n\\nAnd thank you for taking the time to read my patches!\\n\\n> At Mon, 31 Oct 2016 17:11:17 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <3FC648B5-2B7F-4585-9615-207A44B730A9@yesql.se>\\n>>> On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>>> Perl scripts are to be messy, I believe. Anyway the duplicate\\n>>> check as been built into the sub print_radix_trees. Maybe the\\n>>> same check is needed by some plain map files but it would be just\\n>>> duplication for the maps having radix tree.\\n>> \\n>> I took a small stab at doing some cleaning of the Perl scripts, mainly around\\n>> using the more modern (well, modern as in +15 years old) form for open(..),\\n>> avoiding global filehandles for passing scalar references and enforcing use\\n>> strict. Some smaller typos and fixes were also included. It seems my Perl has\\n>> become a bit rusty so I hope the changes make sense. The produced files are\\n>> identical with these patches applied, they are merely doing cleaning as opposed\\n>> to bugfixing.\\n>> \\n>> The attached patches are against the 0001-0006 patches from Heikki and you in\\n>> this series of emails, the separation is intended to make them easier to read.\\n> \\n> I'm not sure how the discussion about this goes, these patches\\n> makes me think about coding style of Perl.\\n\\nSome of this can absolutely be considered style and more or less down to\\npersonal preference. I haven’t seen any coding conventions for Perl so I\\nassume it’s down to consensus among the committers. My rationale for these\\npatches in the first place was that I perceived this thread to partly want to\\nclean up the code and make it more modern Perl.\\n\\n> The distinction between executable script and library is by\\n> intention with an obscure basis. Existing scripts don't get less\\n> modification, but library uses more restricted scopes to get rid\\n> of the troubles caused by using global scopes. But I don't have a\\n> clear preference on that. The TAP test scripts takes OO notations\\n> but I'm not sure convutils.pl also be better to take the same\\n> notation. It would be rarely edited hereafter and won't gets\\n> grown any more.\\n\\nI think the current convutils module is fine and converting it to OO would be\\noverkill.\\n\\n> As far as I see the obvious bug fixes in the patchset are the\\n> following,\\n\\nAgreed, with some comments:\\n\\n> - 0007: load_maptable fogets to close input file.\\n\\nAn interesting note on this is that it’s not even a bug =) Since $in is a\\nscalar reference, there is no need to explicitly close() the filehandle since\\nthe reference counter will close it on leaving scope, but there’s no harm in\\ndoing it ourselves and it also makes for less confusion for anyone not familiar\\nwith Perl internals.\\n\\n> - 0010: commment for load_maptables is wrong.\\n\\nThere is also a fix for a typo in make_mapchecker.pl\\n\\n> - 0011: hash reference is incorrectly dereferenced\\n> \\n> All other fixes other than the above three seem to be styling or\\n> syntax-generation issues and I don't know whether any\\n> recommendation exists…\\n\\nI think there are some more fixes that arent styling/syntax remaining. I’ll go\\nthrough the patches one by one:\\n\\n0007 - While this might be considered styling/syntax, my $0.02 is that it’s not\\nand instead a worthwhile change. I’ll illustrate with an example from the\\npatch in question:\\n\\nUsing a bareword global variable in open() for the filehandle was replaced with\\nthe three-part form in 5.6 and is now even actively discouraged from in the\\nPerl documentation (and has been so since the 5.20 docs). The problem is that\\nthey are global and can thus easily clash, so easily that the 0007 patch\\nactually fixes one such occurrence:\\n\\nprint_radix_map() opens the file in the global filehandle OUT and passes it to\\nprint_radix_table() with the typeglob *OUT; print_radit_table() in turn passes\\nthe filehandle to print_segmented_table() which writes to the file using the\\nparameter $hd, except in one case where it uses the global OUT variable without\\nknowing it will be the right file. This is where the hunk below in 0007 comes\\nin:\\n\\n- print OUT \\\"$line\\\\n\\\";\\n+ print { $$hd } \\\"$line\\\\n\\\";\\n\\nIn this case OUT references the right file and it produces the right result,\\nbut it illustrates how easy it is to get wrong (which can cause very subtle\\nbugs). So, when poking at this code we might as well, IMHO, use what is today\\nin Perl considered the right way to deal with filehandle references.\\n\\nUsing implicit filemodes can also introduce bugs when opening filenames passed\\nin from the outside as we do in UCS_to_most.pl. Considering the use case of\\nthese scripts it’s obviously quite low on the list of risks but still.\\n\\n0008 - I don’t think there are any recommendations whether or not to use use\\nstrict; in the codebase, there certainly are lots of scripts not doing it.\\nPersonally I think it’s good hygiene to always use strict but here it might\\njust be janitorial nitpicking (which I too am guilty of liking.. =)).\\n\\n0009 - local $var; is to provide a temporary value of $var, where $var exists,\\nfor the current scope (and was mostly used back in Perl 4). Since we are\\npassing by value to ucs2utf(), and creating $utf inside it, using my to create\\nthe variable is the right thing even though the end result is the same.\\n\\n0010 and 0011 are already dealt with above.\\n\\nSo to summarize, I think there are a few more (while not all) hunks that are of\\ninterest which aren’t just syntax/style which can serve to make the code easer\\nto read/work with down line should we need to.\\n\\ncheers ./daniel\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 7 Nov 2016 12:32:55 +0100\",\n \"msg_from\": \"Daniel Gustafsson <daniel@yesql.se>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"> On 07 Nov 2016, at 12:32, Daniel Gustafsson <daniel@yesql.se> wrote:\\n> \\n>> On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>> \\n>> I'm not sure how the discussion about this goes, these patches\\n>> makes me think about coding style of Perl.\\n> \\n> Some of this can absolutely be considered style and more or less down to\\n> personal preference. I haven’t seen any coding conventions for Perl so I\\n> assume it’s down to consensus among the committers.\\n\\nActually, scratch that; there is of course a perltidy profile in the pgindent\\ndirectory. I should avoid sending email before coffee..\\n\\ncheers ./daniel\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 7 Nov 2016 17:19:29 +0100\",\n \"msg_from\": \"Daniel Gustafsson <daniel@yesql.se>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello,\\r\\n\\r\\nAt Mon, 7 Nov 2016 12:32:55 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <EE8775B6-BE30-459D-9DDB-F3D0B3FF573D@yesql.se>\\r\\n> > On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\r\\n> > I'm not sure how the discussion about this goes, these patches\\r\\n> > makes me think about coding style of Perl.\\r\\n> \\r\\n> Some of this can absolutely be considered style and more or less down to\\r\\n> personal preference. I haven’t seen any coding conventions for Perl so I\\r\\n> assume it’s down to consensus among the committers. My rationale for these\\r\\n> patches in the first place was that I perceived this thread to partly want to\\r\\n> clean up the code and make it more modern Perl.\\r\\n> \\r\\n> > The distinction between executable script and library is by\\r\\n> > intention with an obscure basis. Existing scripts don't get less\\r\\n> > modification, but library uses more restricted scopes to get rid\\r\\n> > of the troubles caused by using global scopes. But I don't have a\\r\\n> > clear preference on that. The TAP test scripts takes OO notations\\r\\n> > but I'm not sure convutils.pl also be better to take the same\\r\\n> > notation. It would be rarely edited hereafter and won't gets\\r\\n> > grown any more.\\r\\n> \\r\\n> I think the current convutils module is fine and converting it to OO would be\\r\\n> overkill.\\r\\n\\r\\nAgreed.\\r\\n\\r\\n> > As far as I see the obvious bug fixes in the patchset are the\\r\\n> > following,\\r\\n> \\r\\n> Agreed, with some comments:\\r\\n> \\r\\n> > - 0007: load_maptable fogets to close input file.\\r\\n> \\r\\n> An interesting note on this is that it’s not even a bug =) Since $in is a\\r\\n> scalar reference, there is no need to explicitly close() the filehandle since\\r\\n> the reference counter will close it on leaving scope, but there’s no harm in\\r\\n> doing it ourselves and it also makes for less confusion for anyone not familiar\\r\\n> with Perl internals.\\r\\n\\r\\nWow. I didn't know that perl has such a hidden-OO\\r\\nfeature. Nevertheless, implicit close is not friendly to who are\\r\\nnot familiar with newer perl.\\r\\n\\r\\nYour comment led me to confirm the requirement to build PostgreSQL.\\r\\n\\r\\nhttps://www.postgresql.org/docs/devel/static/install-requirements.html\\r\\n\\r\\n| Perl 5.8 or later is needed to build from a Git checkout, or if\\r\\n| you changed the input files for any of the build steps that use\\r\\n| Perl scripts. If building on Windows you will need Perl in any\\r\\n| case. Perl is also required to run some test suites.\\r\\n\\r\\nSo, we should assume Perl 5.8 (released in 2002!) on build\\r\\ntime. And actually 5.10 on RedHat 6.4, 5.16 on my\\r\\nenvironment(ContOS 7.2), and the official doc is at 5.24. Active\\r\\nperl is 5.24. According to this, we should use syntax supported\\r\\nas of 5.8 and/but not obsolete until 5.24, then to follow the\\r\\nlatest convention. But not OO. (But I can't squeeze out a\\r\\nconcrete syntax set out of this requirements :( )\\r\\n\\r\\n\\r\\n> > - 0010: commment for load_maptables is wrong.\\r\\n> \\r\\n> There is also a fix for a typo in make_mapchecker.pl\\r\\n> \\r\\n> > - 0011: hash reference is incorrectly dereferenced\\r\\n> > \\r\\n> > All other fixes other than the above three seem to be styling or\\r\\n> > syntax-generation issues and I don't know whether any\\r\\n> > recommendation exists…\\r\\n> \\r\\n> I think there are some more fixes that arent styling/syntax remaining. I’ll go\\r\\n> through the patches one by one:\\r\\n> \\r\\n> 0007 - While this might be considered styling/syntax, my $0.02 is that it’s not\\r\\n> and instead a worthwhile change. I’ll illustrate with an example from the\\r\\n> patch in question:\\r\\n> \\r\\n> Using a bareword global variable in open() for the filehandle was replaced with\\r\\n> the three-part form in 5.6 and is now even actively discouraged from in the\\r\\n> Perl documentation (and has been so since the 5.20 docs). The problem is that\\r\\n> they are global and can thus easily clash, so easily that the 0007 patch\\r\\n> actually fixes one such occurrence:\\r\\n\\r\\nThat's what should be adopted in the criteria above.\\r\\n\\r\\n - Don't use bareword globals.\\r\\n - Use open() with separate MODE argument.\\r\\n\\r\\n> print_radix_map() opens the file in the global filehandle OUT and passes it to\\r\\n> print_radix_table() with the typeglob *OUT; print_radit_table() in turn passes\\r\\n> the filehandle to print_segmented_table() which writes to the file using the\\r\\n> parameter $hd, except in one case where it uses the global OUT variable without\\r\\n> knowing it will be the right file. This is where the hunk below in 0007 comes\\r\\n> in:\\r\\n> \\r\\n> - print OUT \\\"$line\\\\n\\\";\\r\\n> + print { $$hd } \\\"$line\\\\n\\\";\\r\\n> \\r\\n> In this case OUT references the right file and it produces the right result,\\r\\n> but it illustrates how easy it is to get wrong (which can cause very subtle\\r\\n> bugs). So, when poking at this code we might as well, IMHO, use what is today\\r\\n> in Perl considered the right way to deal with filehandle references.\\r\\n\\r\\nThanks for the detail. Ok, I'll change the style so in the next\\r\\npatch.\\r\\n\\r\\n> Using implicit filemodes can also introduce bugs when opening filenames passed\\r\\n> in from the outside as we do in UCS_to_most.pl. Considering the use case of\\r\\n> these scripts it’s obviously quite low on the list of risks but still.\\r\\n\\r\\nOk, I'll do that.\\r\\n\\r\\n> 0008 - I don’t think there are any recommendations whether or not to use use\\r\\n> strict; in the codebase, there certainly are lots of scripts not doing it.\\r\\n> Personally I think it’s good hygiene to always use strict but here it might\\r\\n> just be janitorial nitpicking (which I too am guilty of liking.. =)).\\r\\n\\r\\nI used strict as an amulet (or armor) not to type incorrect\\r\\nsymbols. Breaking well-working scripts by adding strict is not\\r\\nreasonable but using it in new or heavily rewritten scripts are\\r\\nreasonable. I changed my mind to use newer style in rewriting\\r\\nexisting scripts.\\r\\n\\r\\n> 0009 - local $var; is to provide a temporary value of $var, where $var exists,\\r\\n> for the current scope (and was mostly used back in Perl 4). Since we are\\r\\n> passing by value to ucs2utf(), and creating $utf inside it, using my to create\\r\\n> the variable is the right thing even though the end result is the same.\\r\\n\\r\\nYes, you're right. The point was that the deferrence between\\r\\nlexical and dynamic scopes doesn't make any difference in the\\r\\ncontext. But I'll rewrite it according to the new policy.\\r\\n\\r\\n> 0010 and 0011 are already dealt with above.\\r\\n> \\r\\n> So to summarize, I think there are a few more (while not all) hunks that are of\\r\\n> interest which aren’t just syntax/style which can serve to make the code easer\\r\\n> to read/work with down line should we need to.\\r\\n\\r\\nAddition to this, I'll remove existing authority files and modify\\r\\nradix generator so that it can read plain map files in the next\\r\\npatch.\\r\\n\\r\\nThank you for the significant comments.\\r\\n\\r\\nregards,\\r\\n\\r\\n-- \\r\\nKyotaro Horiguchi\\r\\nNTT Open Source Software Center\\r\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 08 Nov 2016 10:43:56 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello,\\r\\n\\r\\nAt Mon, 7 Nov 2016 17:19:29 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <39E295B9-7391-40B6-911D-FE852E4604BD@yesql.se>\\r\\n> > On 07 Nov 2016, at 12:32, Daniel Gustafsson <daniel@yesql.se> wrote:\\r\\n> > \\r\\n> >> On 04 Nov 2016, at 08:34, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\r\\n> >> \\r\\n> >> I'm not sure how the discussion about this goes, these patches\\r\\n> >> makes me think about coding style of Perl.\\r\\n> > \\r\\n> > Some of this can absolutely be considered style and more or less down to\\r\\n> > personal preference. I haven’t seen any coding conventions for Perl so I\\r\\n> > assume it’s down to consensus among the committers.\\r\\n> \\r\\n> Actually, scratch that; there is of course a perltidy profile in the pgindent\\r\\n> directory. I should avoid sending email before coffee..\\r\\n\\r\\nHmm. Somehow perl-mode on my Emacs is stirring with\\r\\nununderstandable indentation and I manually correct them so it is\\r\\nhighly probable that the style of this patch is not compatible\\r\\nwith the defined style. Anyway it is better that pgindent\\r\\ngenerates smaller patch so I'll try it.\\r\\n\\r\\nregards,\\r\\n\\r\\n-- \\r\\nKyotaro Horiguchi\\r\\nNTT Open Source Software Center\\r\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 08 Nov 2016 11:02:58 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, this is the revising patch applies on top of the previous\\npatch.\\n\\nDifferences on map files are enormous but useless for discussion\\nso they aren't included in this. (but can be generated)\\n\\nThis still doesn't remove three .txt/.xml files since it heavily\\nbloats the patch. I'm planning that they are removed in the final\\nshape. All authority files including the removed files are\\nautomatically downloaded by the Makefile in this patch.\\n\\nAt Tue, 08 Nov 2016 10:43:56 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161108.104356.265607041.horiguchi.kyotaro@lab.ntt.co.jp>\\n> https://www.postgresql.org/docs/devel/static/install-requirements.html\\n> \\n> | Perl 5.8 or later is needed to build from a Git checkout, or if\\n> | you changed the input files for any of the build steps that use\\n> | Perl scripts. If building on Windows you will need Perl in any\\n> | case. Perl is also required to run some test suites.\\n> \\n> So, we should assume Perl 5.8 (released in 2002!) on build\\n> time. And actually 5.10 on RedHat 6.4, 5.16 on my\\n> environment(ContOS 7.2), and the official doc is at 5.24. Active\\n> perl is 5.24. According to this, we should use syntax supported\\n> as of 5.8 and/but not obsolete until 5.24, then to follow the\\n> latest convention. But not OO. (But I can't squeeze out a\\n> concrete syntax set out of this requirements :( )\\n...(forget this for a while..)\\n\\nFinally the attached patch contains most of (virtually all of)\\nDaniel's suggestion and some modification by pgperltidy.\\n\\n> Addition to this, I'll remove existing authority files and modify\\n> radix generator so that it can read plain map files in the next\\n> patch.\\n\\nSo, I think the attached are in rather modern shape.\\n\\nAt Tue, 08 Nov 2016 11:02:58 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161108.110258.59832499.horiguchi.kyotaro@lab.ntt.co.jp>\\n> Hmm. Somehow perl-mode on my Emacs is stirring with\\n> ununderstandable indentation and I manually correct them so it is\\n> highly probable that the style of this patch is not compatible\\n> with the defined style. Anyway it is better that pgindent\\n> generates smaller patch so I'll try it.\\n\\nThe attached are applied pgperltidy. Several regions such like\\nadditional character list are marked not to be edited.\\n\\nOne concern is what to leave by 'make distclen' and 'make\\nmaintainer-clean'. The former should remove authority *.TXT files\\nsince it shouldn't be in source archive. On the other hand it is\\nmore convenient that the latter leaves them. This seems somewhat\\nstrange but I can't come up with better behavior for now.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 08 Nov 2016 20:21:22 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"> On 08 Nov 2016, at 12:21, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> \\n> Hello, this is the revising patch applies on top of the previous\\n> patch.\\n> \\n> ...\\n> \\n> Finally the attached patch contains most of (virtually all of)\\n> Daniel's suggestion and some modification by pgperltidy.\\n\\nReading over this it looks good to me. I did spot one thing I had missed\\nbefore though, the error message below should be referencing the scalar\\nvariable ‘direction' unless I’m missing something:\\n\\n-\\tdie \\\"unacceptable direction : %direction\\\"\\n+\\tdie \\\"unacceptable direction : $direction\\\"\\n \\t if ($direction ne \\\"to_unicode\\\" && $direction ne \\\"from_unicode\\\");\\n\\nWith this, I would consider this ready for committer.\\n\\n>> Addition to this, I'll remove existing authority files and modify\\n>> radix generator so that it can read plain map files in the next\\n>> patch.\\n> \\n> So, I think the attached are in rather modern shape.\\n\\n+1, nice work!\\n\\ncheers ./daniel\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 8 Nov 2016 14:06:29 +0100\",\n \"msg_from\": \"Daniel Gustafsson <daniel@yesql.se>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\\n> I took a small stab at doing some cleaning of the Perl scripts, mainly around\\n> using the more modern (well, modern as in +15 years old) form for open(..),\\n> avoiding global filehandles for passing scalar references and enforcing use\\n> strict. Some smaller typos and fixes were also included. It seems my Perl has\\n> become a bit rusty so I hope the changes make sense. The produced files are\\n> identical with these patches applied, they are merely doing cleaning as opposed\\n> to bugfixing.\\n> \\n> The attached patches are against the 0001-0006 patches from Heikki and you in\\n> this series of emails, the separation is intended to make them easier to read.\\n\\nCool. See also here:\\nhttps://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\\n\\n-- \\nPeter Eisentraut http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 8 Nov 2016 11:37:58 -0500\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"> On 08 Nov 2016, at 17:37, Peter Eisentraut <peter.eisentraut@2ndquadrant.com> wrote:\\n> \\n> On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\\n>> I took a small stab at doing some cleaning of the Perl scripts, mainly around\\n>> using the more modern (well, modern as in +15 years old) form for open(..),\\n>> avoiding global filehandles for passing scalar references and enforcing use\\n>> strict. Some smaller typos and fixes were also included. It seems my Perl has\\n>> become a bit rusty so I hope the changes make sense. The produced files are\\n>> identical with these patches applied, they are merely doing cleaning as opposed\\n>> to bugfixing.\\n>> \\n>> The attached patches are against the 0001-0006 patches from Heikki and you in\\n>> this series of emails, the separation is intended to make them easier to read.\\n> \\n> Cool. See also here:\\n> https://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\\n\\nNice, not having hacked much Perl in quite a while I had all but forgotten\\nabout perlcritic.\\n\\nRunning it on the current version of the patchset yields mostly warnings on\\nstring values used in the require “convutils.pm” statement. There were however\\ntwo more interesting reports: one more open() call not using the three\\nparameter form and an instance of map which alters the input value. The latter\\nis not causing an issue since we don’t use the input list past the map but\\nfixing it seems like good form.\\n\\nAttached is a patch that addresses the perlcritic reports (running without any\\nspecial options).\\n\\ncheers ./daniel\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 9 Nov 2016 02:19:01 +0100\",\n \"msg_from\": \"Daniel Gustafsson <daniel@yesql.se>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, thank you for polishing this.\\r\\n\\r\\nAt Wed, 9 Nov 2016 02:19:01 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <80F34F25-BF6D-4BCD-9C38-42ED10D3F453@yesql.se>\\r\\n> > On 08 Nov 2016, at 17:37, Peter Eisentraut <peter.eisentraut@2ndquadrant.com> wrote:\\r\\n> > \\r\\n> > On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\\r\\n> >> I took a small stab at doing some cleaning of the Perl scripts, mainly around\\r\\n> >> using the more modern (well, modern as in +15 years old) form for open(..),\\r\\n> >> avoiding global filehandles for passing scalar references and enforcing use\\r\\n> >> strict. Some smaller typos and fixes were also included. It seems my Perl has\\r\\n> >> become a bit rusty so I hope the changes make sense. The produced files are\\r\\n> >> identical with these patches applied, they are merely doing cleaning as opposed\\r\\n> >> to bugfixing.\\r\\n> >> \\r\\n> >> The attached patches are against the 0001-0006 patches from Heikki and you in\\r\\n> >> this series of emails, the separation is intended to make them easier to read.\\r\\n> > \\r\\n> > Cool. See also here:\\r\\n> > https://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\\r\\n\\r\\n> Nice, not having hacked much Perl in quite a while I had all but forgotten\\r\\n> about perlcritic.\\r\\n\\r\\nI tried it on CentOS7. Installation failed saying that\\r\\nModule::Build is too old. It is yum-inatlled so removed it and\\r\\ninstalled it with CPAN. Again failed with many 'Could not create\\r\\nMYMETA files'. Then tried to install CPAN::Meta and it failed\\r\\nsaying that CPAN::Meta::YAML is too *new*. That sucks.\\r\\n\\r\\nSo your patch is greately helpfull. Thank you.\\r\\n\\r\\n| -my @mapnames = map { s/\\\\.map//; $_ } values %plainmaps;\\r\\n| +my @mapnames = map { my $m = $_; $m =~ s/\\\\.map//; $m } values %plainmaps;\\r\\n\\r\\nIt surprised me to know that perlcritic does such things.\\r\\n\\r\\n> Running it on the current version of the patchset yields mostly warnings on\\r\\n> string values used in the require “convutils.pm” statement. There were however\\r\\n> two more interesting reports: one more open() call not using the three\\r\\n> parameter form and an instance of map which alters the input value. \\r\\n\\r\\nSorry for overlooking it.\\r\\n\\r\\n> The latter\\r\\n> is not causing an issue since we don’t use the input list past the map but\\r\\n> fixing it seems like good form.\\r\\n\\r\\nAgreed.\\r\\n\\r\\n> Attached is a patch that addresses the perlcritic reports (running without any\\r\\n> special options).\\r\\n\\r\\nThanks. The attached patch contains the patch by perlcritic.\\r\\n\\r\\n0001,2,3 are Heikki's patch that are not modified since it is\\r\\nfirst proposed. It's a bit too big so I don't attach them to this\\r\\nmail (again).\\r\\n\\r\\nhttps://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\\r\\n\\r\\n0004 is radix-tree stuff, applies on top of the three patches\\r\\nabove.\\r\\n\\r\\nThere's a hidden fifth patch which of 20MB in size. But it is\\r\\ngenerated by running make in the Unicode directory.\\r\\n\\r\\n[$(TOP)]$ ./configure ...\\r\\n[$(TOP)]$ make\\r\\n[Unicode]$ make\\r\\n[Unicode]$ make distclean\\r\\n[Unicode]$ git add .\\r\\n[Unicode]$ commit \\r\\n=== COMMITE MESSSAGE\\r\\nReplace map files with radix tree files.\\r\\n\\r\\nThese encodings no longer uses the former map files and uses new radix\\r\\ntree files. All existing authority files in this directory are removed.\\r\\n===\\r\\n\\r\\nregards,\\r\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 09 Nov 2016 17:38:53 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello.\\r\\n\\r\\nI'll be off line until at least next Monday. So I move this to\\r\\nthe next CF by myself.\\r\\n\\r\\nAt Wed, 09 Nov 2016 17:38:53 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161109.173853.77274443.horiguchi.kyotaro@lab.ntt.co.jp>\\r\\n> Hello, thank you for polishing this.\\r\\n> \\r\\n> At Wed, 9 Nov 2016 02:19:01 +0100, Daniel Gustafsson <daniel@yesql.se> wrote in <80F34F25-BF6D-4BCD-9C38-42ED10D3F453@yesql.se>\\r\\n> > > On 08 Nov 2016, at 17:37, Peter Eisentraut <peter.eisentraut@2ndquadrant.com> wrote:\\r\\n> > > \\r\\n> > > On 10/31/16 12:11 PM, Daniel Gustafsson wrote:\\r\\n> > >> I took a small stab at doing some cleaning of the Perl scripts, mainly around\\r\\n> > >> using the more modern (well, modern as in +15 years old) form for open(..),\\r\\n> > >> avoiding global filehandles for passing scalar references and enforcing use\\r\\n> > >> strict. Some smaller typos and fixes were also included. It seems my Perl has\\r\\n> > >> become a bit rusty so I hope the changes make sense. The produced files are\\r\\n> > >> identical with these patches applied, they are merely doing cleaning as opposed\\r\\n> > >> to bugfixing.\\r\\n> > >> \\r\\n> > >> The attached patches are against the 0001-0006 patches from Heikki and you in\\r\\n> > >> this series of emails, the separation is intended to make them easier to read.\\r\\n> > > \\r\\n> > > Cool. See also here:\\r\\n> > > https://www.postgresql.org/message-id/55E52225.4040305%40gmx.net\\r\\n> \\r\\n> > Nice, not having hacked much Perl in quite a while I had all but forgotten\\r\\n> > about perlcritic.\\r\\n> \\r\\n> I tried it on CentOS7. Installation failed saying that\\r\\n> Module::Build is too old. It is yum-inatlled so removed it and\\r\\n> installed it with CPAN. Again failed with many 'Could not create\\r\\n> MYMETA files'. Then tried to install CPAN::Meta and it failed\\r\\n> saying that CPAN::Meta::YAML is too *new*. That sucks.\\r\\n> \\r\\n> So your patch is greately helpfull. Thank you.\\r\\n> \\r\\n> | -my @mapnames = map { s/\\\\.map//; $_ } values %plainmaps;\\r\\n> | +my @mapnames = map { my $m = $_; $m =~ s/\\\\.map//; $m } values %plainmaps;\\r\\n> \\r\\n> It surprised me to know that perlcritic does such things.\\r\\n> \\r\\n> > Running it on the current version of the patchset yields mostly warnings on\\r\\n> > string values used in the require “convutils.pm” statement. There were however\\r\\n> > two more interesting reports: one more open() call not using the three\\r\\n> > parameter form and an instance of map which alters the input value. \\r\\n> \\r\\n> Sorry for overlooking it.\\r\\n> \\r\\n> > The latter\\r\\n> > is not causing an issue since we don’t use the input list past the map but\\r\\n> > fixing it seems like good form.\\r\\n> \\r\\n> Agreed.\\r\\n> \\r\\n> > Attached is a patch that addresses the perlcritic reports (running without any\\r\\n> > special options).\\r\\n> \\r\\n> Thanks. The attached patch contains the patch by perlcritic.\\r\\n> \\r\\n> 0001,2,3 are Heikki's patch that are not modified since it is\\r\\n> first proposed. It's a bit too big so I don't attach them to this\\r\\n> mail (again).\\r\\n> \\r\\n> https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\\r\\n> \\r\\n> 0004 is radix-tree stuff, applies on top of the three patches\\r\\n> above.\\r\\n> \\r\\n> There's a hidden fifth patch which of 20MB in size. But it is\\r\\n> generated by running make in the Unicode directory.\\r\\n> \\r\\n> [$(TOP)]$ ./configure ...\\r\\n> [$(TOP)]$ make\\r\\n> [Unicode]$ make\\r\\n> [Unicode]$ make distclean\\r\\n> [Unicode]$ git add .\\r\\n> [Unicode]$ commit \\r\\n> === COMMITE MESSSAGE\\r\\n> Replace map files with radix tree files.\\r\\n> \\r\\n> These encodings no longer uses the former map files and uses new radix\\r\\n> tree files. All existing authority files in this directory are removed.\\r\\n> ===\\r\\n\\r\\n-- \\r\\nKyotaro Horiguchi\\r\\nNTT Open Source Software Center\\r\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 28 Nov 2016 19:25:15 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 10/31/2016 06:11 PM, Daniel Gustafsson wrote:\\n>> On 27 Oct 2016, at 09:23, Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>>\\n>> At Tue, 25 Oct 2016 12:23:48 +0300, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi>\\n>>>\\n>>> [..]\\n>>> The perl scripts are still quite messy. For example, I lost the checks\\n>>> for duplicate mappings somewhere along the way - that ought to be put\\n>>> back. My Perl skills are limited.\\n>>\\n>> Perl scripts are to be messy, I believe. Anyway the duplicate\\n>> check as been built into the sub print_radix_trees. Maybe the\\n>> same check is needed by some plain map files but it would be just\\n>> duplication for the maps having radix tree.\\n>\\n> I took a small stab at doing some cleaning of the Perl scripts, mainly around\\n> using the more modern (well, modern as in +15 years old) form for open(..),\\n> avoiding global filehandles for passing scalar references and enforcing use\\n> strict. Some smaller typos and fixes were also included. It seems my Perl has\\n> become a bit rusty so I hope the changes make sense. The produced files are\\n> identical with these patches applied, they are merely doing cleaning as opposed\\n> to bugfixing.\\n>\\n> The attached patches are against the 0001-0006 patches from Heikki and you in\\n> this series of emails, the separation is intended to make them easier to read.\\n\\nThanks! Patches 0001-0003 seem to have been mostly unchanged for the \\nlater discussion and everyone seems to be happy with those patches, so I \\npicked the parts of these cleanups of yours that applied to my patches \\n0001-0003, and pushed those. I'll continue reviewing the rest..\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 30 Nov 2016 14:59:44 +0200\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\\n> Thanks. The attached patch contains the patch by perlcritic.\\n>\\n> 0001,2,3 are Heikki's patch that are not modified since it is\\n> first proposed. It's a bit too big so I don't attach them to this\\n> mail (again).\\n>\\n> https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\\n\\nI've now pushed these preliminary patches, with the applicable fixes \\nfrom you and Daniel. The attached patch is now against git master.\\n\\n> 0004 is radix-tree stuff, applies on top of the three patches\\n> above.\\n\\nI've spent the last couple of days reviewing this. While trying to \\nunderstand how it works, I ended up dismantling, rewriting, and putting \\nback together most of the added perl code. Attached is a new version, \\nwith more straightforward logic, making it more understandable. I find \\nit more understandable, anyway, I hope it's not only because I wrote it \\nmyself :-). Let me know what you think.\\n\\nIn particular, I found the explanations of flat and segmented tables \\nreally hard to understand. So in this version, the radix trees for a \\nconversion are stored completely in one large array. Leaf and \\nintermediate levels are all in the same array. When reading this \\nversion, please note that I'm not sure if I mean the same thing with \\n\\\"segment\\\" that you did in your version.\\n\\nI moved the \\\"lower\\\" and \\\"upper\\\" values in the structs. Also, there are \\nnow also separate \\\"lower\\\" and \\\"upper\\\" values for the leaf levels of the \\ntrees, for 1- 2-, 3- and 4-byte inputs. This made a huge difference to \\nthe size of gb18030_to_utf8_radix.map, in particular: the source file \\nshrank from about 2 MB to 1/2 MB. In that conversion, the valid range \\nfor the last byte of 2-byte inputs is 0x40-0xfe, and the valid range for \\nthe last byte of 4-byte inputs is 0x30-0x39. With the old patch version, \\nthe \\\"chars\\\" range was therefore 0x30-0xfe, to cover both of those, and \\nmost of the array was filled with zeros. With this new patch version, we \\nstore separate ranges for those, and can leave out most of the zeros.\\n\\nThere's a segment full of zeros at the beginning of each conversion \\narray now. The purpose of that is that when traversing the radix tree, \\nyou don't need to check each intermediate value for 0. If you follow a 0 \\noffset, it simply points to the dummy all-zeros segments in the \\nbeginning. Seemed like a good idea to shave some cycles, although I'm \\nnot sure if it made much difference in reality.\\n\\nI optimized pg_mb_radix_conv() a bit, too. We could do more. For \\nexample, I think it would save some cycles to have specialized versions \\nof UtfToLocal and LocalToUtf, moving the tests for whether a combined \\ncharacter map and/or conversion callback is used, out of the loop. They \\nfeel a bit ugly too, in their current form...\\n\\nI need a break now, but I'll try to pick this up again some time next \\nweek. Meanwhile, please have a look and tell me what you think.\\n\\n- Heikki\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 2 Dec 2016 22:07:07 +0200\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Heikki Linnakangas wrote:\\n> On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\\n> > Thanks. The attached patch contains the patch by perlcritic.\\n> > \\n> > 0001,2,3 are Heikki's patch that are not modified since it is\\n> > first proposed. It's a bit too big so I don't attach them to this\\n> > mail (again).\\n> > \\n> > https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\\n> \\n> I've now pushed these preliminary patches, with the applicable fixes from\\n> you and Daniel. The attached patch is now against git master.\\n\\nIs this the Nov. 30th commit? Because I don't see any other commits\\nfrom you.\\n\\n-- \\n�lvaro Herrera https://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 2 Dec 2016 17:18:46 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 12/02/2016 10:18 PM, Alvaro Herrera wrote:\\n> Heikki Linnakangas wrote:\\n>> On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\\n>>> Thanks. The attached patch contains the patch by perlcritic.\\n>>>\\n>>> 0001,2,3 are Heikki's patch that are not modified since it is\\n>>> first proposed. It's a bit too big so I don't attach them to this\\n>>> mail (again).\\n>>>\\n>>> https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\\n>>\\n>> I've now pushed these preliminary patches, with the applicable fixes from\\n>> you and Daniel. The attached patch is now against git master.\\n>\\n> Is this the Nov. 30th commit? Because I don't see any other commits\\n> from you.\\n\\nYes. Sorry for the confusion.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 2 Dec 2016 22:49:52 +0200\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, thank you for reviewing this.\\n\\nI compared mine and yours. The new patch works fine and gives\\nsmaller radix map files. It seems also to me more readable.\\n\\nAt Fri, 2 Dec 2016 22:07:07 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <da58a154-0b28-802e-5e82-5a205f53926e@iki.fi>\\n> On 11/09/2016 10:38 AM, Kyotaro HORIGUCHI wrote:\\n> > Thanks. The attached patch contains the patch by perlcritic.\\n> >\\n> > 0001,2,3 are Heikki's patch that are not modified since it is\\n> > first proposed. It's a bit too big so I don't attach them to this\\n> > mail (again).\\n> >\\n> > https://www.postgresql.org/message-id/08e7892a-d55c-eefe-76e6-7910bc8dd1f3@iki.fi\\n> \\n> I've now pushed these preliminary patches, with the applicable fixes\\n> from you and Daniel. The attached patch is now against git master.\\n\\nThanks for committing them.\\n\\n> > 0004 is radix-tree stuff, applies on top of the three patches\\n> > above.\\n> \\n> I've spent the last couple of days reviewing this. While trying to\\n> understand how it works, I ended up dismantling, rewriting, and\\n> putting back together most of the added perl code. \\n\\nI might have been putting too much in one structure and a bit too\\neager to conceal lower level from the upper level.\\n\\n> Attached is a new\\n> version, with more straightforward logic, making it more\\n> understandable. I find it more understandable, anyway, I hope it's not\\n> only because I wrote it myself :-). Let me know what you think.\\n\\nFirst, thank you for the refactoring(?).\\n\\nI didn't intend to replace all of .map files with radix files at\\nfirst. Finally my patch removes all old-style map file but I\\nhaven't noticed that. So removing the old bsearch code seems\\nreasonable. Avoiding redundant decomposition of multibyte\\ncharacters into bytes seems reasonable from the view of\\nefficiency.\\n\\nThe new patch decomposes the structured pg_mb_radix_tree into a\\nseries of (basically) plain member variables in a struct. I'm not\\nso in favor of the style but a radix tree of at least 4-levels is\\neasily read in the style and maybe the code to handle it is\\nrather easily readable. (So +1 for it)\\n\\n> In particular, I found the explanations of flat and segmented tables\\n> really hard to understand. So in this version, the radix trees for a\\n> conversion are stored completely in one large array. Leaf and\\n> intermediate levels are all in the same array. When reading this\\n> version, please note that I'm not sure if I mean the same thing with\\n> \\\"segment\\\" that you did in your version.\\n> I moved the \\\"lower\\\" and \\\"upper\\\" values in the structs. Also, there are\\n> now also separate \\\"lower\\\" and \\\"upper\\\" values for the leaf levels of\\n> the trees, for 1- 2-, 3- and 4-byte inputs. This made a huge\\n\\nThe \\\"segment\\\" there seems to mean definitely the same to\\nmine. Flattening the on-memory structure is fine from the same\\nreason to the above.\\n\\n> difference to the size of gb18030_to_utf8_radix.map, in particular:\\n> the source file shrank from about 2 MB to 1/2 MB. In that conversion,\\n> the valid range for the last byte of 2-byte inputs is 0x40-0xfe, and\\n> the valid range for the last byte of 4-byte inputs is 0x30-0x39. With\\n> the old patch version, the \\\"chars\\\" range was therefore 0x30-0xfe, to\\n> cover both of those, and most of the array was filled with zeros. With\\n> this new patch version, we store separate ranges for those, and can\\n> leave out most of the zeros.\\n\\nGreat. I agree that the (logically) devided chartable is\\nsignificantly space-efficient.\\n\\n> There's a segment full of zeros at the beginning of each conversion\\n> array now. The purpose of that is that when traversing the radix tree,\\n> you don't need to check each intermediate value for 0. If you follow a\\n> 0 offset, it simply points to the dummy all-zeros segments in the\\n> beginning. Seemed like a good idea to shave some cycles, although I'm\\n> not sure if it made much difference in reality.\\n\\nAnd I like the zero page.\\n\\n> I optimized pg_mb_radix_conv() a bit, too. We could do more. For\\n> example, I think it would save some cycles to have specialized\\n> versions of UtfToLocal and LocalToUtf, moving the tests for whether a\\n> combined character map and/or conversion callback is used, out of the\\n> loop. They feel a bit ugly too, in their current form...\\n\\nHmm. Maybe decomposing iiso in pg_mb_radix_conv is faster than\\npushing extra 3 (or 4) parameters into the stack (or it's wrong\\nif they are passed using registers?) but I'm not sure.\\n\\n> I need a break now, but I'll try to pick this up again some time next\\n> week. Meanwhile, please have a look and tell me what you think.\\n\\nThank you very much for the big effort on this patch.\\n\\nApart from the aboves, I have some trivial comments on the new\\nversion.\\n\\n\\n1. If we decide not to use old-style maps, UtfToLocal no longer\\n need to take void * as map data. (Patch 0001)\\n\\n2. \\\"use Data::Dumper\\\" doesn't seem necessary. (Patch 0002)\\n\\n3. A comment contains a superfluous comma. (Patch 0002) (The last\\n byte of the first line below)\\n > ### The segments are written out physically to one big array in the final,\\n > ### step, but logically, they form a radix tree. Or rather, four radix\\n\\n4. The following code doesn't seem so perl'ish.\\n\\n > for (my $i=0; $i <= 0xff; $i++)\\n > {\\n > my $val = $seg->{values}->{$i};\\n > if ($val)\\n > {\\n > $this_min = $i if (!defined $this_min || $i < $this_min);\\n\\n Refraining from proposing extreme perl, the following would be\\n reasonable as an equivalent. (Patch 0002)\\n\\n foreach $i (keys $seg->{values})\\n {\\n \\n The 0002 patch contains the following change but this might be\\n kinda extreme..\\n\\n - for (my $i=0; $i <= 0xff; $i++)\\n + while ((my $i, my $val) = each $map)\\n\\n4. download_srctxts.sh is no longer needed. (No patch)\\n\\n\\nI'll put more consideration on the new version and put another\\nversion later.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 05 Dec 2016 19:29:54 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, I looked on this closer.\\n\\nThe attached is the revised version of this patch.\\n\\nAt Mon, 05 Dec 2016 19:29:54 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161205.192954.121855559.horiguchi.kyotaro@lab.ntt.co.jp>\\n> Apart from the aboves, I have some trivial comments on the new\\n> version.\\n> \\n> \\n> 1. If we decide not to use old-style maps, UtfToLocal no longer\\n> need to take void * as map data. (Patch 0001)\\n> 2. \\\"use Data::Dumper\\\" doesn't seem necessary. (Patch 0002)\\n> 3. A comment contains a superfluous comma. (Patch 0002) (The last\\n> byte of the first line below)\\n> 4. The following code doesn't seem so perl'ish.\\n> 4. download_srctxts.sh is no longer needed. (No patch)\\n\\n6. Fixed some inconsistent indentation/folding.\\n7. Fix handling of $verbose.\\n8. Sort segments using leading bytes.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 13 Dec 2016 15:11:03 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, I found a bug in my portion while rebasing.\\n\\nThe attached patches apply on top of the current master HEAD, not\\non Heikki's previous one. And separated into 4 parts.\\n\\nAt Tue, 13 Dec 2016 15:11:03 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20161213.151103.157484378.horiguchi.kyotaro@lab.ntt.co.jp>\\n> > Apart from the aboves, I have some trivial comments on the new\\n> > version.\\n> > \\n> > \\n> > 1. If we decide not to use old-style maps, UtfToLocal no longer\\n> > need to take void * as map data. (Patch 0001)\\n\\nI changed the pointer type wrongly. Combined maps are of the type\\n*_combined.\\n\\n> > 2. \\\"use Data::Dumper\\\" doesn't seem necessary. (Patch 0002)\\n> > 3. A comment contains a superfluous comma. (Patch 0002) (The last\\n> > byte of the first line below)\\n> > 4. The following code doesn't seem so perl'ish.\\n> > 5. download_srctxts.sh is no longer needed. (No patch)\\n> \\n> 6. Fixed some inconsistent indentation/folding.\\n> 7. Fix handling of $verbose.\\n> 8. Sort segments using leading bytes.\\n\\nThe attached files are the following. This patchset is not\\ncomplete missing changes of map files. The change is tremendously\\nlarge but generatable.\\n\\n0001-Add-missing-semicolon.patch\\n\\n UCS_to_EUC_JP.pl has a line missing teminating semicolon. This\\n doesn't harm but surely a syntax error. This patch fixes it.\\n This might should be a separate patch.\\n\\n0002-Correct-reference-resolution-syntax.patch\\n\\n convutils.pm has lines with different syntax of reference\\n resolution. This unifies the syntax.\\n\\n0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n\\n Before adding radix tree stuff, applied pgperltidy and inserted\\n format-skipping pragma for the parts where perltidy seems to do\\n too much.\\n\\n0004-Use-radix-tree-for-character-conversion.patch\\n\\n Radix tree body.\\n\\n\\nThe unattached fifth patch is generated by the following steps.\\n\\n[$(TOP)]$ ./configure\\n[Unicode]$ make\\n[Unicode]$ make distclean\\n[Unicode]$ git add .\\n[Unicode]$ commit \\n=== COMMITE MESSSAGE\\nReplace map files with radix tree files.\\n\\nThese encodings no longer uses the former map files and uses new radix\\ntree files.\\n===\\n\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 10 Jan 2017 20:22:23 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"HI,\\n\\nI patched 4 patchset and run \\\"make\\\", but I got failed.\\nIs this a bug or my mistake ?\\nI'm sorry if I'm wrong.\\n\\n[$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\\n[$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\\n[$(TOP)]$ patch -p1 <\\n../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n[$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\\n[$(TOP)]$ ./configure\\n[Unicode]$ make\\n'/usr/bin/perl' UCS_to_most.pl\\nType of arg 1 to keys must be hash (not hash element) at convutils.pm\\nline 443, near \\\"})\\n \\\"\\nType of arg 1 to values must be hash (not hash element) at\\nconvutils.pm line 596, near \\\"})\\n \\\"\\nType of arg 1 to each must be hash (not private variable) at\\nconvutils.pm line 755, near \\\"$map)\\n \\\"\\nCompilation failed in require at UCS_to_most.pl line 19.\\nmake: *** [iso8859_2_to_utf8.map] Error 255\\n\\nRegars,\\n-- \\nAyumi Ishii\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 25 Jan 2017 19:18:26 +0900\",\n \"msg_from\": \"Ishii Ayumi <ayumi.ishii.pg@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, thank you for looking this.\\n\\nAt Wed, 25 Jan 2017 19:18:26 +0900, Ishii Ayumi <ayumi.ishii.pg@gmail.com> wrote in <CAOu5J714+w-TRSNHbsS+aBVE5LdsR3CEZ6w4QLQ=9NrAJNavTA@mail.gmail.com>\\n> I patched 4 patchset and run \\\"make\\\", but I got failed.\\n> Is this a bug or my mistake ?\\n> I'm sorry if I'm wrong.\\n> \\n> [$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\\n> [$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\\n> [$(TOP)]$ patch -p1 <\\n> ../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n> [$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\\n> [$(TOP)]$ ./configure\\n> [Unicode]$ make\\n\\nThe directory src/backend/mb/uilts/Unicode is not built as a part\\nof the top-level build, and it would be preferable that the\\npreexisting map files are removed.\\n\\n$ cd src/backend/utils/mb/Unicode\\n$ make distclean # this would require ./configure\\n$ make maintainer-clean\\n$ cd ../../../../.. # go to top\\n$ make clean\\n(make'ing here will give you an error saying a .map file is not found)\\n$ cd src/backend/utils/mb/Unicode # again\\n$ make\\n$ cd ../../../../.. # go to top\\n$ make\\n\\nThis steps still suceeds for me, even with the patches on the\\ncurrent master.\\n\\nThe cause of the the following errors seems the other things.\\n\\n> '/usr/bin/perl' UCS_to_most.pl\\n> Type of arg 1 to keys must be hash (not hash element) at convutils.pm\\n> line 443, near \\\"})\\n> \\\"\\n> Type of arg 1 to values must be hash (not hash element) at\\n> convutils.pm line 596, near \\\"})\\n> \\\"\\n> Type of arg 1 to each must be hash (not private variable) at\\n> convutils.pm line 755, near \\\"$map)\\n> \\\"\\n> Compilation failed in require at UCS_to_most.pl line 19.\\n> make: *** [iso8859_2_to_utf8.map] Error 255\\n\\nSurely perl 5.8.9 complained just as above but 5.16\\ndoesn't. Google told me that at least 5.10 behaves as the same\\nway. The *current* requirement for perl verion to build is 5.8.\\n\\nhttps://www.postgresql.org/docs/current/static/install-requirements.html\\n\\nFortunately, only three lines of change suffices 5.8 so I've\\nchosen to flatter perl 5.8.\\n\\nAs the result, no changes has been made on 0001-0003 so I\\nattached only 0004 to this mail.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 26 Jan 2017 16:16:56 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Tue, Jan 10, 2017 at 8:22 PM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> [...patch...]\\n\\nNobody has showed up yet to review this patch, so I am giving it a shot.\\n\\nThe patch file sizes are scary at first sight, but after having a look:\\n 36 files changed, 1411 insertions(+), 54398 deletions(-)\\nYes that's a surprise, something like git diff --irreversible-delete\\nwould have helped as most of the diffs are just caused by 3 files\\nbeing deleted in patch 0004, making 50k lines going to the abyss of\\ndeletion.\\n\\n> Hello, I found a bug in my portion while rebasing.\\n\\nRight, that's 0001. Nice catch.\\n\\n> The attached files are the following. This patchset is not\\n> complete missing changes of map files. The change is tremendously\\n> large but generatable.\\n>\\n> 0001-Add-missing-semicolon.patch\\n>\\n> UCS_to_EUC_JP.pl has a line missing teminating semicolon. This\\n> doesn't harm but surely a syntax error. This patch fixes it.\\n> This might should be a separate patch.\\n\\nThis requires a back-patch. This makes me wonder how long this script\\nhas actually not run...\\n\\n> 0002-Correct-reference-resolution-syntax.patch\\n>\\n> convutils.pm has lines with different syntax of reference\\n> resolution. This unifies the syntax.\\n\\nYes that looks right to me. I am the best perl guru on this list but\\nlooking around $$var{foo} is bad, ${$var}{foo} is better, and\\n$var->{foo} is even better. This also generates no diffs when running\\nmake in src/backend/utils/mb/Unicode/. So no objections to that.\\n\\n> 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n>\\n> Before adding radix tree stuff, applied pgperltidy and inserted\\n> format-skipping pragma for the parts where perltidy seems to do\\n> too much.\\n\\nWhich version of perltidy did you use? Looking at the archives, the\\nperl code is cleaned up with a specific version, v20090616. See\\nhttps://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\\nfor example on the matter. As perltidy changes over time, this may be\\na sensitive change if done this way.\\n\\n> 0004-Use-radix-tree-for-character-conversion.patch\\n>\\n> Radix tree body.\\n\\nWell, here a lot of diffs could have been saved.\\n\\n> The unattached fifth patch is generated by the following steps.\\n>\\n> [$(TOP)]$ ./configure\\n> [Unicode]$ make\\n> [Unicode]$ make distclean\\n> [Unicode]$ git add .\\n> [Unicode]$ commit\\n> === COMMITE MESSSAGE\\n> Replace map files with radix tree files.\\n>\\n> These encodings no longer uses the former map files and uses new radix\\n> tree files.\\n> ===\\n\\nOK, I can see that working, with 200k of maps generated.. So going\\nthrough the important bits of this jungle..\\n\\n+/*\\n+ * radix tree conversion function - this should be identical to the function in\\n+ * ../conv.c with the same name\\n+ */\\n+static inline uint32\\n+pg_mb_radix_conv(const pg_mb_radix_tree *rt,\\n+ int l,\\n+ unsigned char b1,\\n+ unsigned char b2,\\n+ unsigned char b3,\\n+ unsigned char b4)\\nThis is not nice. Having a duplication like that is a recipe to forget\\nabout it as this patch introduces a dependency with conv.c and the\\nradix tree generation.\\n\\nHaving a .gitignore in Unicode/ would be nice, particularly to avoid\\ncommitting map_checker.\\n\\nA README documenting things may be welcome, or at least comments at\\nthe top of map_checker.c. Why is map_checker essential? What does it\\ndo? There is no way to understand that easily, except that it includes\\na \\\"radix tree conversion function\\\", and that it performs sanity checks\\non the radix trees to be sure that they are on a good shape. But as\\nthis something that one would guess only after looking at your patch\\nand the code (at least I will sleep less stupid tonight after reading\\nthis stuff).\\n\\n--- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n+++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n # Drop these SJIS codes from the source for UTF8=>SJIS conversion\\n #<<< do not let perltidy touch this\\n-my @reject_sjis =(\\n+my @reject_sjis = (\\n 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\\n- 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n+ 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n 0x879a..0x879c\\n-);\\n+ );\\nThis is not generated, it would be nice to drop the noise from the patch.\\n\\nHere is another one:\\n- $i->{code} = $jis | (\\n- $jis < 0x100\\n- ? 0x8e00\\n- : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n-\\n+#<<< do not let perltidy touch this\\n+ $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\\n+ ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n+#>>>\\n\\n if (l == 2)\\n {\\n- iutf = *utf++ << 8;\\n- iutf |= *utf++;\\n+ b3 = *utf++;\\n+ b4 = *utf++;\\n }\\nAh, OK. This conversion is important so as it performs a minimum of\\nbitwise operations. Yes let's keep that. That's pretty cool to get a\\nfaster operation.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 26 Jan 2017 16:28:16 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Wed, Jan 25, 2017 at 7:18 PM, Ishii Ayumi <ayumi.ishii.pg@gmail.com> wrote:\\n> I patched 4 patchset and run \\\"make\\\", but I got failed.\\n> Is this a bug or my mistake ?\\n> I'm sorry if I'm wrong.\\n>\\n> [$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\\n> [$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\\n> [$(TOP)]$ patch -p1 <\\n> ../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n> [$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\\n> [$(TOP)]$ ./configure\\n> [Unicode]$ make\\n> '/usr/bin/perl' UCS_to_most.pl\\n> Type of arg 1 to keys must be hash (not hash element) at convutils.pm\\n> line 443, near \\\"})\\n> \\\"\\n> Type of arg 1 to values must be hash (not hash element) at\\n> convutils.pm line 596, near \\\"})\\n> \\\"\\n> Type of arg 1 to each must be hash (not private variable) at\\n> convutils.pm line 755, near \\\"$map)\\n> \\\"\\n> Compilation failed in require at UCS_to_most.pl line 19.\\n> make: *** [iso8859_2_to_utf8.map] Error 255\\n\\nHm, I am not sure what you are missing. I was able to get things to build.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 26 Jan 2017 16:29:10 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"At Thu, 26 Jan 2017 16:29:10 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqQd860tOC17O3Qs3+dzZTYbXrXxVD9Tfph0pJ9LAYZ=Ww@mail.gmail.com>\\n> On Wed, Jan 25, 2017 at 7:18 PM, Ishii Ayumi <ayumi.ishii.pg@gmail.com> wrote:\\n> > I patched 4 patchset and run \\\"make\\\", but I got failed.\\n> > Is this a bug or my mistake ?\\n> > I'm sorry if I'm wrong.\\n> >\\n> > [$(TOP)]$ patch -p1 < ../0001-Add-missing-semicolon.patch\\n> > [$(TOP)]$ patch -p1 < ../0002-Correct-reference-resolution-syntax.patch\\n> > [$(TOP)]$ patch -p1 <\\n> > ../0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n> > [$(TOP)]$ patch -p1 < ../0004-Use-radix-tree-for-character-conversion.patch\\n> > [$(TOP)]$ ./configure\\n> > [Unicode]$ make\\n> > '/usr/bin/perl' UCS_to_most.pl\\n> > Type of arg 1 to keys must be hash (not hash element) at convutils.pm\\n> > line 443, near \\\"})\\n> > \\\"\\n> > Type of arg 1 to values must be hash (not hash element) at\\n> > convutils.pm line 596, near \\\"})\\n> > \\\"\\n> > Type of arg 1 to each must be hash (not private variable) at\\n> > convutils.pm line 755, near \\\"$map)\\n> > \\\"\\n> > Compilation failed in require at UCS_to_most.pl line 19.\\n> > make: *** [iso8859_2_to_utf8.map] Error 255\\n> \\n> Hm, I am not sure what you are missing. I was able to get things to build.\\n\\nAs I posted, it should be caused by older perl, at least 5.8\\ncomplains so and 5.16 doesn't.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 26 Jan 2017 21:17:37 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Thank you for looking this.\\n\\nAt Thu, 26 Jan 2017 16:28:16 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqREL1fsDBGv4zRvaXY+UKtS0wzkamJcnYhX0--OZvpUUQ@mail.gmail.com>\\n> On Tue, Jan 10, 2017 at 8:22 PM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> > [...patch...]\\n> \\n> Nobody has showed up yet to review this patch, so I am giving it a shot.\\n> \\n> The patch file sizes are scary at first sight, but after having a look:\\n> 36 files changed, 1411 insertions(+), 54398 deletions(-)\\n> Yes that's a surprise, something like git diff --irreversible-delete\\n> would have helped as most of the diffs are just caused by 3 files\\n> being deleted in patch 0004, making 50k lines going to the abyss of\\n> deletion.\\n\\nThank you. Good to hear that. I'll try that at the next chance.\\n\\n> > Hello, I found a bug in my portion while rebasing.\\n> \\n> Right, that's 0001. Nice catch.\\n> \\n> > The attached files are the following. This patchset is not\\n> > complete missing changes of map files. The change is tremendously\\n> > large but generatable.\\n> >\\n> > 0001-Add-missing-semicolon.patch\\n> >\\n> > UCS_to_EUC_JP.pl has a line missing teminating semicolon. This\\n> > doesn't harm but surely a syntax error. This patch fixes it.\\n> > This might should be a separate patch.\\n> \\n> This requires a back-patch. This makes me wonder how long this script\\n> has actually not run...\\n> \\n> > 0002-Correct-reference-resolution-syntax.patch\\n> >\\n> > convutils.pm has lines with different syntax of reference\\n> > resolution. This unifies the syntax.\\n> \\n> Yes that looks right to me.\\n\\nYes, I thoght that the three patches can be back-patched, a kind\\nof bug fix.\\n\\n> I am the best perl guru on this list but\\n> looking around $$var{foo} is bad, ${$var}{foo} is better, and\\n> $var->{foo} is even better. This also generates no diffs when running\\n> make in src/backend/utils/mb/Unicode/. So no objections to that.\\n\\nThank you for the explanation. I think no '$$'s is left alone.\\n\\n> > 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n> >\\n> > Before adding radix tree stuff, applied pgperltidy and inserted\\n> > format-skipping pragma for the parts where perltidy seems to do\\n> > too much.\\n> \\n> Which version of perltidy did you use? Looking at the archives, the\\n> perl code is cleaned up with a specific version, v20090616. See\\n> https://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\\n> for example on the matter. As perltidy changes over time, this may be\\n> a sensitive change if done this way.\\n\\nHmm. I will make a confirmation on that.. tomorrow.\\n\\n> > 0004-Use-radix-tree-for-character-conversion.patch\\n> >\\n> > Radix tree body.\\n> \\n> Well, here a lot of diffs could have been saved.\\n> \\n> > The unattached fifth patch is generated by the following steps.\\n> >\\n> > [$(TOP)]$ ./configure\\n> > [Unicode]$ make\\n> > [Unicode]$ make distclean\\n> > [Unicode]$ git add .\\n> > [Unicode]$ commit\\n> > === COMMITE MESSSAGE\\n> > Replace map files with radix tree files.\\n> >\\n> > These encodings no longer uses the former map files and uses new radix\\n> > tree files.\\n> > ===\\n> \\n> OK, I can see that working, with 200k of maps generated.. So going\\n> through the important bits of this jungle..\\n\\nMany thaks for the exploration.\\n\\n> +/*\\n> + * radix tree conversion function - this should be identical to the function in\\n> + * ../conv.c with the same name\\n> + */\\n> +static inline uint32\\n> +pg_mb_radix_conv(const pg_mb_radix_tree *rt,\\n> + int l,\\n> + unsigned char b1,\\n> + unsigned char b2,\\n> + unsigned char b3,\\n> + unsigned char b4)\\n> This is not nice. Having a duplication like that is a recipe to forget\\n> about it as this patch introduces a dependency with conv.c and the\\n> radix tree generation.\\n\\nMmmmm. I agree to you, but conv.c contains unwanted reference to\\nelog or other sutff of the core. Separating the function in a\\ndedicate source file named such as \\\"../pg_mb_radix_conv.c\\\" will\\nwork. If it is not so bad, I'll do that in the next version.\\n\\n> Having a .gitignore in Unicode/ would be nice, particularly to avoid\\n> committing map_checker.\\n> \\n> A README documenting things may be welcome, or at least comments at\\n> the top of map_checker.c. Why is map_checker essential? What does it\\n> do? There is no way to understand that easily, except that it includes\\n> a \\\"radix tree conversion function\\\", and that it performs sanity checks\\n> on the radix trees to be sure that they are on a good shape. But as\\n> this something that one would guess only after looking at your patch\\n> and the code (at least I will sleep less stupid tonight after reading\\n> this stuff).\\n\\nOkay, I'll do that.\\n\\n> --- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n> +++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n> # Drop these SJIS codes from the source for UTF8=>SJIS conversion\\n> #<<< do not let perltidy touch this\\n> -my @reject_sjis =(\\n> +my @reject_sjis = (\\n> 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\\n> - 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n> + 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n> 0x879a..0x879c\\n> -);\\n> + );\\n> This is not generated, it would be nice to drop the noise from the patch.\\n\\nMmm. I'm not sure how this is generated but I'll care for that.\\n\\n> Here is another one:\\n> - $i->{code} = $jis | (\\n> - $jis < 0x100\\n> - ? 0x8e00\\n> - : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n> -\\n> +#<<< do not let perltidy touch this\\n> + $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\\n> + ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n> +#>>>\\n\\nOk. Will revert this.\\n\\n> if (l == 2)\\n> {\\n> - iutf = *utf++ << 8;\\n> - iutf |= *utf++;\\n> + b3 = *utf++;\\n> + b4 = *utf++;\\n> }\\n> Ah, OK. This conversion is important so as it performs a minimum of\\n> bitwise operations. Yes let's keep that. That's pretty cool to get a\\n> faster operation.\\n\\nIt is Heikki's work:p\\n\\nI'll address them and repost the next version sooner.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 26 Jan 2017 21:42:12 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hi, this is an intermediate report without a patch.\\n\\nAt Thu, 26 Jan 2017 21:42:12 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170126.214212.111556326.horiguchi.kyotaro@lab.ntt.co.jp>\\n> > > 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n> > >\\n> > > Before adding radix tree stuff, applied pgperltidy and inserted\\n> > > format-skipping pragma for the parts where perltidy seems to do\\n> > > too much.\\n> > \\n> > Which version of perltidy did you use? Looking at the archives, the\\n> > perl code is cleaned up with a specific version, v20090616. See\\n> > https://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\\n> > for example on the matter. As perltidy changes over time, this may be\\n> > a sensitive change if done this way.\\n> \\n> Hmm. I will make a confirmation on that.. tomorrow.\\n\\nMy perltidy -v said \\\"v20121207'. Anyway, I gave up to apply\\nperltidy by myself. So I'll just drop 0003 and new 0004 (name\\nchanged to 0003) is made immediately on 0002.\\n\\n> > > 0004-Use-radix-tree-for-character-conversion.patch\\n> > >\\n> > > Radix tree body.\\n> > \\n> > Well, here a lot of diffs could have been saved.\\n> > \\n> > > The unattached fifth patch is generated by the following steps.\\n> > >\\n> > > [$(TOP)]$ ./configure\\n> > > [Unicode]$ make\\n> > > [Unicode]$ make distclean\\n> > > [Unicode]$ git add .\\n> > > [Unicode]$ commit\\n> > > === COMMITE MESSSAGE\\n> > > Replace map files with radix tree files.\\n> > >\\n> > > These encodings no longer uses the former map files and uses new radix\\n> > > tree files.\\n> > > ===\\n> > \\n> > OK, I can see that working, with 200k of maps generated.. So going\\n> > through the important bits of this jungle..\\n> \\n> Many thaks for the exploration.\\n> \\n> > +/*\\n> > + * radix tree conversion function - this should be identical to the function in\\n> > + * ../conv.c with the same name\\n..\\n> > This is not nice. Having a duplication like that is a recipe to forget\\n> > about it as this patch introduces a dependency with conv.c and the\\n> > radix tree generation.\\n\\nIn the attatched patch, mb/char_conveter.c which contains one\\ninline function is created and it is includ'ed from mb/conv.c and\\nmb/Unicode/map_checker.c.\\n\\n> > Having a .gitignore in Unicode/ would be nice, particularly to avoid\\n> > committing map_checker.\\n\\nI missed this. I added .gitignore to ignore map_checker stuff\\nand authority files and old-style map files.\\n\\n> > A README documenting things may be welcome, or at least comments at\\n> > the top of map_checker.c. Why is map_checker essential? What does it\\n> > do? There is no way to understand that easily, except that it includes\\n> > a \\\"radix tree conversion function\\\", and that it performs sanity checks\\n> > on the radix trees to be sure that they are on a good shape. But as\\n> > this something that one would guess only after looking at your patch\\n> > and the code (at least I will sleep less stupid tonight after reading\\n> > this stuff).\\n> \\n> Okay, I'll do that.\\n\\nThe patch has not been provided yet, I'm going to put the\\nfollowing comment just before the main() in map_checker.c.\\n\\n/*\\n * The old-style plain map files were error-resistant due to its\\n * straight-forward way for generation from authority files. In contrast the\\n * radix tree maps are generated by a rather complex calculation and have a\\n * complex, hard-to-confirm format.\\n *\\n * This program runs sanity check of the radix tree maps by confirming all\\n * characters in the plain map files to be converted to the same code by the\\n * corresponding radix tree map.\\n *\\n * All map files are included by map_checker.h that is generated by the script\\n * make_mapchecker.pl as the variable mappairs.\\n *\\n */\\n\\n\\nI'll do the following things later.\\n\\n> > --- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n> > +++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n> > # Drop these SJIS codes from the source for UTF8=>SJIS conversion\\n> > #<<< do not let perltidy touch this\\n> > -my @reject_sjis =(\\n> > +my @reject_sjis = (\\n> > 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\\n> > - 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n> > + 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n> > 0x879a..0x879c\\n> > -);\\n> > + );\\n> > This is not generated, it would be nice to drop the noise from the patch.\\n> \\n> Mmm. I'm not sure how this is generated but I'll care for that.\\n> \\n> > Here is another one:\\n> > - $i->{code} = $jis | (\\n> > - $jis < 0x100\\n> > - ? 0x8e00\\n> > - : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n> > -\\n> > +#<<< do not let perltidy touch this\\n> > + $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\\n> > + ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n> > +#>>>\\n> \\n> Ok. Will revert this.\\n> \\n> > if (l == 2)\\n> > {\\n> > - iutf = *utf++ << 8;\\n> > - iutf |= *utf++;\\n> > + b3 = *utf++;\\n> > + b4 = *utf++;\\n> > }\\n> > Ah, OK. This conversion is important so as it performs a minimum of\\n> > bitwise operations. Yes let's keep that. That's pretty cool to get a\\n> > faster operation.\\n> \\n> It is Heikki's work:p\\n> \\n> I'll address them and repost the next version sooner.\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 27 Jan 2017 17:33:57 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello, this is the revised version of character conversion using radix tree.\\n\\nAt Fri, 27 Jan 2017 17:33:57 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170127.173357.221584433.horiguchi.kyotaro@lab.ntt.co.jp>\\n> Hi, this is an intermediate report without a patch.\\n> \\n> At Thu, 26 Jan 2017 21:42:12 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170126.214212.111556326.horiguchi.kyotaro@lab.ntt.co.jp>\\n> > > > 0003-Apply-pgperltidy-on-src-backend-utils-mb-Unicode.patch\\n> > > >\\n> > > > Before adding radix tree stuff, applied pgperltidy and inserted\\n> > > > format-skipping pragma for the parts where perltidy seems to do\\n> > > > too much.\\n> > > \\n> > > Which version of perltidy did you use? Looking at the archives, the\\n> > > perl code is cleaned up with a specific version, v20090616. See\\n> > > https://www.postgresql.org/message-id/20151204054322.GA2070309@tornado.leadboat.com\\n> > > for example on the matter. As perltidy changes over time, this may be\\n> > > a sensitive change if done this way.\\n> \\n> My perltidy -v said \\\"v20121207'. Anyway, I gave up to apply\\n> perltidy by myself. So I'll just drop 0003 and new 0004 (name\\n> changed to 0003) is made immediately on 0002.\\n\\nI'm not sure what to handle this so I just removed the perltidy\\nstuff from this patchset.\\n\\n> > > > 0004-Use-radix-tree-for-character-conversion.patch\\n> > > >\\n> > > > Radix tree body.\\n> > > \\n> > > Well, here a lot of diffs could have been saved.\\n> > > \\n> > > > The unattached fifth patch is generated by the following steps.\\n> > > >\\n> > > > [$(TOP)]$ ./configure\\n> > > > [Unicode]$ make\\n> > > > [Unicode]$ make distclean\\n> > > > [Unicode]$ git add .\\n> > > > [Unicode]$ commit\\n> > > > === COMMITE MESSSAGE\\n> > > > Replace map files with radix tree files.\\n> > > >\\n> > > > These encodings no longer uses the former map files and uses new radix\\n> > > > tree files.\\n> > > > ===\\n> > > \\n> > > OK, I can see that working, with 200k of maps generated.. So going\\n> > > through the important bits of this jungle..\\n> > \\n> > Many thaks for the exploration.\\n> > \\n> > > +/*\\n> > > + * radix tree conversion function - this should be identical to the function in\\n> > > + * ../conv.c with the same name\\n> ..\\n> > > This is not nice. Having a duplication like that is a recipe to forget\\n> > > about it as this patch introduces a dependency with conv.c and the\\n> > > radix tree generation.\\n> \\n> In the attatched patch, mb/char_conveter.c which contains one\\n> inline function is created and it is includ'ed from mb/conv.c and\\n> mb/Unicode/map_checker.c.\\n> \\n> > > Having a .gitignore in Unicode/ would be nice, particularly to avoid\\n> > > committing map_checker.\\n> \\n> I missed this. I added .gitignore to ignore map_checker stuff\\n> and authority files and old-style map files.\\n> \\n> > > A README documenting things may be welcome, or at least comments at\\n> > > the top of map_checker.c. Why is map_checker essential? What does it\\n> > > do? There is no way to understand that easily, except that it includes\\n> > > a \\\"radix tree conversion function\\\", and that it performs sanity checks\\n> > > on the radix trees to be sure that they are on a good shape. But as\\n> > > this something that one would guess only after looking at your patch\\n> > > and the code (at least I will sleep less stupid tonight after reading\\n> > > this stuff).\\n> > \\n> > Okay, I'll do that.\\n> \\n> The patch has not been provided yet, I'm going to put the\\n> following comment just before the main() in map_checker.c.\\n> \\n> /*\\n> * The old-style plain map files were error-resistant due to its\\n> * straight-forward way for generation from authority files. In contrast the\\n> * radix tree maps are generated by a rather complex calculation and have a\\n> * complex, hard-to-confirm format.\\n> *\\n> * This program runs sanity check of the radix tree maps by confirming all\\n> * characters in the plain map files to be converted to the same code by the\\n> * corresponding radix tree map.\\n> *\\n> * All map files are included by map_checker.h that is generated by the script\\n> * make_mapchecker.pl as the variable mappairs.\\n> *\\n> */\\n> \\n> \\n> I'll do the following things later.\\n\\nThe following is the continuation.\\n\\n> > --- a/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n> > +++ b/src/backend/utils/mb/Unicode/UCS_to_SJIS.pl\\n> > # Drop these SJIS codes from the source for UTF8=>SJIS conversion\\n> > #<<< do not let perltidy touch this\\n> > -my @reject_sjis =(\\n> > +my @reject_sjis = (\\n> > 0xed40..0xeefc, 0x8754..0x875d, 0x878a, 0x8782,\\n> > - 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n> > + 0x8784, 0xfa5b, 0xfa54, 0x8790..0x8792, 0x8795..0x8797,\\n> > 0x879a..0x879c\\n> > -);\\n> > + );\\n> > This is not generated, it would be nice to drop the noise from the patch.\\n> \\n> Mmm. I'm not sure how this is generated but I'll care for that.\\n\\nI don't still understand what what the intermediate diff comes\\nfrom but copy-n-pasting from master silenced it...\\n\\n> > Here is another one:\\n> > - $i->{code} = $jis | (\\n> > - $jis < 0x100\\n> > - ? 0x8e00\\n> > - : ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n> > -\\n> > +#<<< do not let perltidy touch this\\n> > + $i->{code} = $jis | ($jis < 0x100 ? 0x8e00:\\n> > + ($sjis >= 0xeffd ? 0x8f8080 : 0x8080));\\n> > +#>>>\\n> \\n> Ok. Will revert this.\\n\\nThe \\\"previous\\\" code (prefixed with a minus sign) is \\\"my\\\"\\nperltidy's work. Preltidy step is just removed from the patchset.\\n\\n> > if (l == 2)\\n> > {\\n> > - iutf = *utf++ << 8;\\n> > - iutf |= *utf++;\\n> > + b3 = *utf++;\\n> > + b4 = *utf++;\\n> > }\\n> > Ah, OK. This conversion is important so as it performs a minimum of\\n> > bitwise operations. Yes let's keep that. That's pretty cool to get a\\n> > faster operation.\\n> \\n> It is Heikki's work:p\\n> \\n> I'll address them and repost the next version sooner.\\n\\n\\nFinally, the patchset had the following changes from the previous\\nshape.\\n\\n- Avoid syntaxes perl 5.8 complains about\\n\\n- The perltidy step has been removed.\\n\\n- pg_mb_radix_conv is now a separate .c file (but included from\\n other c files)\\n\\n- Added Unicode/.gitignore. The line for [~#] might be needless.\\n\\n- The patchset are made with --irreversible-delete. This is just\\n what I wanted (but counldn't find by myself..)\\n\\n- Semicolon-fix patch(0001) gets several additional fixes.\\n\\n\\n\\nThis patchset consists of four patches. The first two are bug\\nfixes back-patchable to older versions. The third one is the\\npatch that adds radix tree feature. The forth one is not attached\\nto this mail but generatable.\\n\\n0001-Add-missing-semicolon.patch\\n\\n Adds missing semicolon found in three files.\\n\\n0002-Correct-reference-resolution-syntax.patch\\n\\n Changes reference syntax to more preferable style.\\n\\n0003-Use-radix-tree-for-character-conversion.patch\\n\\n Radix tree conversion patch. The size has been reduced from\\n 1.6MB to 91KB.\\n\\n0004: Replace map files\\n\\n This is not attached but generatable. This shouldn't fail even\\n on the environment with perl 5.8.\\n\\n [$(TOP)]$ ./configure\\n [$(TOP)]$ cd src/backend/utils/mb/Unicode\\n [Unicode]$ make distclean maintainer-clean all\\n [Unicode]$ make mapcheck\\n ...\\n All radix trees are perfect!\\n [Unicode]$ make distclean\\n [Unicode]$ git add .\\n [Unicode]$ git commit\\n ...\\n\\n The size of the forth patch was about 7.6MB using --irreversible-delete.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 30 Jan 2017 15:37:38 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Mon, Jan 30, 2017 at 3:37 PM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> Hello, this is the revised version of character conversion using radix tree.\\n\\nThanks for the new version, I'll look at it once I am done with the\\ncleanup of the current CF. For now I have moved it to the CF 2017-03.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 31 Jan 2017 12:25:46 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"At Tue, 31 Jan 2017 12:25:46 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqSGWmHwZqaOA--EHCveG9m77pjWRzxZ6B5iUSJ7GKz-4w@mail.gmail.com>\\n> On Mon, Jan 30, 2017 at 3:37 PM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> > Hello, this is the revised version of character conversion using radix tree.\\n> \\n> Thanks for the new version, I'll look at it once I am done with the\\n> cleanup of the current CF. For now I have moved it to the CF 2017-03.\\n\\nAgreed. Thank you.\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 31 Jan 2017 19:06:09 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Tnanks to that Heikki have pushed the first two patches and a\\npart of the third, only one patch is remaining now.\\n\\n# Sorry for not separating KOI8 stuffs.\\n\\nAt Tue, 31 Jan 2017 19:06:09 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170131.190609.254672218.horiguchi.kyotaro@lab.ntt.co.jp>\\n> > Thanks for the new version, I'll look at it once I am done with the\\n> > cleanup of the current CF. For now I have moved it to the CF 2017-03.\\n> \\n> Agreed. Thank you.\\n\\nAttached is the latest version on the current master (555494d).\\n\\nNote: since this patch is created by git diff --irreversble-delete,\\nthree files mb/Unicode/*.(txt|xml) to be deleted are left alone.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 03 Feb 2017 13:18:26 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Fri, Feb 3, 2017 at 1:18 PM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> Thanks to that Heikki have pushed the first two patches and a\\n> part of the third, only one patch is remaining now.\\n>\\n> # Sorry for not separating KOI8 stuffs.\\n>\\n> At Tue, 31 Jan 2017 19:06:09 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170131.190609.254672218.horiguchi.kyotaro@lab.ntt.co.jp>\\n>> > Thanks for the new version, I'll look at it once I am done with the\\n>> > cleanup of the current CF. For now I have moved it to the CF 2017-03.\\n>>\\n>> Agreed. Thank you.\\n>\\n> Attached is the latest version on the current master (555494d).\\n>\\n> Note: since this patch is created by git diff --irreversble-delete,\\n> three files mb/Unicode/*.(txt|xml) to be deleted are left alone.\\n\\nThanks for the rebase. I have been spending sore time looking at this\\npatch. The new stuff in convutils.pm is by far the interesting part of\\nthe patch, where the building of the radix trees using a byte\\nstructure looks in pretty good shape after eyeballing the logic for a\\ncouple of hours.\\n\\n+# ignore backup files of editors\\n+/*[~#]\\n+\\nThis does not belong to Postgres core code. You could always set up\\nthat in a global exclude file with core.excludefiles.\\n\\nIn order to conduct sanity checks on the shape of the radix tree maps\\ncompared to the existing maps, having map_checker surely makes sense.\\nNow in the final result I don't think we need it. The existing map\\nfiles ought to be replaced by their radix versions at the end, and\\nmap_checker should be removed. This leads to a couple of\\nsimplifications, like Makefile, and reduces the maintenance to one\\nmechanism.\\n\\n+sub print_radix_trees\\n+{\\n+ my ($this_script, $csname, $charset) = @_;\\n+\\n+ &print_radix_map($this_script, $csname, \\\"from_unicode\\\", $charset, 78);\\n+ &print_radix_map($this_script, $csname, \\\"to_unicode\\\", $charset, 78);\\n+}\\nThere is no need for the table width to be defined as a variable (5th\\nargument). Similarly, to_unicode/from_unicode require checks in\\nmultiple places, this could be just a simple boolean flag. Or if you\\nwant to go to the road of non-simple things, you could have two\\narguments: an origin and a target. If one is UTF8 the other is the\\nmapping name.\\n\\n+sub dump_charset\\n+{\\n+ my ($list, $filt) = @_;\\n+\\n+ foreach my $i (@$list)\\n+ {\\n+ next if (defined $filt && !&$filt($i));\\n+ if (!defined $i->{ucs}) { $i->{ucs} = &utf2ucs($i->{utf8}); }\\n+ printf \\\"ucs=%x, code=%x, direction=%s %s:%d %s\\\\n\\\",\\n+ $i->{ucs}, $i->{code}, $i->{direction},\\n+ $i->{f}, $i->{l}, $i->{comment};\\n+ }\\n+}\\nThis is used nowhere. Perhaps it was useful for debugging at some point?\\n\\n+# make_charmap - convert charset table to charmap hash\\n+# with checking duplicate source code\\nMaybe this should be \\\"with checking of duplicated source codes\\\".\\n\\n+# print_radix_map($this_script, $csname, $direction, \\\\%charset, $tblwidth)\\n+#\\n+# this_script - the name of the *caller script* of this feature\\n$this_script is not needed at all, you could just use basename($0) and\\nreduce the number of arguments of the different functions of the\\nstack.\\n\\n+ ### amount of zeros that can be ovarlaid.\\ns/ovarlaid/overlaid.\\n\\n+# make_mapchecker.pl - Gerates map_checker.h file included by map_checker.c\\ns/gerates/generates/\\n\\n+ if (s < 0x80)\\n+ {\\n+ fprintf(stderr, \\\"\\\\nASCII character ? (%x)\\\", s);\\n+ exit(1);\\n+ }\\nMost likely a newline at the end of the error string is better here.\\n\\n+ $charmap{ ucs2utf($src) } = $dst;\\n+ }\\n+\\n+ }\\nUnnecessary newline here.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 22 Feb 2017 16:06:14 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Thank you for the comment.\\n\\nAt Wed, 22 Feb 2017 16:06:14 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqRTQ+7ZjxuPTbsr18MXvW7mTd29mN+91N7AG8fe5aCeAA@mail.gmail.com>\\n> Thanks for the rebase. I have been spending sore time looking at this\\n> patch. The new stuff in convutils.pm is by far the interesting part of\\n> the patch, where the building of the radix trees using a byte\\n> structure looks in pretty good shape after eyeballing the logic for a\\n> couple of hours.\\n> \\n> +# ignore backup files of editors\\n> +/*[~#]\\n> +\\n> This does not belong to Postgres core code. You could always set up\\n> that in a global exclude file with core.excludefiles.\\n\\nThank you for letting me know about it. I removed that.\\n\\n> In order to conduct sanity checks on the shape of the radix tree maps\\n> compared to the existing maps, having map_checker surely makes sense.\\n> Now in the final result I don't think we need it. The existing map\\n> files ought to be replaced by their radix versions at the end, and\\n> map_checker should be removed. This leads to a couple of\\n> simplifications, like Makefile, and reduces the maintenance to one\\n> mechanism.\\n\\nHmm.. Though I don't remember clearly what the radix map of the\\nfirst version looked like, the current radix map seems\\nhuman-readable for me. It might be by practice or by additional\\ncomments in map files. Anyway I removed all of the stuff so as\\nnot to generate the plain maps. But I didn't change the names of\\n_radix.map and just commented out the line to output the plain\\nmaps in UCS_to_*.pl. Combined maps are still in the plain format\\nso print_tables was changed to take character tables separately\\nfor regular (non-combined) characters and combined characters.\\n\\n> +sub print_radix_trees\\n> +{\\n> + my ($this_script, $csname, $charset) = @_;\\n> +\\n> + &print_radix_map($this_script, $csname, \\\"from_unicode\\\", $charset, 78);\\n> + &print_radix_map($this_script, $csname, \\\"to_unicode\\\", $charset, 78);\\n> +}\\n> There is no need for the table width to be defined as a variable (5th\\n> argument).\\n\\nThe table width was already useless.. Removed.\\n\\n> Similarly, to_unicode/from_unicode require checks in\\n> multiple places, this could be just a simple boolean flag.\\n\\nThe direction is a tristate (to/from/both) variable so cannot be\\nreplaced with a boolean. But I agree that comparing with free\\nstring is not so good. This is a change already committed in the\\nmaster but it is changed in the attached patch.\\n\\n# Perhaps it is easier to read in string form..\\n\\n> Or if you want to go to the road of non-simple things, you\\n> could have two arguments: an origin and a target. If one is\\n> UTF8 the other is the mapping name.\\n\\nMmmm. It seems (even) to me to give more harm than good. I can\\nguess two alternatives for this.\\n\\n- Split the property {direction} into two boolean properties\\n {to_unicode} and {from_unicode}.\\n\\n- Make the {direction} property an integer and compared with\\n defined constants $BOTH, $TO_UNICODE and $FROM_UNICODE using\\n the '=' operator.\\n\\nI choosed the former in this patch.\\n\\n> +sub dump_charset\\n> +{\\n> + my ($list, $filt) = @_;\\n> +\\n> + foreach my $i (@$list)\\n> + {\\n> + next if (defined $filt && !&$filt($i));\\n> + if (!defined $i->{ucs}) { $i->{ucs} = &utf2ucs($i->{utf8}); }\\n> + printf \\\"ucs=%x, code=%x, direction=%s %s:%d %s\\\\n\\\",\\n> + $i->{ucs}, $i->{code}, $i->{direction},\\n> + $i->{f}, $i->{l}, $i->{comment};\\n> + }\\n> +}\\n> This is used nowhere. Perhaps it was useful for debugging at some point?\\n\\nYes, it was quite useful. Removed.\\n\\n> +# make_charmap - convert charset table to charmap hash\\n> +# with checking duplicate source code\\n> Maybe this should be \\\"with checking of duplicated source codes\\\".\\n\\nEven though I'm not good English writer, 'duplicated codes' looks\\nas multiple copies of the original 'code' (for me, of\\ncourse). And the 'checking' is a (pure) verbal noun (means not a\\ndeverbal noun) so 'of' is not required. But, of course, I'm not\\nsure which sounds more natural as English.\\n\\nThis comment is not changed.\\n\\n> +# print_radix_map($this_script, $csname, $direction, \\\\%charset, $tblwidth)\\n> +#\\n> +# this_script - the name of the *caller script* of this feature\\n> $this_script is not needed at all, you could just use basename($0) and\\n> reduce the number of arguments of the different functions of the\\n> stack.\\n\\nI avoided relying on global stuff by that but I accept the\\nsuggestion. Fixed in this version.\\n\\n> + ### amount of zeros that can be ovarlaid.\\n> s/ovarlaid/overlaid.\\n> \\n> +# make_mapchecker.pl - Gerates map_checker.h file included by map_checker.c\\n> s/gerates/generates/\\n\\nmake_mapcheker.pl is a tool only for map_checker.c so this files\\nis removed.\\n\\n> + if (s < 0x80)\\n> + {\\n> + fprintf(stderr, \\\"\\\\nASCII character ? (%x)\\\", s);\\n> + exit(1);\\n> + }\\n> Most likely a newline at the end of the error string is better here.\\n\\nmap_checker.c is removed.\\n\\n> + $charmap{ ucs2utf($src) } = $dst;\\n> + }\\n> +\\n> + }\\n> Unnecessary newline here.\\n\\nremoved in convutils.pm.\\n\\nSince Makefile ignores old .map files, the steps to generate a\\npatch for map files was a bit chaged.\\n\\n$ rm *.map\\n$ make distclean maintainer-clean all\\n$ make distclean\\n$ git add .\\n$ git commit\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 27 Feb 2017 17:37:33 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Mon, Feb 27, 2017 at 2:07 PM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>> +# make_charmap - convert charset table to charmap hash\\n>> +# with checking duplicate source code\\n>> Maybe this should be \\\"with checking of duplicated source codes\\\".\\n>\\n> Even though I'm not good English writer, 'duplicated codes' looks\\n> as multiple copies of the original 'code' (for me, of\\n> course). And the 'checking' is a (pure) verbal noun (means not a\\n> deverbal noun) so 'of' is not required. But, of course, I'm not\\n> sure which sounds more natural as English\\n\\nThe problem is that, because \\\"checking\\\" is a noun in this sentence, it\\ncan't be followed by a direct object so you need \\\"of\\\" to connect\\n\\\"checking\\\" with the thing that is being checked. However, what I\\nwould do is rearrange this sentence slightly as to use \\\"checking\\\" as a\\nverb, like this:\\n\\nconvert charset table to charmap hash, checking for duplicate source\\ncodes along the way\\n\\nWhile I don't think Michael's suggestion is wrong, I find the above a\\nlittle more natural.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 28 Feb 2017 08:00:22 +0530\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Tue, 28 Feb 2017 08:00:22 +0530, Robert Haas <robertmhaas@gmail.com> wrote in <CA+TgmoYheGx+knBQAMBm+nr8Cnr7e2RZm1BEwgK5AGMx4MKv9A@mail.gmail.com>\\n> On Mon, Feb 27, 2017 at 2:07 PM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> >> +# make_charmap - convert charset table to charmap hash\\n> >> +# with checking duplicate source code\\n> >> Maybe this should be \\\"with checking of duplicated source codes\\\".\\n> >\\n> > Even though I'm not good English writer, 'duplicated codes' looks\\n> > as multiple copies of the original 'code' (for me, of\\n> > course). And the 'checking' is a (pure) verbal noun (means not a\\n> > deverbal noun) so 'of' is not required. But, of course, I'm not\\n> > sure which sounds more natural as English\\n> \\n> The problem is that, because \\\"checking\\\" is a noun in this sentence, it\\n> can't be followed by a direct object so you need \\\"of\\\" to connect\\n> \\\"checking\\\" with the thing that is being checked. However, what I\\n> would do is rearrange this sentence slightly as to use \\\"checking\\\" as a\\n> verb, like this:\\n> \\n> convert charset table to charmap hash, checking for duplicate source\\n> codes along the way\\n> \\n> While I don't think Michael's suggestion is wrong, I find the above a\\n> little more natural.\\n\\nThank you for the suggestion and explantion. I leaned that,\\nmaybe. I'll send the version with the revised comment.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 28 Feb 2017 13:19:10 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Mon, Feb 27, 2017 at 5:37 PM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> At Wed, 22 Feb 2017 16:06:14 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqRTQ+7ZjxuPTbsr18MXvW7mTd29mN+91N7AG8fe5aCeAA@mail.gmail.com>\\n>> In order to conduct sanity checks on the shape of the radix tree maps\\n>> compared to the existing maps, having map_checker surely makes sense.\\n>> Now in the final result I don't think we need it. The existing map\\n>> files ought to be replaced by their radix versions at the end, and\\n>> map_checker should be removed. This leads to a couple of\\n>> simplifications, like Makefile, and reduces the maintenance to one\\n>> mechanism.\\n>\\n> Hmm.. Though I don't remember clearly what the radix map of the\\n> first version looked like, the current radix map seems\\n> human-readable for me. It might be by practice or by additional\\n> comments in map files. Anyway I removed all of the stuff so as\\n> not to generate the plain maps. But I didn't change the names of\\n> _radix.map and just commented out the line to output the plain\\n> maps in UCS_to_*.pl. Combined maps are still in the plain format\\n> so print_tables was changed to take character tables separately\\n> for regular (non-combined) characters and combined characters.\\n\\nDo others have thoughts to offer on the matter? I would think that the\\nnew radix maps should just replace by the old plain ones, and that the\\nonly way to build the maps going forward is to use the new methods.\\nThe radix trees is the only thing used in the backend code as well\\n(conv.c). We could keep the way to build the old maps, with the\\nmap_checker in module out of the core code. FWIW, I am fine to add the\\nold APIs in my plugin repository on github and have the sanity checks\\nin that as well. And of course also publish on this thread a module to\\ndo that.\\n\\n>> Or if you want to go to the road of non-simple things, you\\n>> could have two arguments: an origin and a target. If one is\\n>> UTF8 the other is the mapping name.\\n>\\n> Mmmm. It seems (even) to me to give more harm than good. I can\\n> guess two alternatives for this.\\n>\\n> - Split the property {direction} into two boolean properties\\n> {to_unicode} and {from_unicode}.\\n>\\n> - Make the {direction} property an integer and compared with\\n> defined constants $BOTH, $TO_UNICODE and $FROM_UNICODE using\\n> the '=' operator.\\n>\\n> I choosed the former in this patch.\\n\\nFine for me.\\n\\n>> + $charmap{ ucs2utf($src) } = $dst;\\n>> + }\\n>> +\\n>> + }\\n>> Unnecessary newline here.\\n>\\n> removed in convutils.pm.\\n>\\n> Since Makefile ignores old .map files, the steps to generate a\\n> patch for map files was a bit chaged.\\n>\\n> $ rm *.map\\n> $ make distclean maintainer-clean all\\n> $ make distclean\\n> $ git add .\\n> $ git commit\\n\\n+# ignore generated files\\n+/map_checker\\n+/map_checker.h\\n[...]\\n+map_checker.h: make_mapchecker.pl $(MAPS) $(RADIXMAPS)\\n+ $(PERL) $<\\n+\\n+map_checker.o: map_checker.c map_checker.h ../char_converter.c\\n+\\n+map_checker: map_checker.o\\nWith map_checker out of the game, those things are not needed.\\n\\n+++ b/src/backend/utils/mb/char_converter.c\\n@@ -0,0 +1,116 @@\\n+/*-------------------------------------------------------------------------\\n+ *\\n+ * Character converter function using radix tree\\nIn the simplified version of the patch, pg_mb_radix_conv() being only\\nneeded in conv.c I think that this could just be a static local\\nroutine.\\n\\n-#include \\\"../../Unicode/utf8_to_koi8r.map\\\"\\n-#include \\\"../../Unicode/koi8r_to_utf8.map\\\"\\n-#include \\\"../../Unicode/utf8_to_koi8u.map\\\"\\n-#include \\\"../../Unicode/koi8u_to_utf8.map\\\"\\n+#include \\\"../../Unicode/utf8_to_koi8r_radix.map\\\"\\n+#include \\\"../../Unicode/koi8r_to_utf8_radix.map\\\"\\n+#include \\\"../../Unicode/utf8_to_koi8u_radix.map\\\"\\n+#include \\\"../../Unicode/koi8u_to_utf8_radix.map\\\"\\nFWIW, I am fine to use those new names as include points.\\n\\n-distclean: clean\\n+distclean:\\n rm -f $(TEXTS)\\n-maintainer-clean: distclean\\n+# maintainer-clean intentionally leaves $(TEXTS)\\n+maintainer-clean:\\nWhy is that? There is also a useless diff down that code block.\\n\\n+conv.o: conv.c char_converter.c\\nThis also can go away.\\n\\n-print_tables(\\\"EUC_JIS_2004\\\", \\\\@all, 1);\\n+# print_tables(\\\"EUC_JIS_2004\\\", \\\\@regular, undef, 1);\\n+print_radix_trees(\\\"EUC_JIS_2004\\\", \\\\@regular);\\n+print_tables(\\\"EUC_JIS_2004\\\", undef, \\\\@combined, 1);\\n[...]\\n sub print_tables\\n {\\n- my ($charset, $table, $verbose) = @_;\\n+ my ($charset, $regular, $combined, $verbose) = @_;\\nprint_tables is only used for combined maps, you could remove $regular\\nfrom it and just keep $combined around, perhaps renaming print_tables\\nto print_combined_maps?\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 28 Feb 2017 15:20:06 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"At Tue, 28 Feb 2017 15:20:06 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqR49krGP6qaaKaL2v3HCnn+dnzv8Dq_ySGbDSr6b_ywrw@mail.gmail.com>\\n> On Mon, Feb 27, 2017 at 5:37 PM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> > At Wed, 22 Feb 2017 16:06:14 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqRTQ+7ZjxuPTbsr18MXvW7mTd29mN+91N7AG8fe5aCeAA@mail.gmail.com>\\n> >> In order to conduct sanity checks on the shape of the radix tree maps\\n> >> compared to the existing maps, having map_checker surely makes sense.\\n> >> Now in the final result I don't think we need it. The existing map\\n> >> files ought to be replaced by their radix versions at the end, and\\n> >> map_checker should be removed. This leads to a couple of\\n> >> simplifications, like Makefile, and reduces the maintenance to one\\n> >> mechanism.\\n> >\\n> > Hmm.. Though I don't remember clearly what the radix map of the\\n> > first version looked like, the current radix map seems\\n> > human-readable for me. It might be by practice or by additional\\n> > comments in map files. Anyway I removed all of the stuff so as\\n> > not to generate the plain maps. But I didn't change the names of\\n> > _radix.map and just commented out the line to output the plain\\n> > maps in UCS_to_*.pl. Combined maps are still in the plain format\\n> > so print_tables was changed to take character tables separately\\n> > for regular (non-combined) characters and combined characters.\\n> \\n> Do others have thoughts to offer on the matter? I would think that the\\n> new radix maps should just replace by the old plain ones, and that the\\n> only way to build the maps going forward is to use the new methods.\\n> The radix trees is the only thing used in the backend code as well\\n> (conv.c). We could keep the way to build the old maps, with the\\n> map_checker in module out of the core code. FWIW, I am fine to add the\\n> old APIs in my plugin repository on github and have the sanity checks\\n> in that as well. And of course also publish on this thread a module to\\n> do that.\\n\\nI couldn't make out my mind to move to radix tree completely, but\\nUtfToLocal/LocalToUtf no longer handle the \\\"plain map\\\"s for\\nnon-combined character so they have lost their planground. Okay,\\nI think I removed all the trace of the plain map era.\\n\\nEvery characters in a mapping has a comment that describes what\\nthe character is or where it is defined. This information is no\\nlonger useful (radix map doesn't have a plance to show it) but\\nI left it for debug use. (This might just be justification..)\\n\\n> > - Split the property {direction} into two boolean properties\\n> > {to_unicode} and {from_unicode}.\\n> >\\n> > - Make the {direction} property an integer and compared with\\n> > defined constants $BOTH, $TO_UNICODE and $FROM_UNICODE using\\n> > the '=' operator.\\n> >\\n> > I choosed the former in this patch.\\n> \\n> Fine for me.\\n\\nThanks.\\n\\n> >> + $charmap{ ucs2utf($src) } = $dst;\\n> >> + }\\n> >> +\\n> >> + }\\n> >> Unnecessary newline here.\\n> >\\n> > removed in convutils.pm.\\n> >\\n> > Since Makefile ignores old .map files, the steps to generate a\\n> > patch for map files was a bit chaged.\\n> >\\n> > $ rm *.map\\n> > $ make distclean maintainer-clean all\\n> > $ make distclean\\n> > $ git add .\\n> > $ git commit\\n> \\n> +# ignore generated files\\n> +/map_checker\\n> +/map_checker.h\\n> [...]\\n> +map_checker.h: make_mapchecker.pl $(MAPS) $(RADIXMAPS)\\n> + $(PERL) $<\\n> +\\n> +map_checker.o: map_checker.c map_checker.h ../char_converter.c\\n> +\\n> +map_checker: map_checker.o\\n> With map_checker out of the game, those things are not needed.\\n\\nOuch! Thanks for pointing out it. Removed.\\n\\n> +++ b/src/backend/utils/mb/char_converter.c\\n> @@ -0,0 +1,116 @@\\n> +/*-------------------------------------------------------------------------\\n> + *\\n> + * Character converter function using radix tree\\n> In the simplified version of the patch, pg_mb_radix_conv() being only\\n> needed in conv.c I think that this could just be a static local\\n> routine.\\n> \\n> -#include \\\"../../Unicode/utf8_to_koi8r.map\\\"\\n> -#include \\\"../../Unicode/koi8r_to_utf8.map\\\"\\n> -#include \\\"../../Unicode/utf8_to_koi8u.map\\\"\\n> -#include \\\"../../Unicode/koi8u_to_utf8.map\\\"\\n> +#include \\\"../../Unicode/utf8_to_koi8r_radix.map\\\"\\n> +#include \\\"../../Unicode/koi8r_to_utf8_radix.map\\\"\\n> +#include \\\"../../Unicode/utf8_to_koi8u_radix.map\\\"\\n> +#include \\\"../../Unicode/koi8u_to_utf8_radix.map\\\"\\n> FWIW, I am fine to use those new names as include points.\\n> \\n> -distclean: clean\\n> +distclean:\\n> rm -f $(TEXTS)\\n> -maintainer-clean: distclean\\n> +# maintainer-clean intentionally leaves $(TEXTS)\\n> +maintainer-clean:\\n> Why is that? There is also a useless diff down that code block.\\n\\nIt *was* for convenience but now it is automatically downloaded\\nso such distinction donsn't offer anything good. Changed it to\\nremove $(TEXTS).\\n\\n> +conv.o: conv.c char_converter.c\\n> This also can go away.\\n\\nTouching char_converter.c will be ignored if it is removed. Did\\nyou mistake it for map_checker?\\n\\n> -print_tables(\\\"EUC_JIS_2004\\\", \\\\@all, 1);\\n> +# print_tables(\\\"EUC_JIS_2004\\\", \\\\@regular, undef, 1);\\n> +print_radix_trees(\\\"EUC_JIS_2004\\\", \\\\@regular);\\n> +print_tables(\\\"EUC_JIS_2004\\\", undef, \\\\@combined, 1);\\n> [...]\\n> sub print_tables\\n> {\\n> - my ($charset, $table, $verbose) = @_;\\n> + my ($charset, $regular, $combined, $verbose) = @_;\\n> print_tables is only used for combined maps, you could remove $regular\\n> from it and just keep $combined around, perhaps renaming print_tables\\n> to print_combined_maps?\\n\\nRenamed to print_combied_maps.\\n\\nAnd the code-comment pointed in the comment by the previous mail\\nis rewritten as Robert's suggestion.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 28 Feb 2017 17:34:02 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Tue, Feb 28, 2017 at 5:34 PM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> At Tue, 28 Feb 2017 15:20:06 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqR49krGP6qaaKaL2v3HCnn+dnzv8Dq_ySGbDSr6b_ywrw@mail.gmail.com>\\n>> +conv.o: conv.c char_converter.c\\n>> This also can go away.\\n>\\n> Touching char_converter.c will be ignored if it is removed. Did\\n> you mistake it for map_checker?\\n\\nThat was not what I meant: as pg_mb_radix_conv() is only used in\\nconv.c, it may be better to just remove completely char_converter.c.\\n\\n> And the code-comment pointed in the comment by the previous mail\\n> is rewritten as Robert's suggestion.\\n\\nFine for me.\\n\\n-distclean: clean\\n+distclean:\\n rm -f $(TEXTS)\\n\\n-maintainer-clean: distclean\\n- rm -f $(MAPS)\\n-\\n+maintainer-clean:\\n+ rm -f $(TEXTS) $(MAPS)\\nWell, I would have assumed that this should not change..\\n\\nThe last version of the patch looks in rather good shape to me, we are\\nalso sure that the sanity checks on the old maps and the new maps\\nmatch per the previous runs with map_checker. One thing that still\\nneed some extra opinions is what to do with the old maps:\\n1) Just remove them, replacing the old maps by the new radix tree maps.\\n2) Keep them around in the backend code, even if they are useless.\\n3) Use a GUC to be able to switch from one to the other, giving a\\nfallback method in case of emergency.\\n4) Use an extension module to store the old maps with as well the\\nprevious build code, so as sanity checks can still be performed on the\\nnew maps.\\n\\nI would vote for 2), to reduce long term maintenance burdens and after\\nseeing all the sanity checks that have been done in previous versions.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 1 Mar 2017 14:34:23 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"At Wed, 1 Mar 2017 14:34:23 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqQ_4n+FDWi5Xiueo68i=fTmdg1Wx+y6XWWX=8rAhKRtFw@mail.gmail.com>\\n> On Tue, Feb 28, 2017 at 5:34 PM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> > At Tue, 28 Feb 2017 15:20:06 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqR49krGP6qaaKaL2v3HCnn+dnzv8Dq_ySGbDSr6b_ywrw@mail.gmail.com>\\n> >> +conv.o: conv.c char_converter.c\\n> >> This also can go away.\\n> >\\n> > Touching char_converter.c will be ignored if it is removed. Did\\n> > you mistake it for map_checker?\\n> \\n> That was not what I meant: as pg_mb_radix_conv() is only used in\\n> conv.c, it may be better to just remove completely char_converter.c.\\n\\nOuch! You're right. Sorry for my short-sight. char_converter.c is\\nremoved and related description in Makefile is removed.\\n\\n> > And the code-comment pointed in the comment by the previous mail\\n> > is rewritten as Robert's suggestion.\\n> \\n> Fine for me.\\n> \\n> -distclean: clean\\n> +distclean:\\n> rm -f $(TEXTS)\\n> \\n> -maintainer-clean: distclean\\n> - rm -f $(MAPS)\\n> -\\n> +maintainer-clean:\\n> + rm -f $(TEXTS) $(MAPS)\\n> Well, I would have assumed that this should not change..\\n\\nI should have reverted there but actually the patch somehow does\\nthe different thing.. Surely reverted it this time.\\n\\n> The last version of the patch looks in rather good shape to me, we are\\n> also sure that the sanity checks on the old maps and the new maps\\n> match per the previous runs with map_checker.\\n\\nAgreed.\\n\\n> One thing that still\\n> need some extra opinions is what to do with the old maps:\\n> 1) Just remove them, replacing the old maps by the new radix tree maps.\\n> 2) Keep them around in the backend code, even if they are useless.\\n> 3) Use a GUC to be able to switch from one to the other, giving a\\n> fallback method in case of emergency.\\n> 4) Use an extension module to store the old maps with as well the\\n> previous build code, so as sanity checks can still be performed on the\\n> new maps.\\n> \\n> I would vote for 2), to reduce long term maintenance burdens and after\\n> seeing all the sanity checks that have been done in previous versions.\\n\\nI don't vote 3 and 4. And I did 1 in the last patch.\\n\\nAbout 2, any change in the authority files rarely but possiblly\\nhappens. Even in the case the plain map files are no longer can\\nbe generated. (but can with a bit tweak of convutils.pm) If the\\nradix-tree file generator is under a suspicion, the \\\"plain\\\" map\\nfile generator (and the map_checker) or some other means to\\nsanity check might be required.\\n\\nThat being said, when something occurs in radix files, we can\\nfind it in the radix file and can find the corresponding lines in\\nthe aurhority file. The remaining problem is the case where some\\nsubstantial change in authority files doesn't affect radix\\nfiles. We can detect such mistake by detecting changes in\\nauthority files. So I propose the 5th option.\\n\\n5) Just remove plain map files and all related code. Addition to\\n that, Makefile stores hash digest of authority files in\\n Unicode/authoriy_hashes.txt or something that is managed by\\n git.\\n\\nThis digest may differ among platforms (typically from cr/nl\\ndifference) but we can assume *nix for the usage.\\n\\nI will send the next version after this discussion is settled.\\n\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 02 Mar 2017 14:20:00 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Thu, Mar 2, 2017 at 2:20 PM, Kyotaro HORIGUCHI\\n<horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> 5) Just remove plain map files and all related code. Addition to\\n> that, Makefile stores hash digest of authority files in\\n> Unicode/authoriy_hashes.txt or something that is managed by\\n> git.\\n\\nThat may be an idea to check for differences across upstream versions.\\nBut that sounds like a separate discussion to me.\\n\\n> This digest may differ among platforms (typically from cr/nl\\n> difference) but we can assume *nix for the usage.\\n>\\n> I will send the next version after this discussion is settled.\\n\\nSure. There is not much point to move on without Heikki's opinion at\\nleast, or anybody else like Ishii-san or Tom who are familiar with\\nthis code. I would think that Heikki would be the committer to pick up\\nthis change though.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 3 Mar 2017 12:53:04 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Fri, 3 Mar 2017 12:53:04 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqSQaLozFNg+5Tf9s1TZs2pcE-GHhnMG31qnsusV9vMUOw@mail.gmail.com>\\n> On Thu, Mar 2, 2017 at 2:20 PM, Kyotaro HORIGUCHI\\n> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n> > 5) Just remove plain map files and all related code. Addition to\\n> > that, Makefile stores hash digest of authority files in\\n> > Unicode/authoriy_hashes.txt or something that is managed by\\n> > git.\\n> \\n> That may be an idea to check for differences across upstream versions.\\n> But that sounds like a separate discussion to me.\\n\\nFine with me either.\\n\\n> > This digest may differ among platforms (typically from cr/nl\\n> > difference) but we can assume *nix for the usage.\\n> >\\n> > I will send the next version after this discussion is settled.\\n> \\n> Sure. There is not much point to move on without Heikki's opinion at\\n> least, or anybody else like Ishii-san or Tom who are familiar with\\n> this code. I would think that Heikki would be the committer to pick up\\n> this change though.\\n\\nSo, this is the latest version of this patch in the shape of the\\noption 1.\\n\\n\\n| need some extra opinions is what to do with the old maps:\\n| 1) Just remove them, replacing the old maps by the new radix tree maps.\\n| 2) Keep them around in the backend code, even if they are useless.\\n| 3) Use a GUC to be able to switch from one to the other, giving a\\n| fallback method in case of emergency.\\n| 4) Use an extension module to store the old maps with as well the\\n| previous build code, so as sanity checks can still be performed on the\\n| new maps.\\n\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 06 Mar 2017 17:16:09 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 03/06/2017 10:16 AM, Kyotaro HORIGUCHI wrote:\\n> At Fri, 3 Mar 2017 12:53:04 +0900, Michael Paquier <michael.paquier@gmail.com> wrote in <CAB7nPqSQaLozFNg+5Tf9s1TZs2pcE-GHhnMG31qnsusV9vMUOw@mail.gmail.com>\\n>> On Thu, Mar 2, 2017 at 2:20 PM, Kyotaro HORIGUCHI\\n>> <horiguchi.kyotaro@lab.ntt.co.jp> wrote:\\n>>> 5) Just remove plain map files and all related code. Addition to\\n>>> that, Makefile stores hash digest of authority files in\\n>>> Unicode/authoriy_hashes.txt or something that is managed by\\n>>> git.\\n>>\\n>> That may be an idea to check for differences across upstream versions.\\n>> But that sounds like a separate discussion to me.\\n>\\n> Fine with me either.\\n\\nI did some more kibitzing here and there, and committed. Thanks everyone!\\n\\nI agree the new maps should just replace the old maps altogether, so \\ncommitted that way. I also moved the combined map files to the same .map \\nfiles as the main radix trees. Seems more clear that way to me.\\n\\nI changed the to/from_unicode properties back to a single direction \\nproperty, with Perl constants BOTH, TO_UNICODE and FROM_UNICODE, per \\nyour alternative suggestion upthread. Seems more clear to me.\\n\\nIt would be nice to run the map_checker tool one more time, though, to \\nverify that the mappings match those from PostgreSQL 9.6. Just to be \\nsure, and after that the map checker can go to the dustbin.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 13 Mar 2017 20:48:07 +0200\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Heikki Linnakangas <hlinnaka@iki.fi> writes:\\n> I did some more kibitzing here and there, and committed. Thanks everyone!\\n\\n111 files changed, 147742 insertions(+), 367346 deletions(-)\\n\\nNice.\\n\\n> It would be nice to run the map_checker tool one more time, though, to \\n> verify that the mappings match those from PostgreSQL 9.6.\\n\\n+1\\n\\n> Just to be sure, and after that the map checker can go to the dustbin.\\n\\nHm, maybe we should keep it around for the next time somebody has a bright\\nidea in this area?\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 13 Mar 2017 14:53:17 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 03/13/2017 08:53 PM, Tom Lane wrote:\\n> Heikki Linnakangas <hlinnaka@iki.fi> writes:\\n>> It would be nice to run the map_checker tool one more time, though, to\\n>> verify that the mappings match those from PostgreSQL 9.6.\\n>\\n> +1\\n>\\n>> Just to be sure, and after that the map checker can go to the dustbin.\\n>\\n> Hm, maybe we should keep it around for the next time somebody has a bright\\n> idea in this area?\\n\\nThe map checker compares old-style maps with the new radix maps. The \\nnext time 'round, we'll need something that compares the radix maps with \\nthe next great thing. Not sure how easy it would be to adapt.\\n\\nHmm. A somewhat different approach might be more suitable for testing \\nacross versions, though. We could modify the perl scripts slightly to \\nprint out SQL statements that exercise every mapping. For every \\nsupported conversion, the SQL script could:\\n\\n1. create a database in the source encoding.\\n2. set client_encoding='<target encoding>'\\n3. SELECT a string that contains every character in the source encoding.\\n\\nYou could then run those SQL statements against old and new server \\nversion, and verify that you get the same results.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 13 Mar 2017 21:07:39 +0200\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On Tue, Mar 14, 2017 at 4:07 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> On 03/13/2017 08:53 PM, Tom Lane wrote:\\n>> Heikki Linnakangas <hlinnaka@iki.fi> writes:\\n>>>\\n>>> It would be nice to run the map_checker tool one more time, though, to\\n>>> verify that the mappings match those from PostgreSQL 9.6.\\n>>\\n>> +1\\n\\nNice to login and see that committed!\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 14 Mar 2017 08:59:42 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Thank you for committing this.\\n\\nAt Mon, 13 Mar 2017 21:07:39 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <d5b70078-9f57-0f63-3462-1e564a57739f@iki.fi>\\n> On 03/13/2017 08:53 PM, Tom Lane wrote:\\n> > Heikki Linnakangas <hlinnaka@iki.fi> writes:\\n> >> It would be nice to run the map_checker tool one more time, though, to\\n> >> verify that the mappings match those from PostgreSQL 9.6.\\n> >\\n> > +1\\n> >\\n> >> Just to be sure, and after that the map checker can go to the dustbin.\\n> >\\n> > Hm, maybe we should keep it around for the next time somebody has a\\n> > bright\\n> > idea in this area?\\n> \\n> The map checker compares old-style maps with the new radix maps. The\\n> next time 'round, we'll need something that compares the radix maps\\n> with the next great thing. Not sure how easy it would be to adapt.\\n> \\n> Hmm. A somewhat different approach might be more suitable for testing\\n> across versions, though. We could modify the perl scripts slightly to\\n> print out SQL statements that exercise every mapping. For every\\n> supported conversion, the SQL script could:\\n> \\n> 1. create a database in the source encoding.\\n> 2. set client_encoding='<target encoding>'\\n> 3. SELECT a string that contains every character in the source\\n> encoding.\\n\\nThere are many encodings that can be client-encoding but cannot\\nbe database-encoding. And some encodings such as UTF-8 has\\nseveral one-way conversion. If we do something like this, it\\nwould be as the following.\\n\\n1. Encoding test\\n1-1. create a database in UTF-8\\n1-2. set client_encoding='<source encoding>'\\n1-3. INSERT all characters defined in the source encoding.\\n1-4. set client_encoding='UTF-8'\\n1-5. SELECT a string that contains every character in UTF-8.\\n2. Decoding test\\n\\n.... sucks!\\n\\n\\nI would like to use convert() function. It can be a large\\nPL/PgSQL function or a series of \\\"SELECT convert(...)\\\"s. The\\nlatter is doable on-the-fly (by not generating/storing the whole\\nscript).\\n\\n| -- Test for SJIS->UTF-8 conversion\\n| ...\\n| SELECT convert('\\\\0000', 'SJIS', 'UTF-8'); -- results in error\\n| ...\\n| SELECT convert('\\\\897e', 'SJIS', 'UTF-8');\\n\\n> You could then run those SQL statements against old and new server\\n> version, and verify that you get the same results.\\n\\nIncluding the result files in the repository will make this easy\\nbut unacceptably bloats. Put mb/Unicode/README.sanity_check?\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 17 Mar 2017 14:19:31 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"On 03/17/2017 07:19 AM, Kyotaro HORIGUCHI wrote:\\n> At Mon, 13 Mar 2017 21:07:39 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <d5b70078-9f57-0f63-3462-1e564a57739f@iki.fi>\\n>> Hmm. A somewhat different approach might be more suitable for testing\\n>> across versions, though. We could modify the perl scripts slightly to\\n>> print out SQL statements that exercise every mapping. For every\\n>> supported conversion, the SQL script could:\\n>>\\n>> 1. create a database in the source encoding.\\n>> 2. set client_encoding='<target encoding>'\\n>> 3. SELECT a string that contains every character in the source\\n>> encoding.\\n>\\n> There are many encodings that can be client-encoding but cannot\\n> be database-encoding.\\n\\nGood point.\\n\\n> I would like to use convert() function. It can be a large\\n> PL/PgSQL function or a series of \\\"SELECT convert(...)\\\"s. The\\n> latter is doable on-the-fly (by not generating/storing the whole\\n> script).\\n>\\n> | -- Test for SJIS->UTF-8 conversion\\n> | ...\\n> | SELECT convert('\\\\0000', 'SJIS', 'UTF-8'); -- results in error\\n> | ...\\n> | SELECT convert('\\\\897e', 'SJIS', 'UTF-8');\\n\\nMakes sense.\\n\\n>> You could then run those SQL statements against old and new server\\n>> version, and verify that you get the same results.\\n>\\n> Including the result files in the repository will make this easy\\n> but unacceptably bloats. Put mb/Unicode/README.sanity_check?\\n\\nYeah, a README with instructions on how to do sounds good. No need to \\ninclude the results in the repository, you can run the script against an \\nolder version when you need something to compare with.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 17 Mar 2017 13:03:35 +0200\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nAt Fri, 17 Mar 2017 13:03:35 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <01efd334-b839-0450-1b63-f2dea9326a7e@iki.fi>\\n> On 03/17/2017 07:19 AM, Kyotaro HORIGUCHI wrote:\\n> > I would like to use convert() function. It can be a large\\n> > PL/PgSQL function or a series of \\\"SELECT convert(...)\\\"s. The\\n> > latter is doable on-the-fly (by not generating/storing the whole\\n> > script).\\n> >\\n> > | -- Test for SJIS->UTF-8 conversion\\n> > | ...\\n> > | SELECT convert('\\\\0000', 'SJIS', 'UTF-8'); -- results in error\\n> > | ...\\n> > | SELECT convert('\\\\897e', 'SJIS', 'UTF-8');\\n> \\n> Makes sense.\\n> \\n> >> You could then run those SQL statements against old and new server\\n> >> version, and verify that you get the same results.\\n> >\\n> > Including the result files in the repository will make this easy\\n> > but unacceptably bloats. Put mb/Unicode/README.sanity_check?\\n> \\n> Yeah, a README with instructions on how to do sounds good. No need to\\n> include the results in the repository, you can run the script against\\n> an older version when you need something to compare with.\\n\\nOk, I'll write a small script to generate a set of \\\"conversion\\ndump\\\" and try to write README.sanity_check describing how to use\\nit.\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 21 Mar 2017 13:10:48 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"At Tue, 21 Mar 2017 13:10:48 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170321.131048.150321071.horiguchi.kyotaro@lab.ntt.co.jp>\\n> At Fri, 17 Mar 2017 13:03:35 +0200, Heikki Linnakangas <hlinnaka@iki.fi> wrote in <01efd334-b839-0450-1b63-f2dea9326a7e@iki.fi>\\n> > On 03/17/2017 07:19 AM, Kyotaro HORIGUCHI wrote:\\n> > > I would like to use convert() function. It can be a large\\n> > > PL/PgSQL function or a series of \\\"SELECT convert(...)\\\"s. The\\n> > > latter is doable on-the-fly (by not generating/storing the whole\\n> > > script).\\n> > >\\n> > > | -- Test for SJIS->UTF-8 conversion\\n> > > | ...\\n> > > | SELECT convert('\\\\0000', 'SJIS', 'UTF-8'); -- results in error\\n> > > | ...\\n> > > | SELECT convert('\\\\897e', 'SJIS', 'UTF-8');\\n> > \\n> > Makes sense.\\n> > \\n> > >> You could then run those SQL statements against old and new server\\n> > >> version, and verify that you get the same results.\\n> > >\\n> > > Including the result files in the repository will make this easy\\n> > > but unacceptably bloats. Put mb/Unicode/README.sanity_check?\\n> > \\n> > Yeah, a README with instructions on how to do sounds good. No need to\\n> > include the results in the repository, you can run the script against\\n> > an older version when you need something to compare with.\\n> \\n> Ok, I'll write a small script to generate a set of \\\"conversion\\n> dump\\\" and try to write README.sanity_check describing how to use\\n> it.\\n\\nI found that there's no way to identify the character domain of a\\nconversion on SQL interface. Unconditionally giving from 0 to\\n0xffffffff as a bytea string yields too-bloat result by containg\\nmany bogus lines. (If \\\\x40 is a character, convert() also\\naccepts \\\\x4040, \\\\x404040 and \\\\x40404040)\\n\\nOne more annoyance is the fact that mappings and conversion\\nprocedures are not in one-to-one correspondence. The\\ncorresnponcence is hidden in conversion_procs/*.c files so we\\nshould extract it from them or provide as knowledge. Both don't\\nseem good.\\n\\nFinally, it seems that I have no choice than resurrecting\\nmap_checker. The exactly the same one no longer works but\\nmap_dumper.c with almost the same structure will work.\\n\\nIf no one objects to adding map_dumper.c and\\ngen_mapdumper_header.pl (tentavie name, of course), I'll make a\\npatch to do that.\\n\\nAny suggestions?\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 23 Mar 2017 12:13:07 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n },\n {\n \"msg_contents\": \"Hmm, things are bit different.\\n\\nAt Thu, 23 Mar 2017 12:13:07 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in <20170323.121307.241436413.horiguchi.kyotaro@lab.ntt.co.jp>\\n> > Ok, I'll write a small script to generate a set of \\\"conversion\\n> > dump\\\" and try to write README.sanity_check describing how to use\\n> > it.\\n> \\n> I found that there's no way to identify the character domain of a\\n> conversion on SQL interface. Unconditionally giving from 0 to\\n> 0xffffffff as a bytea string yields too-bloat result by containg\\n> many bogus lines. (If \\\\x40 is a character, convert() also\\n> accepts \\\\x4040, \\\\x404040 and \\\\x40404040)\\n> \\n> One more annoyance is the fact that mappings and conversion\\n> procedures are not in one-to-one correspondence. The\\n> corresnponcence is hidden in conversion_procs/*.c files so we\\n> should extract it from them or provide as knowledge. Both don't\\n> seem good.\\n> \\n> Finally, it seems that I have no choice than resurrecting\\n> map_checker. The exactly the same one no longer works but\\n> map_dumper.c with almost the same structure will work.\\n> \\n> If no one objects to adding map_dumper.c and\\n> gen_mapdumper_header.pl (tentavie name, of course), I'll make a\\n> patch to do that.\\n\\nThe scirpt or executable should be compatible between versions\\nbut pg_mb_radix_conv is not. On the other hand more upper level\\nAPI reuiqres server stuff.\\n\\nFinally I made an extension that dumps encoding conversion.\\n\\nencoding_dumper('SJIS', 'UTF-8') or encoding_dumper(35, 6)\\n\\nThen it returns the following output consists of two BYTEAs.\\n\\n srccode | dstcode \\n---------+----------\\n \\\\x01 | \\\\x01\\n \\\\x02 | \\\\x02\\n...\\n \\\\xfc4a | \\\\xe9b899\\n \\\\xfc4b | \\\\xe9bb91\\n(7914 rows)\\n\\nThis returns in a very short time but doesn't when srccode\\nextends to 4 bytes. As an extreme example the following,\\n\\n> =# select * from encoding_dumper('UTF-8', 'LATIN1');\\n\\ntakes over 2 minutes to return only 255 rows. We cannot determine\\nthe exact domain without looking into map data so the function\\ncannot do other than looping through all the four-byte values.\\nProviding a function that gives the domain for a conversion was a\\nmess, especially for artithmetic-conversions. The following query\\ntook 94 minutes to give 25M lines/125MB. In short, that's a\\ncrap. (the first attached)\\n\\nSELECT x.conname, y.srccode, y.dstcode\\nFROM\\n (\\n SELECT conname, conforencoding, contoencoding\\n FROM pg_conversion c\\n WHERE pg_char_to_encoding('UTF-8') IN (c.conforencoding, c.contoencoding)\\n AND pg_char_to_encoding('SQL_ASCII')\\n NOT IN (c.conforencoding, c.contoencoding)) as x,\\n LATERAL (\\n SELECT srccode, dstcode\\n FROM encoding_dumper(x.conforencoding, x.contoencoding)) as y\\nORDER BY x.conforencoding, x.contoencoding, y.srccode;\\n\\n\\nAs the another way, I added a measure to generate plain mapping\\nlists corresponding to .map files (similar to old maps but\\nsimpler) and this finishes the work within a second.\\n\\n$ make mapdumps\\n\\nIf we will not shortly change the framework of mapped character\\nconversion, the dumper program may be useful but I'm not sure\\nthis is reasonable as sanity check for future modifications. In\\nthe PoC, pg_mb_radix_tree() is copied into map_checker.c but this\\nneeds to be a separate file again. (the second attached)\\n\\n\\nregards,\\n\\n-- \\nKyotaro Horiguchi\\nNTT Open Source Software Center\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 27 Mar 2017 19:05:43 +0900 (Tokyo Standard Time)\",\n \"msg_from\": \"Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Radix tree for character conversion\"\n }\n]","isConversational":false}}},{"rowIdx":43089,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"While reading the logical replication (and related) code, I found a few unused\nfunction arguments:\n\n\t * XactLogCommitRecord() - unused argument forceSync\n\n\t * SnapBuildBuildSnapshot() - xid\n\n\t * TeardownHistoricSnapshot() - is_error\n\nNo idea which ones are intended for future use and which ones can be\nremoved.\n\n-- \nAntonin Houska\nCybertec Schönig & Schönig GmbH\nGröhrmühlgasse 26\nA-2700 Wiener Neustadt\nWeb: http://www.postgresql-support.de, http://www.cybertec.at\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 05 Sep 2016 11:26:39 +0200","msg_from":"Antonin Houska <ah@cybertec.at>","msg_from_op":true,"msg_subject":"Unused function arguments"}],"string":"[\n {\n \"msg_contents\": \"While reading the logical replication (and related) code, I found a few unused\\nfunction arguments:\\n\\n\\t * XactLogCommitRecord() - unused argument forceSync\\n\\n\\t * SnapBuildBuildSnapshot() - xid\\n\\n\\t * TeardownHistoricSnapshot() - is_error\\n\\nNo idea which ones are intended for future use and which ones can be\\nremoved.\\n\\n-- \\nAntonin Houska\\nCybertec Schönig & Schönig GmbH\\nGröhrmühlgasse 26\\nA-2700 Wiener Neustadt\\nWeb: http://www.postgresql-support.de, http://www.cybertec.at\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 05 Sep 2016 11:26:39 +0200\",\n \"msg_from\": \"Antonin Houska <ah@cybertec.at>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Unused function arguments\"\n }\n]","isConversational":false}}},{"rowIdx":43090,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi all\n\nNow that it's becoming more common to post patch series, not just\nstandalone patches, it might be worth looking at how the CF app can\nhelp manage them.\n\nAny ideas? Especially since the patch series may not get committed all\nin one go, but progressively rebased on top of the bits that did get\ncommitted until it's all in?\n\nMaking one CF app entry for this doesn't work well. It's confusing,\nspammy in terms of number of entries involved, confusing for potential\nreviewers, and pretty useless unless each patch is independent of all\nthe others. In which case they shouldn't be a series in the first\nplace.\n\nA \"partly committed\" status doesn't help much; it doesn't signal\nwhether the rest is waiting for author response, awaiting review after\nrevision, etc.\n\nSo far I've just not been flagging it committed at all until\neverything is. Or creating new CF entries that are immediately set to\n\"committed\" for each part that goes in. But neither seems ideal.\n\nIdeas?\n\n-- \n Craig Ringer http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 18:43:51 +0800","msg_from":"Craig Ringer <craig@2ndquadrant.com>","msg_from_op":true,"msg_subject":"CF app and patch series"},{"msg_contents":"Craig Ringer wrote:\n> Hi all\n> \n> Now that it's becoming more common to post patch series, not just\n> standalone patches, it might be worth looking at how the CF app can\n> help manage them.\n> \n> Any ideas?\n\nI agree that we don't consider this case at all currently and that it's\ncausing some pain. \n\nMIME parsing is mind-boggling. Trying to figure out *one* patch file\nfrom an email is already pretty difficult. Trying to figure out more\nthan one might be nightmarish. Maybe Magnus will contradict me and say\nit's trivial to do -- that'd be great.\n\nI don't have any great ideas for how to support this; I'd say it would\nbe something like the CF entry has sub-entries one for each patch in the\nseries, that can be closed independently. This probably involves\nsurgery to the CF database and app which I'm not volunteering to write,\nhowever. Django-enabled contributors speak up now ...\n\nI think for the time being we should keep the single entry as \"needs\nreview\" or whatever open state until there is nothing left in\ncommittable state, then close as \"committed\"; the parts that were not\ncommitted can be resent as a new series to a later CF. In the\nannotations section, add a link to the latest version each time it's\nposted, along with some indication of how many parts are left[1]. Perhaps\nif a part is committed and there's no new version submitted soon, also\nadd an annotation to indicate that.\n\n[1] Do not, as I've seen some do in the past, delete the old annotations\nwhile adding new ones.\n\n-- \n�lvaro Herrera http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 12:48:11 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: CF app and patch series"},{"msg_contents":"On Thu, Sep 8, 2016 at 5:48 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\nwrote:\n\n> Craig Ringer wrote:\n> > Hi all\n> >\n> > Now that it's becoming more common to post patch series, not just\n> > standalone patches, it might be worth looking at how the CF app can\n> > help manage them.\n> >\n> > Any ideas?\n>\n> I agree that we don't consider this case at all currently and that it's\n> causing some pain.\n>\n> MIME parsing is mind-boggling. Trying to figure out *one* patch file\n> from an email is already pretty difficult. Trying to figure out more\n> than one might be nightmarish. Maybe Magnus will contradict me and say\n> it's trivial to do -- that'd be great.\n>\n\nNothing is ever trivial :)\n\nActually, the archives collect all attachments. And they're available in\nthe API there. But the commitfest app only keeps the first one.\n\nSo would it be trivial to collect more? Not really. Would it be\nnightmarish? No, not that either.\n\nSo if we can figure out how to actually work it into the UI of the CF app,\nit should certainly be doable to track multiple attachments.\n\n\n\n> I don't have any great ideas for how to support this; I'd say it would\n> be something like the CF entry has sub-entries one for each patch in the\n> series, that can be closed independently. This probably involves\n> surgery to the CF database and app which I'm not volunteering to write,\n> however. Django-enabled contributors speak up now ...\n>\n\nYeah, that would require a bit more surgery. Not sure how to represent it\nthough, if those patches are all typically sent in the same mailthread.\nWhich I guess they are. Because then that thread would have to be attached\nto all of those sub-entries, which would kind of defeat the purpose?\n\n-- \n Magnus Hagander\n Me: http://www.hagander.net/\n Work: http://www.redpill-linpro.com/\n\nOn Thu, Sep 8, 2016 at 5:48 PM, Alvaro Herrera <alvherre@2ndquadrant.com> wrote:Craig Ringer wrote:\n> Hi all\n>\n> Now that it's becoming more common to post patch series, not just\n> standalone patches, it might be worth looking at how the CF app can\n> help manage them.\n>\n> Any ideas?\n\nI agree that we don't consider this case at all currently and that it's\ncausing some pain.\n\nMIME parsing is mind-boggling. Trying to figure out *one* patch file\nfrom an email is already pretty difficult. Trying to figure out more\nthan one might be nightmarish. Maybe Magnus will contradict me and say\nit's trivial to do -- that'd be great.Nothing is ever trivial :)Actually, the archives collect all attachments. And they're available in the API there. But the commitfest app only keeps the first one.So would it be trivial to collect more? Not really. Would it be nightmarish? No, not that either. So if we can figure out how to actually work it into the UI of the CF app, it should certainly be doable to track multiple attachments. \nI don't have any great ideas for how to support this; I'd say it would\nbe something like the CF entry has sub-entries one for each patch in the\nseries, that can be closed independently. This probably involves\nsurgery to the CF database and app which I'm not volunteering to write,\nhowever. Django-enabled contributors speak up now ...Yeah, that would require a bit more surgery. Not sure how to represent it though, if those patches are all typically sent in the same mailthread. Which I guess they are. Because then that thread would have to be attached to all of those sub-entries, which would kind of defeat the purpose?-- Magnus Hagander Me: http://www.hagander.net/ Work: http://www.redpill-linpro.com/","msg_date":"Fri, 9 Sep 2016 12:22:55 +0200","msg_from":"Magnus Hagander <magnus@hagander.net>","msg_from_op":false,"msg_subject":"Re: CF app and patch series"}],"string":"[\n {\n \"msg_contents\": \"Hi all\\n\\nNow that it's becoming more common to post patch series, not just\\nstandalone patches, it might be worth looking at how the CF app can\\nhelp manage them.\\n\\nAny ideas? Especially since the patch series may not get committed all\\nin one go, but progressively rebased on top of the bits that did get\\ncommitted until it's all in?\\n\\nMaking one CF app entry for this doesn't work well. It's confusing,\\nspammy in terms of number of entries involved, confusing for potential\\nreviewers, and pretty useless unless each patch is independent of all\\nthe others. In which case they shouldn't be a series in the first\\nplace.\\n\\nA \\\"partly committed\\\" status doesn't help much; it doesn't signal\\nwhether the rest is waiting for author response, awaiting review after\\nrevision, etc.\\n\\nSo far I've just not been flagging it committed at all until\\neverything is. Or creating new CF entries that are immediately set to\\n\\\"committed\\\" for each part that goes in. But neither seems ideal.\\n\\nIdeas?\\n\\n-- \\n Craig Ringer http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 18:43:51 +0800\",\n \"msg_from\": \"Craig Ringer <craig@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"CF app and patch series\"\n },\n {\n \"msg_contents\": \"Craig Ringer wrote:\\n> Hi all\\n> \\n> Now that it's becoming more common to post patch series, not just\\n> standalone patches, it might be worth looking at how the CF app can\\n> help manage them.\\n> \\n> Any ideas?\\n\\nI agree that we don't consider this case at all currently and that it's\\ncausing some pain. \\n\\nMIME parsing is mind-boggling. Trying to figure out *one* patch file\\nfrom an email is already pretty difficult. Trying to figure out more\\nthan one might be nightmarish. Maybe Magnus will contradict me and say\\nit's trivial to do -- that'd be great.\\n\\nI don't have any great ideas for how to support this; I'd say it would\\nbe something like the CF entry has sub-entries one for each patch in the\\nseries, that can be closed independently. This probably involves\\nsurgery to the CF database and app which I'm not volunteering to write,\\nhowever. Django-enabled contributors speak up now ...\\n\\nI think for the time being we should keep the single entry as \\\"needs\\nreview\\\" or whatever open state until there is nothing left in\\ncommittable state, then close as \\\"committed\\\"; the parts that were not\\ncommitted can be resent as a new series to a later CF. In the\\nannotations section, add a link to the latest version each time it's\\nposted, along with some indication of how many parts are left[1]. Perhaps\\nif a part is committed and there's no new version submitted soon, also\\nadd an annotation to indicate that.\\n\\n[1] Do not, as I've seen some do in the past, delete the old annotations\\nwhile adding new ones.\\n\\n-- \\n�lvaro Herrera http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 12:48:11 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: CF app and patch series\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 5:48 PM, Alvaro Herrera <alvherre@2ndquadrant.com>\\nwrote:\\n\\n> Craig Ringer wrote:\\n> > Hi all\\n> >\\n> > Now that it's becoming more common to post patch series, not just\\n> > standalone patches, it might be worth looking at how the CF app can\\n> > help manage them.\\n> >\\n> > Any ideas?\\n>\\n> I agree that we don't consider this case at all currently and that it's\\n> causing some pain.\\n>\\n> MIME parsing is mind-boggling. Trying to figure out *one* patch file\\n> from an email is already pretty difficult. Trying to figure out more\\n> than one might be nightmarish. Maybe Magnus will contradict me and say\\n> it's trivial to do -- that'd be great.\\n>\\n\\nNothing is ever trivial :)\\n\\nActually, the archives collect all attachments. And they're available in\\nthe API there. But the commitfest app only keeps the first one.\\n\\nSo would it be trivial to collect more? Not really. Would it be\\nnightmarish? No, not that either.\\n\\nSo if we can figure out how to actually work it into the UI of the CF app,\\nit should certainly be doable to track multiple attachments.\\n\\n\\n\\n> I don't have any great ideas for how to support this; I'd say it would\\n> be something like the CF entry has sub-entries one for each patch in the\\n> series, that can be closed independently. This probably involves\\n> surgery to the CF database and app which I'm not volunteering to write,\\n> however. Django-enabled contributors speak up now ...\\n>\\n\\nYeah, that would require a bit more surgery. Not sure how to represent it\\nthough, if those patches are all typically sent in the same mailthread.\\nWhich I guess they are. Because then that thread would have to be attached\\nto all of those sub-entries, which would kind of defeat the purpose?\\n\\n-- \\n Magnus Hagander\\n Me: http://www.hagander.net/\\n Work: http://www.redpill-linpro.com/\\n\\nOn Thu, Sep 8, 2016 at 5:48 PM, Alvaro Herrera <alvherre@2ndquadrant.com> wrote:Craig Ringer wrote:\\n> Hi all\\n>\\n> Now that it's becoming more common to post patch series, not just\\n> standalone patches, it might be worth looking at how the CF app can\\n> help manage them.\\n>\\n> Any ideas?\\n\\nI agree that we don't consider this case at all currently and that it's\\ncausing some pain.\\n\\nMIME parsing is mind-boggling. Trying to figure out *one* patch file\\nfrom an email is already pretty difficult. Trying to figure out more\\nthan one might be nightmarish. Maybe Magnus will contradict me and say\\nit's trivial to do -- that'd be great.Nothing is ever trivial :)Actually, the archives collect all attachments. And they're available in the API there. But the commitfest app only keeps the first one.So would it be trivial to collect more? Not really. Would it be nightmarish? No, not that either. So if we can figure out how to actually work it into the UI of the CF app, it should certainly be doable to track multiple attachments. \\nI don't have any great ideas for how to support this; I'd say it would\\nbe something like the CF entry has sub-entries one for each patch in the\\nseries, that can be closed independently. This probably involves\\nsurgery to the CF database and app which I'm not volunteering to write,\\nhowever. Django-enabled contributors speak up now ...Yeah, that would require a bit more surgery. Not sure how to represent it though, if those patches are all typically sent in the same mailthread. Which I guess they are. Because then that thread would have to be attached to all of those sub-entries, which would kind of defeat the purpose?-- Magnus Hagander Me: http://www.hagander.net/ Work: http://www.redpill-linpro.com/\",\n \"msg_date\": \"Fri, 9 Sep 2016 12:22:55 +0200\",\n \"msg_from\": \"Magnus Hagander <magnus@hagander.net>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: CF app and patch series\"\n }\n]","isConversational":false}}},{"rowIdx":43091,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hello, hackers!\n\nWe were testing how well some application works with PostgreSQL and \nstumbled upon an autovacuum behavior which I fail to understand.\nApplication in question have a habit to heavily use temporary tables in \nfunny ways.\nFor example it creates A LOT of them.\nWhich is ok.\nFunny part is that it never drops them. So when backend is finally \nterminated, it tries to drop them and fails with error:\n\nFATAL: out of shared memory\nHINT: You might need to increase max_locks_per_transaction\n\nIf I understand that rigth, we are trying to drop all these temp tables \nin one transaction and running out of locks to do so.\nAfter that postgresql.log is flooded at the rate 1k/s with messages like \nthat:\n\nLOG: autovacuum: found orphan temp table \"pg_temp_15\".\"tt38147\" in \ndatabase \"DB_TEST\"\n\nIt produces a noticeable load on the system and it`s getting worst with \nevery terminated backend or restart.\nI did some RTFS and it appears that autovacuum has no intention of \ncleaning that orphan tables unless\nit`s wraparound time:\n\nsrc/backend/postmaster/autovacuum.c\n /* We just ignore it if the owning backend is still active */\n 2037 if (backendID == MyBackendId || \nBackendIdGetProc(backendID) == NULL)\n 2038 {\n 2039 /*\n 2040 * We found an orphan temp table (which was \nprobably left\n 2041 * behind by a crashed backend). If it's so old \nas to need\n 2042 * vacuum for wraparound, forcibly drop it. \nOtherwise just\n 2043 * log a complaint.\n 2044 */\n 2045 if (wraparound)\n 2046 {\n 2047 ObjectAddress object;\n 2048\n 2049 ereport(LOG,\n 2050 (errmsg(\"autovacuum: dropping orphan \ntemp table \\\"%s\\\".\\\"%s\\\" in database \\\"%s\\\"\",\n 2051 get_namespace_name(classForm->relnamespace),\n 2052 NameStr(classForm->relname),\n 2053 get_database_name(MyDatabaseId))));\n 2054 object.classId = RelationRelationId;\n 2055 object.objectId = relid;\n 2056 object.objectSubId = 0;\n 2057 performDeletion(&object, DROP_CASCADE, \nPERFORM_DELETION_INTERNAL);\n 2058 }\n 2059 else\n 2060 {\n 2061 ereport(LOG,\n 2062 (errmsg(\"autovacuum: found orphan \ntemp table \\\"%s\\\".\\\"%s\\\" in database \\\"%s\\\"\",\n 2063 get_namespace_name(classForm->relnamespace),\n 2064 NameStr(classForm->relname),\n 2065 get_database_name(MyDatabaseId))));\n 2066 }\n 2067 }\n 2068 }\n\n\nWhat is more troubling is that pg_statistic is starting to bloat badly.\n\nLOG: automatic vacuum of table \"DB_TEST.pg_catalog.pg_statistic\": index \nscans: 0\n pages: 0 removed, 68225 remain, 0 skipped due to pins\n tuples: 0 removed, 2458382 remain, 2408081 are dead but not yet \nremovable\n buffer usage: 146450 hits, 31 misses, 0 dirtied\n avg read rate: 0.010 MB/s, avg write rate: 0.000 MB/s\n system usage: CPU 3.27s/6.92u sec elapsed 23.87 sec\n\nWhat is the purpose of keeping orphan tables around and not dropping \nthem on the spot?\n\n\n-- \nGrigory Smolkin\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n\n\n\n\n\nHello, hackers!\nWe were testing how well some application works with PostgreSQL\n and stumbled upon an autovacuum behavior which I fail to\n understand.\n Application in question have a habit to heavily use temporary\n tables in funny ways.\n For example it creates A LOT of them.\n Which is ok.\n Funny part is that it never drops them. So when backend is finally\n terminated, it tries to drop them and fails with error:\n\n FATAL: out of shared memory\n HINT: You might need to increase max_locks_per_transaction\n\n If I understand that rigth, we are trying to drop all these temp\n tables in one transaction and running out of locks to do so.\n After that postgresql.log is flooded at the rate 1k/s with\n messages like that:\n\n LOG: autovacuum: found orphan temp table \"pg_temp_15\".\"tt38147\"\n in database \"DB_TEST\"\n\n It produces a noticeable load on the system and it`s getting worst\n with every terminated backend or restart.\n I did some RTFS and it appears that autovacuum has no intention of\n cleaning that orphan tables unless\n it`s wraparound time:\n\n src/backend/postmaster/autovacuum.c\n /* We just ignore it if the owning backend is still\n active */\n 2037 if (backendID == MyBackendId ||\n BackendIdGetProc(backendID) == NULL)\n 2038 {\n 2039 /*\n 2040 * We found an orphan temp table (which was\n probably left\n 2041 * behind by a crashed backend). If it's so\n old as to need\n 2042 * vacuum for wraparound, forcibly drop it. \n Otherwise just\n 2043 * log a complaint.\n 2044 */\n 2045 if (wraparound)\n 2046 {\n 2047 ObjectAddress object;\n 2048 \n 2049 ereport(LOG,\n 2050 (errmsg(\"autovacuum: dropping\n orphan temp table \\\"%s\\\".\\\"%s\\\" in database \\\"%s\\\"\",\n 2051 \n get_namespace_name(classForm->relnamespace),\n 2052 \n NameStr(classForm->relname),\n 2053 \n get_database_name(MyDatabaseId))));\n 2054 object.classId = RelationRelationId;\n 2055 object.objectId = relid;\n 2056 object.objectSubId = 0;\n 2057 performDeletion(&object,\n DROP_CASCADE, PERFORM_DELETION_INTERNAL);\n 2058 }\n 2059 else\n 2060 {\n 2061 ereport(LOG,\n 2062 (errmsg(\"autovacuum: found\n orphan temp table \\\"%s\\\".\\\"%s\\\" in database \\\"%s\\\"\",\n 2063 \n get_namespace_name(classForm->relnamespace),\n 2064 \n NameStr(classForm->relname),\n 2065 \n get_database_name(MyDatabaseId))));\n 2066 }\n 2067 }\n 2068 }\n\n\n What is more troubling is that pg_statistic is starting to bloat\n badly.\n\n LOG: automatic vacuum of table \"DB_TEST.pg_catalog.pg_statistic\":\n index scans: 0\n pages: 0 removed, 68225 remain, 0 skipped due to pins\n tuples: 0 removed, 2458382 remain, 2408081 are dead but\n not yet removable\n buffer usage: 146450 hits, 31 misses, 0 dirtied\n avg read rate: 0.010 MB/s, avg write rate: 0.000 MB/s\n system usage: CPU 3.27s/6.92u sec elapsed 23.87 sec\n\n What is the purpose of keeping orphan tables around and not\n dropping them on the spot?\n\n\n\n-- \nGrigory Smolkin\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company","msg_date":"Mon, 5 Sep 2016 14:54:05 +0300","msg_from":"Grigory Smolkin <g.smolkin@postgrespro.ru>","msg_from_op":true,"msg_subject":"Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On 09/05/2016 01:54 PM, Grigory Smolkin wrote:\n> What is the purpose of keeping orphan tables around and not dropping\n> them on the spot?\n\nYou can read the discussion about it here:\nhttps://www.postgresql.org/message-id/flat/3507.1214581513%40sss.pgh.pa.us\n-- \nVik Fearing +33 6 46 75 15 36\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 15:13:15 +0200","msg_from":"Vik Fearing <vik@2ndquadrant.fr>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"Grigory Smolkin wrote:\n\n> Funny part is that it never drops them. So when backend is finally\n> terminated, it tries to drop them and fails with error:\n> \n> FATAL: out of shared memory\n> HINT: You might need to increase max_locks_per_transaction\n> \n> If I understand that rigth, we are trying to drop all these temp tables in\n> one transaction and running out of locks to do so.\n\nHmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\nIt is certainly pointless to hold onto these locks for temp tables. I\nwonder how ugly would be to fix this problem ...\n\n-- \n�lvaro Herrera http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 10:34:40 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On 09/05/2016 04:34 PM, Alvaro Herrera wrote:\n> Grigory Smolkin wrote:\n>\n>> Funny part is that it never drops them. So when backend is finally\n>> terminated, it tries to drop them and fails with error:\n>>\n>> FATAL: out of shared memory\n>> HINT: You might need to increase max_locks_per_transaction\n>>\n>> If I understand that rigth, we are trying to drop all these temp tables in\n>> one transaction and running out of locks to do so.\n> Hmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\n> It is certainly pointless to hold onto these locks for temp tables. I\n> wonder how ugly would be to fix this problem ...\n>\n\nThank you for your interest in this problem.\nI dont think this is a source of problem. Ugly fix here would only force \nbackend to terminate properly.\nIt will not help at all in cause of server crash or power outage.\nWe need a way to tell autovacuum, that we don`t need orphan temp tables, \nso they can be removed using existing routine.\n\nThe least invasive solution would be to have a guc, something like \n'keep_orphan_temp_tables' with boolean value.\nWhich would determine a autovacuum worker policy toward encountered \norphan temp tables.\n\n-- \nGrigory Smolkin\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n\n\n\n\n\n\nOn 09/05/2016 04:34 PM, Alvaro Herrera\n wrote:\n\n\nGrigory Smolkin wrote:\n\n\n\nFunny part is that it never drops them. So when backend is finally\nterminated, it tries to drop them and fails with error:\n\nFATAL: out of shared memory\nHINT: You might need to increase max_locks_per_transaction\n\nIf I understand that rigth, we are trying to drop all these temp tables in\none transaction and running out of locks to do so.\n\n\n\nHmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\nIt is certainly pointless to hold onto these locks for temp tables. I\nwonder how ugly would be to fix this problem ...\n\n\n\n\n Thank you for your interest in this problem.\n I dont think this is a source of problem. Ugly fix here would only\n force backend to terminate properly.\n It will not help at all in cause of server crash or power outage.\n We need a way to tell autovacuum, that we don`t need orphan temp\n tables, so they can be removed using existing routine.\n\n The least invasive solution would be to have a guc, something like\n 'keep_orphan_temp_tables' with boolean value.\n Which would determine a autovacuum worker policy toward encountered\n orphan temp tables.\n\n-- \nGrigory Smolkin\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company","msg_date":"Mon, 5 Sep 2016 17:05:00 +0300","msg_from":"Grigory Smolkin <g.smolkin@postgrespro.ru>","msg_from_op":true,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"Grigory Smolkin wrote:\n> \n> On 09/05/2016 04:34 PM, Alvaro Herrera wrote:\n> >Grigory Smolkin wrote:\n> >\n> >>Funny part is that it never drops them. So when backend is finally\n> >>terminated, it tries to drop them and fails with error:\n> >>\n> >>FATAL: out of shared memory\n> >>HINT: You might need to increase max_locks_per_transaction\n> >>\n> >>If I understand that rigth, we are trying to drop all these temp tables in\n> >>one transaction and running out of locks to do so.\n> >Hmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\n> >It is certainly pointless to hold onto these locks for temp tables. I\n> >wonder how ugly would be to fix this problem ...\n> >\n> \n> Thank you for your interest in this problem.\n> I dont think this is a source of problem. Ugly fix here would only force\n> backend to terminate properly.\n> It will not help at all in cause of server crash or power outage.\n> We need a way to tell autovacuum, that we don`t need orphan temp tables, so\n> they can be removed using existing routine.\n\nIt is always possible to drop the containing schemas; and as soon as\nsome other backend uses the BackendId 15 (in your example) the tables\nwould be removed anyway. This only becomes a longstanding problem when\nthe crashing backend uses a high-numbered BackendId that's not reused\npromptly enough.\n\n> The least invasive solution would be to have a guc, something like\n> 'keep_orphan_temp_tables' with boolean value.\n> Which would determine a autovacuum worker policy toward encountered orphan\n> temp tables.\n\nThe stated reason for keeping them around is to ensure you have time to\ndo some forensics research in case there was something useful in the\ncrashing backend. My feeling is that if the reason they are kept around\nis not a crash but rather some implementation defect that broke end-time\ncleanup, then they don't have their purported value and I would rather\njust remove them.\n\nI have certainly faced my fair share of customers with dangling temp\ntables, and would like to see this changed in some way or another.\n\n-- \n�lvaro Herrera http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 12:48:32 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Mon, Sep 5, 2016 at 12:48:32PM -0300, Alvaro Herrera wrote:\n> > The least invasive solution would be to have a guc, something like\n> > 'keep_orphan_temp_tables' with boolean value.\n> > Which would determine a autovacuum worker policy toward encountered orphan\n> > temp tables.\n> \n> The stated reason for keeping them around is to ensure you have time to\n> do some forensics research in case there was something useful in the\n> crashing backend. My feeling is that if the reason they are kept around\n> is not a crash but rather some implementation defect that broke end-time\n> cleanup, then they don't have their purported value and I would rather\n> just remove them.\n> \n> I have certainly faced my fair share of customers with dangling temp\n> tables, and would like to see this changed in some way or another.\n\nI don't think we look at those temp tables frequently enough to justify\nkeeping them around for all users.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n+ As you are, so once was I. As I am, so you will be. +\n+ Ancient Roman grave inscription +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 13:14:54 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On 9/5/16 12:14 PM, Bruce Momjian wrote:\n>> > I have certainly faced my fair share of customers with dangling temp\n>> > tables, and would like to see this changed in some way or another.\n> I don't think we look at those temp tables frequently enough to justify\n> keeping them around for all users.\n\nPlus, if we cared about forensics, we'd prevent re-use of the orphaned \nschemas by new backends. That doesn't seem like a good idea for normal \nuse, but if we had a preserve_orphaned_temp_objects GUC someone could \nadd that behavior.\n\nIsn't there some other GUC aimed at preserving data for forensics \n(besides zero_damaged_pages)? Maybe we could just broaden that to \ninclude orphaned temp objects.\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 11:21:39 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Mon, Sep 5, 2016 at 1:14 PM, Bruce Momjian <bruce@momjian.us> wrote:\n> On Mon, Sep 5, 2016 at 12:48:32PM -0300, Alvaro Herrera wrote:\n>> > The least invasive solution would be to have a guc, something like\n>> > 'keep_orphan_temp_tables' with boolean value.\n>> > Which would determine a autovacuum worker policy toward encountered orphan\n>> > temp tables.\n>>\n>> The stated reason for keeping them around is to ensure you have time to\n>> do some forensics research in case there was something useful in the\n>> crashing backend. My feeling is that if the reason they are kept around\n>> is not a crash but rather some implementation defect that broke end-time\n>> cleanup, then they don't have their purported value and I would rather\n>> just remove them.\n>>\n>> I have certainly faced my fair share of customers with dangling temp\n>> tables, and would like to see this changed in some way or another.\n>\n> I don't think we look at those temp tables frequently enough to justify\n> keeping them around for all users.\n\n+1. I think it would be much better to nuke them more aggressively.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 11:38:10 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Mon, 5 Sep 2016 14:54:05 +0300\nGrigory Smolkin <g.smolkin@postgrespro.ru> wrote:\n\n> Hello, hackers!\n> \n> We were testing how well some application works with PostgreSQL and \n> stumbled upon an autovacuum behavior which I fail to understand.\n> Application in question have a habit to heavily use temporary tables\n> in funny ways.\n> For example it creates A LOT of them.\n> Which is ok.\n> Funny part is that it never drops them. So when backend is finally \n> terminated, it tries to drop them and fails with error:\n> \n> FATAL: out of shared memory\n> HINT: You might need to increase max_locks_per_transaction\n> \n> If I understand that rigth, we are trying to drop all these temp\n> tables in one transaction and running out of locks to do so.\n> After that postgresql.log is flooded at the rate 1k/s with messages\n> like that:\n> \n> LOG: autovacuum: found orphan temp table \"pg_temp_15\".\"tt38147\" in \n> database \"DB_TEST\"\n> \n> It produces a noticeable load on the system and it`s getting worst\n> with every terminated backend or restart.\n> I did some RTFS and it appears that autovacuum has no intention of \n> cleaning that orphan tables unless\n> it`s wraparound time:\n> \n> src/backend/postmaster/autovacuum.c\n> /* We just ignore it if the owning backend is still\n> active */ 2037 if (backendID == MyBackendId || \n> BackendIdGetProc(backendID) == NULL)\n> 2038 {\n> 2039 /*\n> 2040 * We found an orphan temp table (which was \n> probably left\n> 2041 * behind by a crashed backend). If it's so\n> old as to need\n> 2042 * vacuum for wraparound, forcibly drop it. \n> Otherwise just\n> 2043 * log a complaint.\n> 2044 */\n> 2045 if (wraparound)\n> 2046 {\n> 2047 ObjectAddress object;\n> 2048\n> 2049 ereport(LOG,\n> 2050 (errmsg(\"autovacuum: dropping\n> orphan temp table \\\"%s\\\".\\\"%s\\\" in database \\\"%s\\\"\",\n> 2051 get_namespace_name(classForm->relnamespace),\n> 2052 NameStr(classForm->relname),\n> 2053 get_database_name(MyDatabaseId))));\n> 2054 object.classId = RelationRelationId;\n> 2055 object.objectId = relid;\n> 2056 object.objectSubId = 0;\n> 2057 performDeletion(&object, DROP_CASCADE, \n> PERFORM_DELETION_INTERNAL);\n> 2058 }\n> 2059 else\n> 2060 {\n> 2061 ereport(LOG,\n> 2062 (errmsg(\"autovacuum: found orphan \n> temp table \\\"%s\\\".\\\"%s\\\" in database \\\"%s\\\"\",\n> 2063 get_namespace_name(classForm->relnamespace),\n> 2064 NameStr(classForm->relname),\n> 2065 get_database_name(MyDatabaseId))));\n> 2066 }\n> 2067 }\n> 2068 }\n> \n> \n> What is more troubling is that pg_statistic is starting to bloat\n> badly.\n> \n> LOG: automatic vacuum of table \"DB_TEST.pg_catalog.pg_statistic\":\n> index scans: 0\n> pages: 0 removed, 68225 remain, 0 skipped due to pins\n> tuples: 0 removed, 2458382 remain, 2408081 are dead but not\n> yet removable\n> buffer usage: 146450 hits, 31 misses, 0 dirtied\n> avg read rate: 0.010 MB/s, avg write rate: 0.000 MB/s\n> system usage: CPU 3.27s/6.92u sec elapsed 23.87 sec\n> \n> What is the purpose of keeping orphan tables around and not dropping \n> them on the spot?\n> \n> \n\nHey Hackers,\n\nI tried to fix the problem with a new backend not being\nable to reuse a temporary namespace when it contains\nthousands of temporary tables. I disabled locking of objects\nduring namespace clearing process. See the patch attached.\nPlease tell me if there are any reasons why this is wrong.\n\nI also added a GUC variable and changed the condition in\nautovacuum to let it nuke orphan tables on its way.\nSee another patch attached.\n\nRegards,\nConstantin Pan\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 20 Oct 2016 15:30:24 +0300","msg_from":"\"Constantin S. Pan\" <kvapen@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Thu, Sep 8, 2016 at 12:38 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n> On Mon, Sep 5, 2016 at 1:14 PM, Bruce Momjian <bruce@momjian.us> wrote:\n>> I don't think we look at those temp tables frequently enough to justify\n>> keeping them around for all users.\n>\n> +1. I think it would be much better to nuke them more aggressively.\n\n+1 from here as well. Making the deletion of orphaned temp tables even\nin the non-wraparound autovacuum case mandatory looks to be the better\nmove to me. I can see that it could be important to be able to look at\nsome of temp tables' data after a crash, but the argument looks weak\ncompared to the potential bloat of catalog tables because of those\ndangling temp relations. And I'd suspect that there are far more users\nwho would like to see this removal more aggressive than users caring\nabout having a look at those orphaned tables after a crash.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 21 Oct 2016 14:16:36 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Thu, Oct 20, 2016 at 9:30 PM, Constantin S. Pan <kvapen@gmail.com> wrote:\n> I tried to fix the problem with a new backend not being\n> able to reuse a temporary namespace when it contains\n> thousands of temporary tables. I disabled locking of objects\n> during namespace clearing process. See the patch attached.\n> Please tell me if there are any reasons why this is wrong.\n\nThat's invasive. I am wondering if a cleaner approach here would be a\nflag in deleteOneObject() that performs the lock cleanup, as that's\nwhat you are trying to solve here.\n\n> I also added a GUC variable and changed the condition in\n> autovacuum to let it nuke orphan tables on its way.\n> See another patch attached.\n\nIt seems to me that you'd even want to make the drop of orphaned\ntables mandatory once it is detected even it is not a wraparound\nautovacuum. Dangling temp tables have higher chances to hit users than\ndiagnostic of orphaned temp tables after a crash. (A background worker\ncould be used for existing versions to clean up that more aggressively\nactually)\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 21 Oct 2016 14:29:24 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Fri, Oct 21, 2016 at 2:29 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> On Thu, Oct 20, 2016 at 9:30 PM, Constantin S. Pan <kvapen@gmail.com> wrote:\n>> I tried to fix the problem with a new backend not being\n>> able to reuse a temporary namespace when it contains\n>> thousands of temporary tables. I disabled locking of objects\n>> during namespace clearing process. See the patch attached.\n>> Please tell me if there are any reasons why this is wrong.\n>\n> That's invasive. I am wondering if a cleaner approach here would be a\n> flag in deleteOneObject() that performs the lock cleanup, as that's\n> what you are trying to solve here.\n>\n>> I also added a GUC variable and changed the condition in\n>> autovacuum to let it nuke orphan tables on its way.\n>> See another patch attached.\n>\n> It seems to me that you'd even want to make the drop of orphaned\n> tables mandatory once it is detected even it is not a wraparound\n> autovacuum. Dangling temp tables have higher chances to hit users than\n> diagnostic of orphaned temp tables after a crash. (A background worker\n> could be used for existing versions to clean up that more aggressively\n> actually)\n\nYou should as well add your patch to the next commit fest, so as to be\nsure that it will attract more reviews and more attention:\nhttps://commitfest.postgresql.org/11/\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 21 Oct 2016 14:31:11 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Fri, 21 Oct 2016 14:29:24 +0900\nMichael Paquier <michael.paquier@gmail.com> wrote:\n\n> That's invasive. I am wondering if a cleaner approach here would be a\n> flag in deleteOneObject() that performs the lock cleanup, as that's\n> what you are trying to solve here.\n\nThe problem occurs earlier, at the findDependentObjects step. All the\nobjects inside the namespace are being locked before any of them gets\ndeleted, which leads to the \"too many locks\" condition.\n\nCheers,\nConstantin Pan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 21 Oct 2016 13:08:58 +0300","msg_from":"\"Constantin S. Pan\" <kvapen@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"Michael Paquier <michael.paquier@gmail.com> writes:\n> On Thu, Oct 20, 2016 at 9:30 PM, Constantin S. Pan <kvapen@gmail.com> wrote:\n>> I tried to fix the problem with a new backend not being\n>> able to reuse a temporary namespace when it contains\n>> thousands of temporary tables. I disabled locking of objects\n>> during namespace clearing process. See the patch attached.\n>> Please tell me if there are any reasons why this is wrong.\n\n> That's invasive.\n\nInvasive or otherwise, it's *completely unacceptable*. Without a lock\nyou have no way to be sure that nothing else is touching the table.\n\nA less broken approach might be to split the cleanup into multiple shorter\ntransactions, that is, after every N objects stop and commit what you've\ndone so far. This shouldn't be that hard to do during backend exit, as\nI'm pretty sure we're starting a new transaction just for this purpose\nanyway. I don't know if it'd be possible to do it during the automatic\ncleanup when glomming onto a pre-existing temp namespace, because we're\nalready within a user-started transaction at that point. But if we solve\nthe problem where it's being created, maybe that's enough for now.\n\n>> I also added a GUC variable and changed the condition in\n>> autovacuum to let it nuke orphan tables on its way.\n>> See another patch attached.\n\n> It seems to me that you'd even want to make the drop of orphaned\n> tables mandatory once it is detected even it is not a wraparound\n> autovacuum.\n\nIf we are willing to do that then we don't really have to solve the\nproblem on the backend side. One could expect that autovacuum would\nclean things up within a few minutes after a backend failure. We'd\nhave to be really darn sure that that \"orphaned backend\" test can\nnever have any false positives, though. I'm not sure that it was\never designed to be race-condition-proof.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 21 Oct 2016 09:47:18 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On 10/21/16 8:47 AM, Tom Lane wrote:\n>> It seems to me that you'd even want to make the drop of orphaned\n>> > tables mandatory once it is detected even it is not a wraparound\n>> > autovacuum.\n> If we are willing to do that then we don't really have to solve the\n> problem on the backend side. One could expect that autovacuum would\n> clean things up within a few minutes after a backend failure.\n\nUnless all the autovac workers are busy working on huge tables... maybe \na delay of several hours/days is OK in this case, but it's not wise to \nassume autovac will always get to something within minutes.\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 21 Oct 2016 10:15:21 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Sat, Oct 22, 2016 at 12:15 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\n> On 10/21/16 8:47 AM, Tom Lane wrote:\n>>>\n>>> It seems to me that you'd even want to make the drop of orphaned\n>>> > tables mandatory once it is detected even it is not a wraparound\n>>> > autovacuum.\n>>\n>> If we are willing to do that then we don't really have to solve the\n>> problem on the backend side. One could expect that autovacuum would\n>> clean things up within a few minutes after a backend failure.\n>\n> Unless all the autovac workers are busy working on huge tables... maybe a\n> delay of several hours/days is OK in this case, but it's not wise to assume\n> autovac will always get to something within minutes.\n\nI am really thinking that we should just do that and call it a day\nthen, but document the fact that if one wants to look at the content\nof orphaned tables after a crash he had better turn autovacuum to off\nfor the time of the analysis.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 22 Oct 2016 07:41:42 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"Michael Paquier <michael.paquier@gmail.com> writes:\n> On Sat, Oct 22, 2016 at 12:15 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\n>> On 10/21/16 8:47 AM, Tom Lane wrote:\n>>> If we are willing to do that then we don't really have to solve the\n>>> problem on the backend side. One could expect that autovacuum would\n>>> clean things up within a few minutes after a backend failure.\n\n> I am really thinking that we should just do that and call it a day\n> then, but document the fact that if one wants to look at the content\n> of orphaned tables after a crash he had better turn autovacuum to off\n> for the time of the analysis.\n\nYeah, agreed. This also points up the value of Robert's suggestion\nof a \"really off\" setting.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 21 Oct 2016 20:45:05 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Sat, Oct 22, 2016 at 9:45 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> Michael Paquier <michael.paquier@gmail.com> writes:\n>> On Sat, Oct 22, 2016 at 12:15 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\n>>> On 10/21/16 8:47 AM, Tom Lane wrote:\n>>>> If we are willing to do that then we don't really have to solve the\n>>>> problem on the backend side. One could expect that autovacuum would\n>>>> clean things up within a few minutes after a backend failure.\n>\n>> I am really thinking that we should just do that and call it a day\n>> then, but document the fact that if one wants to look at the content\n>> of orphaned tables after a crash he had better turn autovacuum to off\n>> for the time of the analysis.\n>\n> Yeah, agreed. This also points up the value of Robert's suggestion\n> of a \"really off\" setting.\n\nOkay, so I suggest something like the attached as HEAD-only change\nbecause that's a behavior modification.\n-- \nMichael\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Sat, 22 Oct 2016 15:42:46 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"Hi Dilip,\n\nThis is a gentle reminder.\n\nyou assigned as reviewer to the current patch in the 11-2016 commitfest.\nBut you haven't shared your review yet. Can you please try to share your\nviews\nabout the patch. This will help us in smoother operation of commitfest.\n\nMichael had sent an updated patch based on some discussion.\n\nPlease Ignore if you already shared your review.\n\n\nRegards,\nHari Babu\nFujitsu Australia\n\nHi Dilip,This is a gentle reminder.you assigned as reviewer to the current patch in the 11-2016 commitfest.But you haven't shared your review yet. Can you please try to share your viewsabout the patch. This will help us in smoother operation of commitfest.Michael had sent an updated patch based on some discussion.Please Ignore if you already shared your review. Regards,Hari BabuFujitsu Australia","msg_date":"Thu, 17 Nov 2016 12:24:04 +1100","msg_from":"Haribabu Kommi <kommi.haribabu@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Wed, Nov 16, 2016 at 5:24 PM, Haribabu Kommi\n<kommi.haribabu@gmail.com> wrote:\n> This is a gentle reminder.\n>\n> you assigned as reviewer to the current patch in the 11-2016 commitfest.\n> But you haven't shared your review yet. Can you please try to share your\n> views\n> about the patch. This will help us in smoother operation of commitfest.\n\nThanks for the reminder.\n\n> Michael had sent an updated patch based on some discussion.\n> Please Ignore if you already shared your review.\n\nHm. Thinking about that again, having a GUC to control if orphaned\ntemp tables in autovacuum is an overkill (who is going to go into this\nlevel of tuning!?) and that we had better do something more aggressive\nas there have been cases of users complaining about dangling temp\ntables. I suspect the use case where people would like to have a look\nat orphaned temp tables after a backend crash is not that wide, at\nleast a method would be to disable autovacuum after a crash if such a\nmonitoring is necessary. Tom has already stated upthread that the\npatch to remove wildly locks is not acceptable, and he's clearly\nright.\n\nSo the best move would be really to make the removal of orphaned temp\ntables more aggressive, and not bother about having a GUC to control\nthat. The patch sent in\nhttps://www.postgresql.org/message-id/CAB7nPqSRYwaz1i12mPkH06_roO3ifgCgR88_aeX1OEg2r4OaNw@mail.gmail.com\ndoes so, so I am marking the CF entry as ready for committer for this\npatch to attract some committer's attention on the matter.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 16 Nov 2016 20:14:01 -0800","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Wed, Nov 16, 2016 at 11:14 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> Hm. Thinking about that again, having a GUC to control if orphaned\n> temp tables in autovacuum is an overkill (who is going to go into this\n> level of tuning!?) and that we had better do something more aggressive\n> as there have been cases of users complaining about dangling temp\n> tables. I suspect the use case where people would like to have a look\n> at orphaned temp tables after a backend crash is not that wide, at\n> least a method would be to disable autovacuum after a crash if such a\n> monitoring is necessary. Tom has already stated upthread that the\n> patch to remove wildly locks is not acceptable, and he's clearly\n> right.\n>\n> So the best move would be really to make the removal of orphaned temp\n> tables more aggressive, and not bother about having a GUC to control\n> that. The patch sent in\n> https://www.postgresql.org/message-id/CAB7nPqSRYwaz1i12mPkH06_roO3ifgCgR88_aeX1OEg2r4OaNw@mail.gmail.com\n> does so, so I am marking the CF entry as ready for committer for this\n> patch to attract some committer's attention on the matter.\n\nThe whole point of the review process is to get an opinion from\nsomebody other than the original author on the patch in question. If\nyou write a patch and then mark your own patch Ready for Committer,\nyou're defeating the entire purpose of this process. I think that's\nwhat you did here, I think you have done it on other occasions in the\nnot-too-distant patch, and I wish you'd stop. I understand perfectly\nwell that there are times when a committer needs to involve themselves\ndirectly in a patch even when nobody else has reviewed it, because\nthat just has to happen, and I try to keep an eye out for such\nscenarios, but it's frustrating to clear time to work on the RfC\nbacklog and then discover patches that have just been marked that way\nwithout discussion or agreement.\n\nNow, on the substance of this issue, I think your proposed change to\nclean up temporary tables immediately rather than waiting until they\nbecome old enough to threaten wraparound is a clear improvement, and\nIMHO we should definitely do it. However, I think your proposed\ndocumentation changes are pretty well inadequate. If somebody\nactually does want to get at the temporary tables of a crashed\nbackend, they will need to do a lot more than what you mention in that\nupdate. Even if they set autovacuum=off, they will be vulnerable to\nhaving those tables removed by another backend with the same backend\nID that reinitializes the temporary schema. And even if that doesn't\nhappen, they won't be able to select from those tables because they'll\nget an error about reading temporary tables of another session. To\nfix that they'd have to move the temporary tables into some other\nschema AND change the filenames on disk. And then on top of that, by\nthe time anybody even found this in the documentation, it would be far\ntoo late to shut off autovacuum in the first place because it runs\nevery minute (unless you have raised autovacuum_naptime, which you\nshouldn't). I think we just shouldn't document this. The proposed\nbehavior change is basically switching from an extremely conservative\nbehavior with surprising consequences to what people would expect\nanyway, and anyone who needs to dig information out of another\nsession's temporary tables is going to need to know a lot more about\nthe server internals than we normally explain in the documentation.\n\n--\nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 17 Nov 2016 10:37:14 -0500","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Thu, Nov 17, 2016 at 7:37 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n> The whole point of the review process is to get an opinion from\n> somebody other than the original author on the patch in question. If\n> you write a patch and then mark your own patch Ready for Committer,\n> you're defeating the entire purpose of this process. I think that's\n> what you did here, I think you have done it on other occasions in the\n> not-too-distant patch, and I wish you'd stop. I understand perfectly\n> well that there are times when a committer needs to involve themselves\n> directly in a patch even when nobody else has reviewed it, because\n> that just has to happen, and I try to keep an eye out for such\n> scenarios, but it's frustrating to clear time to work on the RfC\n> backlog and then discover patches that have just been marked that way\n> without discussion or agreement.\n\nOK, sorry about that, I switched it back to \"Needs Review\" FWIW. For\nmy defense, after a review of the first set of patches proposed, I\nsuggested one way to go which is the second patch I sent. Bruce and\nyourself mentioned that nuking them more aggressively would be better\nto have. Tom mentioned that doing so and having a GUC would be worth\nit. In short this sounded like an agreement to me, which is why I\nproposed a new patch to make the discussion move on. And the patch is\nnot that complicated. When looking at it I asked myself about\npotential timing issues regarding fact of doing this cleanup more\naggressively but discarded them at the end.\n\n> Now, on the substance of this issue, I think your proposed change to\n> clean up temporary tables immediately rather than waiting until they\n> become old enough to threaten wraparound is a clear improvement, and\n> IMHO we should definitely do it. However, I think your proposed\n> documentation changes are pretty well inadequate. If somebody\n> actually does want to get at the temporary tables of a crashed\n> backend, they will need to do a lot more than what you mention in that\n> update. Even if they set autovacuum=off, they will be vulnerable to\n> having those tables removed by another backend with the same backend\n> ID that reinitializes the temporary schema. And even if that doesn't\n> happen, they won't be able to select from those tables because they'll\n> get an error about reading temporary tables of another session. To\n> fix that they'd have to move the temporary tables into some other\n> schema AND change the filenames on disk. And then on top of that, by\n> the time anybody even found this in the documentation, it would be far\n> too late to shut off autovacuum in the first place because it runs\n> every minute (unless you have raised autovacuum_naptime, which you\n> shouldn't). I think we just shouldn't document this. The proposed\n> behavior change is basically switching from an extremely conservative\n> behavior with surprising consequences to what people would expect\n> anyway, and anyone who needs to dig information out of another\n> session's temporary tables is going to need to know a lot more about\n> the server internals than we normally explain in the documentation.\n\nOkay, let's remove the documentation then. What do you think about the\nupdated version attached?\n(Even this patch enters into \"Needs Review\" state).\n-- \nMichael\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 17 Nov 2016 10:41:02 -0800","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Thu, Nov 17, 2016 at 1:41 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> Okay, let's remove the documentation then. What do you think about the\n> updated version attached?\n> (Even this patch enters into \"Needs Review\" state).\n\nLGTM. I'll commit it if there are not objections.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 17 Nov 2016 14:16:31 -0500","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Thu, Nov 17, 2016 at 11:16 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n> On Thu, Nov 17, 2016 at 1:41 PM, Michael Paquier\n> <michael.paquier@gmail.com> wrote:\n>> Okay, let's remove the documentation then. What do you think about the\n>> updated version attached?\n>> (Even this patch enters into \"Needs Review\" state).\n>\n> LGTM. I'll commit it if there are not objections.\n\nThank you.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 17 Nov 2016 13:25:06 -0800","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Thu, Nov 17, 2016 at 6:54 AM, Haribabu Kommi\n<kommi.haribabu@gmail.com> wrote:\n> you assigned as reviewer to the current patch in the 11-2016 commitfest.\n> But you haven't shared your review yet. Can you please try to share your\n> views\n> about the patch. This will help us in smoother operation of commitfest.\n>\n> Michael had sent an updated patch based on some discussion.\n>\n> Please Ignore if you already shared your review.\n\n\nHi Hari,\n\nSo far I haven't spent time on this, I am planning to spend in next week.\nBut it seems that lot of review has happened and patch is already in\ngood shapes. So I think other reviewers can take decision.\n\n-- \nRegards,\nDilip Kumar\nEnterpriseDB: http://www.enterprisedb.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 18 Nov 2016 20:00:40 +0530","msg_from":"Dilip Kumar <dilipbalaut@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Thu, Nov 17, 2016 at 4:25 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> On Thu, Nov 17, 2016 at 11:16 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> On Thu, Nov 17, 2016 at 1:41 PM, Michael Paquier\n>> <michael.paquier@gmail.com> wrote:\n>>> Okay, let's remove the documentation then. What do you think about the\n>>> updated version attached?\n>>> (Even this patch enters into \"Needs Review\" state).\n>>\n>> LGTM. I'll commit it if there are not objections.\n>\n> Thank you.\n\nOn further reflection, I'm not sure this fixes the original complaint.\nIn fact, it might even make it worse. The performDeletion() call here\nis going to run inside of a loop that's scanning through pg_class, so\nall in a single transaction. So we'll actually try to drop ALL\norphaned tables for ALL backends that failed to clean up in a single\ntransaction, as opposed to the current state of affairs where we will\ndrop all orphaned tables for ONE backend in a single transaction. If\nanything, that could require MORE locks. And if it starts failing,\nthen all autovacuum activity in that database will cease. Oops.\n\nSo now I think that we probably need to make this logic a bit smarter.\nAdd all of the OIDs that need to be dropped to a list. Then have a\nloop prior to the main loop (where it says \"Perform operations on\ncollected tables.\") which iterates over that list and drops those\ntables one by one, starting a transaction every (say) 100 tables or\nafter an error. For bonus points, if a transaction fails, put all of\nthe OIDs except the one that provoked the failure back into the list\nof OIDs to be dropped, so that we still make a progress even if some\nDROPs are failing for some reason.\n\nThat might sound adding unnecessary work just for the sake of\nparanoia, but I don't think it is. Failures here won't be common, but\nsince they are entirely automated there will be no human intelligence\navailable to straighten things out. Barring considerable caution,\nwe'll just enter a flaming death spiral.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 18 Nov 2016 16:11:57 -0500","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Fri, Nov 18, 2016 at 1:11 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> So now I think that we probably need to make this logic a bit smarter.\n> Add all of the OIDs that need to be dropped to a list. Then have a\n> loop prior to the main loop (where it says \"Perform operations on\n> collected tables.\") which iterates over that list and drops those\n> tables one by one, starting a transaction every (say) 100 tables or\n> after an error. For bonus points, if a transaction fails, put all of\n> the OIDs except the one that provoked the failure back into the list\n> of OIDs to be dropped, so that we still make a progress even if some\n> DROPs are failing for some reason.\n\nOkay.\n\n> That might sound adding unnecessary work just for the sake of\n> paranoia, but I don't think it is. Failures here won't be common, but\n> since they are entirely automated there will be no human intelligence\n> available to straighten things out. Barring considerable caution,\n> we'll just enter a flaming death spiral.\n\nThinking more paranoid, an extra way to enter in this flaming death\nspiral is to not limit the maximum number of failures authorized when\ndropping a set of orphaned tables and transactions fail multiple\ntimes. This is basically not important as the relation on which the\ndrop failed gets dropped from the list but failing on each one of them\nis a good way to slow down autovacuum, so putting a limit of say 10\ntransactions failing is I think really important.\n\nI have played with what you suggested, and finished with the patch\nattached. I have run some tests using this function to create some\ntemp tables with several backends to be sure that multiple backend IDs\nare used:\n\nCREATE FUNCTION create_temp_tables(i int) RETURNS void\nAS $$\nBEGIN\nFOR i IN 1..i LOOP\n EXECUTE 'CREATE TEMP TABLE aa' || i || ' (a int);';\nEND LOOP;\nEND\n$$ LANGUAGE plpgsql;\n\nThen I killed the instance. At restart I could see a bunch of temp\ntables in pg_class, and I let autovacuum do the cleanup after restart.\nI have tested as well the error code path in the PG_TRY() block by\nenforcing manually a elog(ERROR) to be sure that the maximum number of\nfailures is correctly handled, better safe than sorry.\n-- \nMichael\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 18 Nov 2016 21:16:00 -0800","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Sat, Nov 19, 2016 at 2:16 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> On Fri, Nov 18, 2016 at 1:11 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> That might sound adding unnecessary work just for the sake of\n>> paranoia, but I don't think it is. Failures here won't be common, but\n>> since they are entirely automated there will be no human intelligence\n>> available to straighten things out. Barring considerable caution,\n>> we'll just enter a flaming death spiral.\n>\n> Thinking more paranoid, an extra way to enter in this flaming death\n> spiral is to not limit the maximum number of failures authorized when\n> dropping a set of orphaned tables and transactions fail multiple\n> times. This is basically not important as the relation on which the\n> drop failed gets dropped from the list but failing on each one of them\n> is a good way to slow down autovacuum, so putting a limit of say 10\n> transactions failing is I think really important.\n\nBy the way, when hacking this patch I asked myself three questions:\n1) How many objects should be dropped per transaction? 50 sounds like\na fine number to me so the patch I sent is doing so. This should\ndefinitely not be more than the default for max_locks_per_transaction,\naka 64. Another thing to consider would be to use a number depending\non max_locks_per_transaction, like half of it.\n2) How many transaction failures should autovacuum forgive? The patch\nuses 10. Honestly I put that number out of thin air.\n3) Should the drop of orphaned tables be done for a wraparound\nautovacuum? Obviously, the answer is no. It is vital not to consume\ntransaction XIDs in this case. The patch I sent is dropping the\nobjects even for a wraparound job, that's easily switchable.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 21 Nov 2016 12:42:07 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Sun, Nov 20, 2016 at 10:42 PM, Michael Paquier\n<michael.paquier@gmail.com> wrote:\n> On Sat, Nov 19, 2016 at 2:16 PM, Michael Paquier\n> <michael.paquier@gmail.com> wrote:\n>> On Fri, Nov 18, 2016 at 1:11 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>> That might sound adding unnecessary work just for the sake of\n>>> paranoia, but I don't think it is. Failures here won't be common, but\n>>> since they are entirely automated there will be no human intelligence\n>>> available to straighten things out. Barring considerable caution,\n>>> we'll just enter a flaming death spiral.\n>>\n>> Thinking more paranoid, an extra way to enter in this flaming death\n>> spiral is to not limit the maximum number of failures authorized when\n>> dropping a set of orphaned tables and transactions fail multiple\n>> times. This is basically not important as the relation on which the\n>> drop failed gets dropped from the list but failing on each one of them\n>> is a good way to slow down autovacuum, so putting a limit of say 10\n>> transactions failing is I think really important.\n>\n> By the way, when hacking this patch I asked myself three questions:\n> 1) How many objects should be dropped per transaction? 50 sounds like\n> a fine number to me so the patch I sent is doing so. This should\n> definitely not be more than the default for max_locks_per_transaction,\n> aka 64. Another thing to consider would be to use a number depending\n> on max_locks_per_transaction, like half of it.\n> 2) How many transaction failures should autovacuum forgive? The patch\n> uses 10. Honestly I put that number out of thin air.\n> 3) Should the drop of orphaned tables be done for a wraparound\n> autovacuum? Obviously, the answer is no. It is vital not to consume\n> transaction XIDs in this case. The patch I sent is dropping the\n> objects even for a wraparound job, that's easily switchable.\n\nI don't think that you should skip it in the wraparound case, because\nit might be one of the temp tables that is threatening wraparound.\n\nI've committed the patch after doing some work on the comments.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 21 Nov 2016 13:06:08 -0500","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"},{"msg_contents":"On Tue, Nov 22, 2016 at 3:06 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n> I don't think that you should skip it in the wraparound case, because\n> it might be one of the temp tables that is threatening wraparound.\n>\n> I've committed the patch after doing some work on the comments.\n\nOK, thanks.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 22 Nov 2016 06:15:29 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Fun fact about autovacuum and orphan temp tables"}],"string":"[\n {\n \"msg_contents\": \"Hello, hackers!\\n\\nWe were testing how well some application works with PostgreSQL and \\nstumbled upon an autovacuum behavior which I fail to understand.\\nApplication in question have a habit to heavily use temporary tables in \\nfunny ways.\\nFor example it creates A LOT of them.\\nWhich is ok.\\nFunny part is that it never drops them. So when backend is finally \\nterminated, it tries to drop them and fails with error:\\n\\nFATAL: out of shared memory\\nHINT: You might need to increase max_locks_per_transaction\\n\\nIf I understand that rigth, we are trying to drop all these temp tables \\nin one transaction and running out of locks to do so.\\nAfter that postgresql.log is flooded at the rate 1k/s with messages like \\nthat:\\n\\nLOG: autovacuum: found orphan temp table \\\"pg_temp_15\\\".\\\"tt38147\\\" in \\ndatabase \\\"DB_TEST\\\"\\n\\nIt produces a noticeable load on the system and it`s getting worst with \\nevery terminated backend or restart.\\nI did some RTFS and it appears that autovacuum has no intention of \\ncleaning that orphan tables unless\\nit`s wraparound time:\\n\\nsrc/backend/postmaster/autovacuum.c\\n /* We just ignore it if the owning backend is still active */\\n 2037 if (backendID == MyBackendId || \\nBackendIdGetProc(backendID) == NULL)\\n 2038 {\\n 2039 /*\\n 2040 * We found an orphan temp table (which was \\nprobably left\\n 2041 * behind by a crashed backend). If it's so old \\nas to need\\n 2042 * vacuum for wraparound, forcibly drop it. \\nOtherwise just\\n 2043 * log a complaint.\\n 2044 */\\n 2045 if (wraparound)\\n 2046 {\\n 2047 ObjectAddress object;\\n 2048\\n 2049 ereport(LOG,\\n 2050 (errmsg(\\\"autovacuum: dropping orphan \\ntemp table \\\\\\\"%s\\\\\\\".\\\\\\\"%s\\\\\\\" in database \\\\\\\"%s\\\\\\\"\\\",\\n 2051 get_namespace_name(classForm->relnamespace),\\n 2052 NameStr(classForm->relname),\\n 2053 get_database_name(MyDatabaseId))));\\n 2054 object.classId = RelationRelationId;\\n 2055 object.objectId = relid;\\n 2056 object.objectSubId = 0;\\n 2057 performDeletion(&object, DROP_CASCADE, \\nPERFORM_DELETION_INTERNAL);\\n 2058 }\\n 2059 else\\n 2060 {\\n 2061 ereport(LOG,\\n 2062 (errmsg(\\\"autovacuum: found orphan \\ntemp table \\\\\\\"%s\\\\\\\".\\\\\\\"%s\\\\\\\" in database \\\\\\\"%s\\\\\\\"\\\",\\n 2063 get_namespace_name(classForm->relnamespace),\\n 2064 NameStr(classForm->relname),\\n 2065 get_database_name(MyDatabaseId))));\\n 2066 }\\n 2067 }\\n 2068 }\\n\\n\\nWhat is more troubling is that pg_statistic is starting to bloat badly.\\n\\nLOG: automatic vacuum of table \\\"DB_TEST.pg_catalog.pg_statistic\\\": index \\nscans: 0\\n pages: 0 removed, 68225 remain, 0 skipped due to pins\\n tuples: 0 removed, 2458382 remain, 2408081 are dead but not yet \\nremovable\\n buffer usage: 146450 hits, 31 misses, 0 dirtied\\n avg read rate: 0.010 MB/s, avg write rate: 0.000 MB/s\\n system usage: CPU 3.27s/6.92u sec elapsed 23.87 sec\\n\\nWhat is the purpose of keeping orphan tables around and not dropping \\nthem on the spot?\\n\\n\\n-- \\nGrigory Smolkin\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n\\n\\n\\n\\n\\nHello, hackers!\\nWe were testing how well some application works with PostgreSQL\\n and stumbled upon an autovacuum behavior which I fail to\\n understand.\\n Application in question have a habit to heavily use temporary\\n tables in funny ways.\\n For example it creates A LOT of them.\\n Which is ok.\\n Funny part is that it never drops them. So when backend is finally\\n terminated, it tries to drop them and fails with error:\\n\\n FATAL: out of shared memory\\n HINT: You might need to increase max_locks_per_transaction\\n\\n If I understand that rigth, we are trying to drop all these temp\\n tables in one transaction and running out of locks to do so.\\n After that postgresql.log is flooded at the rate 1k/s with\\n messages like that:\\n\\n LOG: autovacuum: found orphan temp table \\\"pg_temp_15\\\".\\\"tt38147\\\"\\n in database \\\"DB_TEST\\\"\\n\\n It produces a noticeable load on the system and it`s getting worst\\n with every terminated backend or restart.\\n I did some RTFS and it appears that autovacuum has no intention of\\n cleaning that orphan tables unless\\n it`s wraparound time:\\n\\n src/backend/postmaster/autovacuum.c\\n /* We just ignore it if the owning backend is still\\n active */\\n 2037 if (backendID == MyBackendId ||\\n BackendIdGetProc(backendID) == NULL)\\n 2038 {\\n 2039 /*\\n 2040 * We found an orphan temp table (which was\\n probably left\\n 2041 * behind by a crashed backend). If it's so\\n old as to need\\n 2042 * vacuum for wraparound, forcibly drop it. \\n Otherwise just\\n 2043 * log a complaint.\\n 2044 */\\n 2045 if (wraparound)\\n 2046 {\\n 2047 ObjectAddress object;\\n 2048 \\n 2049 ereport(LOG,\\n 2050 (errmsg(\\\"autovacuum: dropping\\n orphan temp table \\\\\\\"%s\\\\\\\".\\\\\\\"%s\\\\\\\" in database \\\\\\\"%s\\\\\\\"\\\",\\n 2051 \\n get_namespace_name(classForm->relnamespace),\\n 2052 \\n NameStr(classForm->relname),\\n 2053 \\n get_database_name(MyDatabaseId))));\\n 2054 object.classId = RelationRelationId;\\n 2055 object.objectId = relid;\\n 2056 object.objectSubId = 0;\\n 2057 performDeletion(&object,\\n DROP_CASCADE, PERFORM_DELETION_INTERNAL);\\n 2058 }\\n 2059 else\\n 2060 {\\n 2061 ereport(LOG,\\n 2062 (errmsg(\\\"autovacuum: found\\n orphan temp table \\\\\\\"%s\\\\\\\".\\\\\\\"%s\\\\\\\" in database \\\\\\\"%s\\\\\\\"\\\",\\n 2063 \\n get_namespace_name(classForm->relnamespace),\\n 2064 \\n NameStr(classForm->relname),\\n 2065 \\n get_database_name(MyDatabaseId))));\\n 2066 }\\n 2067 }\\n 2068 }\\n\\n\\n What is more troubling is that pg_statistic is starting to bloat\\n badly.\\n\\n LOG: automatic vacuum of table \\\"DB_TEST.pg_catalog.pg_statistic\\\":\\n index scans: 0\\n pages: 0 removed, 68225 remain, 0 skipped due to pins\\n tuples: 0 removed, 2458382 remain, 2408081 are dead but\\n not yet removable\\n buffer usage: 146450 hits, 31 misses, 0 dirtied\\n avg read rate: 0.010 MB/s, avg write rate: 0.000 MB/s\\n system usage: CPU 3.27s/6.92u sec elapsed 23.87 sec\\n\\n What is the purpose of keeping orphan tables around and not\\n dropping them on the spot?\\n\\n\\n\\n-- \\nGrigory Smolkin\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\",\n \"msg_date\": \"Mon, 5 Sep 2016 14:54:05 +0300\",\n \"msg_from\": \"Grigory Smolkin <g.smolkin@postgrespro.ru>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On 09/05/2016 01:54 PM, Grigory Smolkin wrote:\\n> What is the purpose of keeping orphan tables around and not dropping\\n> them on the spot?\\n\\nYou can read the discussion about it here:\\nhttps://www.postgresql.org/message-id/flat/3507.1214581513%40sss.pgh.pa.us\\n-- \\nVik Fearing +33 6 46 75 15 36\\nhttp://2ndQuadrant.fr PostgreSQL : Expertise, Formation et Support\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 15:13:15 +0200\",\n \"msg_from\": \"Vik Fearing <vik@2ndquadrant.fr>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"Grigory Smolkin wrote:\\n\\n> Funny part is that it never drops them. So when backend is finally\\n> terminated, it tries to drop them and fails with error:\\n> \\n> FATAL: out of shared memory\\n> HINT: You might need to increase max_locks_per_transaction\\n> \\n> If I understand that rigth, we are trying to drop all these temp tables in\\n> one transaction and running out of locks to do so.\\n\\nHmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\\nIt is certainly pointless to hold onto these locks for temp tables. I\\nwonder how ugly would be to fix this problem ...\\n\\n-- \\n�lvaro Herrera http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 10:34:40 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On 09/05/2016 04:34 PM, Alvaro Herrera wrote:\\n> Grigory Smolkin wrote:\\n>\\n>> Funny part is that it never drops them. So when backend is finally\\n>> terminated, it tries to drop them and fails with error:\\n>>\\n>> FATAL: out of shared memory\\n>> HINT: You might need to increase max_locks_per_transaction\\n>>\\n>> If I understand that rigth, we are trying to drop all these temp tables in\\n>> one transaction and running out of locks to do so.\\n> Hmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\\n> It is certainly pointless to hold onto these locks for temp tables. I\\n> wonder how ugly would be to fix this problem ...\\n>\\n\\nThank you for your interest in this problem.\\nI dont think this is a source of problem. Ugly fix here would only force \\nbackend to terminate properly.\\nIt will not help at all in cause of server crash or power outage.\\nWe need a way to tell autovacuum, that we don`t need orphan temp tables, \\nso they can be removed using existing routine.\\n\\nThe least invasive solution would be to have a guc, something like \\n'keep_orphan_temp_tables' with boolean value.\\nWhich would determine a autovacuum worker policy toward encountered \\norphan temp tables.\\n\\n-- \\nGrigory Smolkin\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n\\n\\n\\n\\n\\n\\nOn 09/05/2016 04:34 PM, Alvaro Herrera\\n wrote:\\n\\n\\nGrigory Smolkin wrote:\\n\\n\\n\\nFunny part is that it never drops them. So when backend is finally\\nterminated, it tries to drop them and fails with error:\\n\\nFATAL: out of shared memory\\nHINT: You might need to increase max_locks_per_transaction\\n\\nIf I understand that rigth, we are trying to drop all these temp tables in\\none transaction and running out of locks to do so.\\n\\n\\n\\nHmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\\nIt is certainly pointless to hold onto these locks for temp tables. I\\nwonder how ugly would be to fix this problem ...\\n\\n\\n\\n\\n Thank you for your interest in this problem.\\n I dont think this is a source of problem. Ugly fix here would only\\n force backend to terminate properly.\\n It will not help at all in cause of server crash or power outage.\\n We need a way to tell autovacuum, that we don`t need orphan temp\\n tables, so they can be removed using existing routine.\\n\\n The least invasive solution would be to have a guc, something like\\n 'keep_orphan_temp_tables' with boolean value.\\n Which would determine a autovacuum worker policy toward encountered\\n orphan temp tables.\\n\\n-- \\nGrigory Smolkin\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\",\n \"msg_date\": \"Mon, 5 Sep 2016 17:05:00 +0300\",\n \"msg_from\": \"Grigory Smolkin <g.smolkin@postgrespro.ru>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"Grigory Smolkin wrote:\\n> \\n> On 09/05/2016 04:34 PM, Alvaro Herrera wrote:\\n> >Grigory Smolkin wrote:\\n> >\\n> >>Funny part is that it never drops them. So when backend is finally\\n> >>terminated, it tries to drop them and fails with error:\\n> >>\\n> >>FATAL: out of shared memory\\n> >>HINT: You might need to increase max_locks_per_transaction\\n> >>\\n> >>If I understand that rigth, we are trying to drop all these temp tables in\\n> >>one transaction and running out of locks to do so.\\n> >Hmm, yeah, I suppose it does that, and it does seem pretty inconvenient.\\n> >It is certainly pointless to hold onto these locks for temp tables. I\\n> >wonder how ugly would be to fix this problem ...\\n> >\\n> \\n> Thank you for your interest in this problem.\\n> I dont think this is a source of problem. Ugly fix here would only force\\n> backend to terminate properly.\\n> It will not help at all in cause of server crash or power outage.\\n> We need a way to tell autovacuum, that we don`t need orphan temp tables, so\\n> they can be removed using existing routine.\\n\\nIt is always possible to drop the containing schemas; and as soon as\\nsome other backend uses the BackendId 15 (in your example) the tables\\nwould be removed anyway. This only becomes a longstanding problem when\\nthe crashing backend uses a high-numbered BackendId that's not reused\\npromptly enough.\\n\\n> The least invasive solution would be to have a guc, something like\\n> 'keep_orphan_temp_tables' with boolean value.\\n> Which would determine a autovacuum worker policy toward encountered orphan\\n> temp tables.\\n\\nThe stated reason for keeping them around is to ensure you have time to\\ndo some forensics research in case there was something useful in the\\ncrashing backend. My feeling is that if the reason they are kept around\\nis not a crash but rather some implementation defect that broke end-time\\ncleanup, then they don't have their purported value and I would rather\\njust remove them.\\n\\nI have certainly faced my fair share of customers with dangling temp\\ntables, and would like to see this changed in some way or another.\\n\\n-- \\n�lvaro Herrera http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 12:48:32 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 5, 2016 at 12:48:32PM -0300, Alvaro Herrera wrote:\\n> > The least invasive solution would be to have a guc, something like\\n> > 'keep_orphan_temp_tables' with boolean value.\\n> > Which would determine a autovacuum worker policy toward encountered orphan\\n> > temp tables.\\n> \\n> The stated reason for keeping them around is to ensure you have time to\\n> do some forensics research in case there was something useful in the\\n> crashing backend. My feeling is that if the reason they are kept around\\n> is not a crash but rather some implementation defect that broke end-time\\n> cleanup, then they don't have their purported value and I would rather\\n> just remove them.\\n> \\n> I have certainly faced my fair share of customers with dangling temp\\n> tables, and would like to see this changed in some way or another.\\n\\nI don't think we look at those temp tables frequently enough to justify\\nkeeping them around for all users.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 13:14:54 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On 9/5/16 12:14 PM, Bruce Momjian wrote:\\n>> > I have certainly faced my fair share of customers with dangling temp\\n>> > tables, and would like to see this changed in some way or another.\\n> I don't think we look at those temp tables frequently enough to justify\\n> keeping them around for all users.\\n\\nPlus, if we cared about forensics, we'd prevent re-use of the orphaned \\nschemas by new backends. That doesn't seem like a good idea for normal \\nuse, but if we had a preserve_orphaned_temp_objects GUC someone could \\nadd that behavior.\\n\\nIsn't there some other GUC aimed at preserving data for forensics \\n(besides zero_damaged_pages)? Maybe we could just broaden that to \\ninclude orphaned temp objects.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 11:21:39 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 5, 2016 at 1:14 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Mon, Sep 5, 2016 at 12:48:32PM -0300, Alvaro Herrera wrote:\\n>> > The least invasive solution would be to have a guc, something like\\n>> > 'keep_orphan_temp_tables' with boolean value.\\n>> > Which would determine a autovacuum worker policy toward encountered orphan\\n>> > temp tables.\\n>>\\n>> The stated reason for keeping them around is to ensure you have time to\\n>> do some forensics research in case there was something useful in the\\n>> crashing backend. My feeling is that if the reason they are kept around\\n>> is not a crash but rather some implementation defect that broke end-time\\n>> cleanup, then they don't have their purported value and I would rather\\n>> just remove them.\\n>>\\n>> I have certainly faced my fair share of customers with dangling temp\\n>> tables, and would like to see this changed in some way or another.\\n>\\n> I don't think we look at those temp tables frequently enough to justify\\n> keeping them around for all users.\\n\\n+1. I think it would be much better to nuke them more aggressively.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 11:38:10 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Mon, 5 Sep 2016 14:54:05 +0300\\nGrigory Smolkin <g.smolkin@postgrespro.ru> wrote:\\n\\n> Hello, hackers!\\n> \\n> We were testing how well some application works with PostgreSQL and \\n> stumbled upon an autovacuum behavior which I fail to understand.\\n> Application in question have a habit to heavily use temporary tables\\n> in funny ways.\\n> For example it creates A LOT of them.\\n> Which is ok.\\n> Funny part is that it never drops them. So when backend is finally \\n> terminated, it tries to drop them and fails with error:\\n> \\n> FATAL: out of shared memory\\n> HINT: You might need to increase max_locks_per_transaction\\n> \\n> If I understand that rigth, we are trying to drop all these temp\\n> tables in one transaction and running out of locks to do so.\\n> After that postgresql.log is flooded at the rate 1k/s with messages\\n> like that:\\n> \\n> LOG: autovacuum: found orphan temp table \\\"pg_temp_15\\\".\\\"tt38147\\\" in \\n> database \\\"DB_TEST\\\"\\n> \\n> It produces a noticeable load on the system and it`s getting worst\\n> with every terminated backend or restart.\\n> I did some RTFS and it appears that autovacuum has no intention of \\n> cleaning that orphan tables unless\\n> it`s wraparound time:\\n> \\n> src/backend/postmaster/autovacuum.c\\n> /* We just ignore it if the owning backend is still\\n> active */ 2037 if (backendID == MyBackendId || \\n> BackendIdGetProc(backendID) == NULL)\\n> 2038 {\\n> 2039 /*\\n> 2040 * We found an orphan temp table (which was \\n> probably left\\n> 2041 * behind by a crashed backend). If it's so\\n> old as to need\\n> 2042 * vacuum for wraparound, forcibly drop it. \\n> Otherwise just\\n> 2043 * log a complaint.\\n> 2044 */\\n> 2045 if (wraparound)\\n> 2046 {\\n> 2047 ObjectAddress object;\\n> 2048\\n> 2049 ereport(LOG,\\n> 2050 (errmsg(\\\"autovacuum: dropping\\n> orphan temp table \\\\\\\"%s\\\\\\\".\\\\\\\"%s\\\\\\\" in database \\\\\\\"%s\\\\\\\"\\\",\\n> 2051 get_namespace_name(classForm->relnamespace),\\n> 2052 NameStr(classForm->relname),\\n> 2053 get_database_name(MyDatabaseId))));\\n> 2054 object.classId = RelationRelationId;\\n> 2055 object.objectId = relid;\\n> 2056 object.objectSubId = 0;\\n> 2057 performDeletion(&object, DROP_CASCADE, \\n> PERFORM_DELETION_INTERNAL);\\n> 2058 }\\n> 2059 else\\n> 2060 {\\n> 2061 ereport(LOG,\\n> 2062 (errmsg(\\\"autovacuum: found orphan \\n> temp table \\\\\\\"%s\\\\\\\".\\\\\\\"%s\\\\\\\" in database \\\\\\\"%s\\\\\\\"\\\",\\n> 2063 get_namespace_name(classForm->relnamespace),\\n> 2064 NameStr(classForm->relname),\\n> 2065 get_database_name(MyDatabaseId))));\\n> 2066 }\\n> 2067 }\\n> 2068 }\\n> \\n> \\n> What is more troubling is that pg_statistic is starting to bloat\\n> badly.\\n> \\n> LOG: automatic vacuum of table \\\"DB_TEST.pg_catalog.pg_statistic\\\":\\n> index scans: 0\\n> pages: 0 removed, 68225 remain, 0 skipped due to pins\\n> tuples: 0 removed, 2458382 remain, 2408081 are dead but not\\n> yet removable\\n> buffer usage: 146450 hits, 31 misses, 0 dirtied\\n> avg read rate: 0.010 MB/s, avg write rate: 0.000 MB/s\\n> system usage: CPU 3.27s/6.92u sec elapsed 23.87 sec\\n> \\n> What is the purpose of keeping orphan tables around and not dropping \\n> them on the spot?\\n> \\n> \\n\\nHey Hackers,\\n\\nI tried to fix the problem with a new backend not being\\nable to reuse a temporary namespace when it contains\\nthousands of temporary tables. I disabled locking of objects\\nduring namespace clearing process. See the patch attached.\\nPlease tell me if there are any reasons why this is wrong.\\n\\nI also added a GUC variable and changed the condition in\\nautovacuum to let it nuke orphan tables on its way.\\nSee another patch attached.\\n\\nRegards,\\nConstantin Pan\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 20 Oct 2016 15:30:24 +0300\",\n \"msg_from\": \"\\\"Constantin S. Pan\\\" <kvapen@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 8, 2016 at 12:38 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Mon, Sep 5, 2016 at 1:14 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>> I don't think we look at those temp tables frequently enough to justify\\n>> keeping them around for all users.\\n>\\n> +1. I think it would be much better to nuke them more aggressively.\\n\\n+1 from here as well. Making the deletion of orphaned temp tables even\\nin the non-wraparound autovacuum case mandatory looks to be the better\\nmove to me. I can see that it could be important to be able to look at\\nsome of temp tables' data after a crash, but the argument looks weak\\ncompared to the potential bloat of catalog tables because of those\\ndangling temp relations. And I'd suspect that there are far more users\\nwho would like to see this removal more aggressive than users caring\\nabout having a look at those orphaned tables after a crash.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 21 Oct 2016 14:16:36 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Thu, Oct 20, 2016 at 9:30 PM, Constantin S. Pan <kvapen@gmail.com> wrote:\\n> I tried to fix the problem with a new backend not being\\n> able to reuse a temporary namespace when it contains\\n> thousands of temporary tables. I disabled locking of objects\\n> during namespace clearing process. See the patch attached.\\n> Please tell me if there are any reasons why this is wrong.\\n\\nThat's invasive. I am wondering if a cleaner approach here would be a\\nflag in deleteOneObject() that performs the lock cleanup, as that's\\nwhat you are trying to solve here.\\n\\n> I also added a GUC variable and changed the condition in\\n> autovacuum to let it nuke orphan tables on its way.\\n> See another patch attached.\\n\\nIt seems to me that you'd even want to make the drop of orphaned\\ntables mandatory once it is detected even it is not a wraparound\\nautovacuum. Dangling temp tables have higher chances to hit users than\\ndiagnostic of orphaned temp tables after a crash. (A background worker\\ncould be used for existing versions to clean up that more aggressively\\nactually)\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 21 Oct 2016 14:29:24 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Fri, Oct 21, 2016 at 2:29 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> On Thu, Oct 20, 2016 at 9:30 PM, Constantin S. Pan <kvapen@gmail.com> wrote:\\n>> I tried to fix the problem with a new backend not being\\n>> able to reuse a temporary namespace when it contains\\n>> thousands of temporary tables. I disabled locking of objects\\n>> during namespace clearing process. See the patch attached.\\n>> Please tell me if there are any reasons why this is wrong.\\n>\\n> That's invasive. I am wondering if a cleaner approach here would be a\\n> flag in deleteOneObject() that performs the lock cleanup, as that's\\n> what you are trying to solve here.\\n>\\n>> I also added a GUC variable and changed the condition in\\n>> autovacuum to let it nuke orphan tables on its way.\\n>> See another patch attached.\\n>\\n> It seems to me that you'd even want to make the drop of orphaned\\n> tables mandatory once it is detected even it is not a wraparound\\n> autovacuum. Dangling temp tables have higher chances to hit users than\\n> diagnostic of orphaned temp tables after a crash. (A background worker\\n> could be used for existing versions to clean up that more aggressively\\n> actually)\\n\\nYou should as well add your patch to the next commit fest, so as to be\\nsure that it will attract more reviews and more attention:\\nhttps://commitfest.postgresql.org/11/\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 21 Oct 2016 14:31:11 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Fri, 21 Oct 2016 14:29:24 +0900\\nMichael Paquier <michael.paquier@gmail.com> wrote:\\n\\n> That's invasive. I am wondering if a cleaner approach here would be a\\n> flag in deleteOneObject() that performs the lock cleanup, as that's\\n> what you are trying to solve here.\\n\\nThe problem occurs earlier, at the findDependentObjects step. All the\\nobjects inside the namespace are being locked before any of them gets\\ndeleted, which leads to the \\\"too many locks\\\" condition.\\n\\nCheers,\\nConstantin Pan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 21 Oct 2016 13:08:58 +0300\",\n \"msg_from\": \"\\\"Constantin S. Pan\\\" <kvapen@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael.paquier@gmail.com> writes:\\n> On Thu, Oct 20, 2016 at 9:30 PM, Constantin S. Pan <kvapen@gmail.com> wrote:\\n>> I tried to fix the problem with a new backend not being\\n>> able to reuse a temporary namespace when it contains\\n>> thousands of temporary tables. I disabled locking of objects\\n>> during namespace clearing process. See the patch attached.\\n>> Please tell me if there are any reasons why this is wrong.\\n\\n> That's invasive.\\n\\nInvasive or otherwise, it's *completely unacceptable*. Without a lock\\nyou have no way to be sure that nothing else is touching the table.\\n\\nA less broken approach might be to split the cleanup into multiple shorter\\ntransactions, that is, after every N objects stop and commit what you've\\ndone so far. This shouldn't be that hard to do during backend exit, as\\nI'm pretty sure we're starting a new transaction just for this purpose\\nanyway. I don't know if it'd be possible to do it during the automatic\\ncleanup when glomming onto a pre-existing temp namespace, because we're\\nalready within a user-started transaction at that point. But if we solve\\nthe problem where it's being created, maybe that's enough for now.\\n\\n>> I also added a GUC variable and changed the condition in\\n>> autovacuum to let it nuke orphan tables on its way.\\n>> See another patch attached.\\n\\n> It seems to me that you'd even want to make the drop of orphaned\\n> tables mandatory once it is detected even it is not a wraparound\\n> autovacuum.\\n\\nIf we are willing to do that then we don't really have to solve the\\nproblem on the backend side. One could expect that autovacuum would\\nclean things up within a few minutes after a backend failure. We'd\\nhave to be really darn sure that that \\\"orphaned backend\\\" test can\\nnever have any false positives, though. I'm not sure that it was\\never designed to be race-condition-proof.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 21 Oct 2016 09:47:18 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On 10/21/16 8:47 AM, Tom Lane wrote:\\n>> It seems to me that you'd even want to make the drop of orphaned\\n>> > tables mandatory once it is detected even it is not a wraparound\\n>> > autovacuum.\\n> If we are willing to do that then we don't really have to solve the\\n> problem on the backend side. One could expect that autovacuum would\\n> clean things up within a few minutes after a backend failure.\\n\\nUnless all the autovac workers are busy working on huge tables... maybe \\na delay of several hours/days is OK in this case, but it's not wise to \\nassume autovac will always get to something within minutes.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 21 Oct 2016 10:15:21 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Sat, Oct 22, 2016 at 12:15 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n> On 10/21/16 8:47 AM, Tom Lane wrote:\\n>>>\\n>>> It seems to me that you'd even want to make the drop of orphaned\\n>>> > tables mandatory once it is detected even it is not a wraparound\\n>>> > autovacuum.\\n>>\\n>> If we are willing to do that then we don't really have to solve the\\n>> problem on the backend side. One could expect that autovacuum would\\n>> clean things up within a few minutes after a backend failure.\\n>\\n> Unless all the autovac workers are busy working on huge tables... maybe a\\n> delay of several hours/days is OK in this case, but it's not wise to assume\\n> autovac will always get to something within minutes.\\n\\nI am really thinking that we should just do that and call it a day\\nthen, but document the fact that if one wants to look at the content\\nof orphaned tables after a crash he had better turn autovacuum to off\\nfor the time of the analysis.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 22 Oct 2016 07:41:42 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"Michael Paquier <michael.paquier@gmail.com> writes:\\n> On Sat, Oct 22, 2016 at 12:15 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n>> On 10/21/16 8:47 AM, Tom Lane wrote:\\n>>> If we are willing to do that then we don't really have to solve the\\n>>> problem on the backend side. One could expect that autovacuum would\\n>>> clean things up within a few minutes after a backend failure.\\n\\n> I am really thinking that we should just do that and call it a day\\n> then, but document the fact that if one wants to look at the content\\n> of orphaned tables after a crash he had better turn autovacuum to off\\n> for the time of the analysis.\\n\\nYeah, agreed. This also points up the value of Robert's suggestion\\nof a \\\"really off\\\" setting.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 21 Oct 2016 20:45:05 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Sat, Oct 22, 2016 at 9:45 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> Michael Paquier <michael.paquier@gmail.com> writes:\\n>> On Sat, Oct 22, 2016 at 12:15 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n>>> On 10/21/16 8:47 AM, Tom Lane wrote:\\n>>>> If we are willing to do that then we don't really have to solve the\\n>>>> problem on the backend side. One could expect that autovacuum would\\n>>>> clean things up within a few minutes after a backend failure.\\n>\\n>> I am really thinking that we should just do that and call it a day\\n>> then, but document the fact that if one wants to look at the content\\n>> of orphaned tables after a crash he had better turn autovacuum to off\\n>> for the time of the analysis.\\n>\\n> Yeah, agreed. This also points up the value of Robert's suggestion\\n> of a \\\"really off\\\" setting.\\n\\nOkay, so I suggest something like the attached as HEAD-only change\\nbecause that's a behavior modification.\\n-- \\nMichael\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sat, 22 Oct 2016 15:42:46 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"Hi Dilip,\\n\\nThis is a gentle reminder.\\n\\nyou assigned as reviewer to the current patch in the 11-2016 commitfest.\\nBut you haven't shared your review yet. Can you please try to share your\\nviews\\nabout the patch. This will help us in smoother operation of commitfest.\\n\\nMichael had sent an updated patch based on some discussion.\\n\\nPlease Ignore if you already shared your review.\\n\\n\\nRegards,\\nHari Babu\\nFujitsu Australia\\n\\nHi Dilip,This is a gentle reminder.you assigned as reviewer to the current patch in the 11-2016 commitfest.But you haven't shared your review yet. Can you please try to share your viewsabout the patch. This will help us in smoother operation of commitfest.Michael had sent an updated patch based on some discussion.Please Ignore if you already shared your review. Regards,Hari BabuFujitsu Australia\",\n \"msg_date\": \"Thu, 17 Nov 2016 12:24:04 +1100\",\n \"msg_from\": \"Haribabu Kommi <kommi.haribabu@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Wed, Nov 16, 2016 at 5:24 PM, Haribabu Kommi\\n<kommi.haribabu@gmail.com> wrote:\\n> This is a gentle reminder.\\n>\\n> you assigned as reviewer to the current patch in the 11-2016 commitfest.\\n> But you haven't shared your review yet. Can you please try to share your\\n> views\\n> about the patch. This will help us in smoother operation of commitfest.\\n\\nThanks for the reminder.\\n\\n> Michael had sent an updated patch based on some discussion.\\n> Please Ignore if you already shared your review.\\n\\nHm. Thinking about that again, having a GUC to control if orphaned\\ntemp tables in autovacuum is an overkill (who is going to go into this\\nlevel of tuning!?) and that we had better do something more aggressive\\nas there have been cases of users complaining about dangling temp\\ntables. I suspect the use case where people would like to have a look\\nat orphaned temp tables after a backend crash is not that wide, at\\nleast a method would be to disable autovacuum after a crash if such a\\nmonitoring is necessary. Tom has already stated upthread that the\\npatch to remove wildly locks is not acceptable, and he's clearly\\nright.\\n\\nSo the best move would be really to make the removal of orphaned temp\\ntables more aggressive, and not bother about having a GUC to control\\nthat. The patch sent in\\nhttps://www.postgresql.org/message-id/CAB7nPqSRYwaz1i12mPkH06_roO3ifgCgR88_aeX1OEg2r4OaNw@mail.gmail.com\\ndoes so, so I am marking the CF entry as ready for committer for this\\npatch to attract some committer's attention on the matter.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 16 Nov 2016 20:14:01 -0800\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Wed, Nov 16, 2016 at 11:14 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> Hm. Thinking about that again, having a GUC to control if orphaned\\n> temp tables in autovacuum is an overkill (who is going to go into this\\n> level of tuning!?) and that we had better do something more aggressive\\n> as there have been cases of users complaining about dangling temp\\n> tables. I suspect the use case where people would like to have a look\\n> at orphaned temp tables after a backend crash is not that wide, at\\n> least a method would be to disable autovacuum after a crash if such a\\n> monitoring is necessary. Tom has already stated upthread that the\\n> patch to remove wildly locks is not acceptable, and he's clearly\\n> right.\\n>\\n> So the best move would be really to make the removal of orphaned temp\\n> tables more aggressive, and not bother about having a GUC to control\\n> that. The patch sent in\\n> https://www.postgresql.org/message-id/CAB7nPqSRYwaz1i12mPkH06_roO3ifgCgR88_aeX1OEg2r4OaNw@mail.gmail.com\\n> does so, so I am marking the CF entry as ready for committer for this\\n> patch to attract some committer's attention on the matter.\\n\\nThe whole point of the review process is to get an opinion from\\nsomebody other than the original author on the patch in question. If\\nyou write a patch and then mark your own patch Ready for Committer,\\nyou're defeating the entire purpose of this process. I think that's\\nwhat you did here, I think you have done it on other occasions in the\\nnot-too-distant patch, and I wish you'd stop. I understand perfectly\\nwell that there are times when a committer needs to involve themselves\\ndirectly in a patch even when nobody else has reviewed it, because\\nthat just has to happen, and I try to keep an eye out for such\\nscenarios, but it's frustrating to clear time to work on the RfC\\nbacklog and then discover patches that have just been marked that way\\nwithout discussion or agreement.\\n\\nNow, on the substance of this issue, I think your proposed change to\\nclean up temporary tables immediately rather than waiting until they\\nbecome old enough to threaten wraparound is a clear improvement, and\\nIMHO we should definitely do it. However, I think your proposed\\ndocumentation changes are pretty well inadequate. If somebody\\nactually does want to get at the temporary tables of a crashed\\nbackend, they will need to do a lot more than what you mention in that\\nupdate. Even if they set autovacuum=off, they will be vulnerable to\\nhaving those tables removed by another backend with the same backend\\nID that reinitializes the temporary schema. And even if that doesn't\\nhappen, they won't be able to select from those tables because they'll\\nget an error about reading temporary tables of another session. To\\nfix that they'd have to move the temporary tables into some other\\nschema AND change the filenames on disk. And then on top of that, by\\nthe time anybody even found this in the documentation, it would be far\\ntoo late to shut off autovacuum in the first place because it runs\\nevery minute (unless you have raised autovacuum_naptime, which you\\nshouldn't). I think we just shouldn't document this. The proposed\\nbehavior change is basically switching from an extremely conservative\\nbehavior with surprising consequences to what people would expect\\nanyway, and anyone who needs to dig information out of another\\nsession's temporary tables is going to need to know a lot more about\\nthe server internals than we normally explain in the documentation.\\n\\n--\\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Nov 2016 10:37:14 -0500\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 7:37 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> The whole point of the review process is to get an opinion from\\n> somebody other than the original author on the patch in question. If\\n> you write a patch and then mark your own patch Ready for Committer,\\n> you're defeating the entire purpose of this process. I think that's\\n> what you did here, I think you have done it on other occasions in the\\n> not-too-distant patch, and I wish you'd stop. I understand perfectly\\n> well that there are times when a committer needs to involve themselves\\n> directly in a patch even when nobody else has reviewed it, because\\n> that just has to happen, and I try to keep an eye out for such\\n> scenarios, but it's frustrating to clear time to work on the RfC\\n> backlog and then discover patches that have just been marked that way\\n> without discussion or agreement.\\n\\nOK, sorry about that, I switched it back to \\\"Needs Review\\\" FWIW. For\\nmy defense, after a review of the first set of patches proposed, I\\nsuggested one way to go which is the second patch I sent. Bruce and\\nyourself mentioned that nuking them more aggressively would be better\\nto have. Tom mentioned that doing so and having a GUC would be worth\\nit. In short this sounded like an agreement to me, which is why I\\nproposed a new patch to make the discussion move on. And the patch is\\nnot that complicated. When looking at it I asked myself about\\npotential timing issues regarding fact of doing this cleanup more\\naggressively but discarded them at the end.\\n\\n> Now, on the substance of this issue, I think your proposed change to\\n> clean up temporary tables immediately rather than waiting until they\\n> become old enough to threaten wraparound is a clear improvement, and\\n> IMHO we should definitely do it. However, I think your proposed\\n> documentation changes are pretty well inadequate. If somebody\\n> actually does want to get at the temporary tables of a crashed\\n> backend, they will need to do a lot more than what you mention in that\\n> update. Even if they set autovacuum=off, they will be vulnerable to\\n> having those tables removed by another backend with the same backend\\n> ID that reinitializes the temporary schema. And even if that doesn't\\n> happen, they won't be able to select from those tables because they'll\\n> get an error about reading temporary tables of another session. To\\n> fix that they'd have to move the temporary tables into some other\\n> schema AND change the filenames on disk. And then on top of that, by\\n> the time anybody even found this in the documentation, it would be far\\n> too late to shut off autovacuum in the first place because it runs\\n> every minute (unless you have raised autovacuum_naptime, which you\\n> shouldn't). I think we just shouldn't document this. The proposed\\n> behavior change is basically switching from an extremely conservative\\n> behavior with surprising consequences to what people would expect\\n> anyway, and anyone who needs to dig information out of another\\n> session's temporary tables is going to need to know a lot more about\\n> the server internals than we normally explain in the documentation.\\n\\nOkay, let's remove the documentation then. What do you think about the\\nupdated version attached?\\n(Even this patch enters into \\\"Needs Review\\\" state).\\n-- \\nMichael\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 17 Nov 2016 10:41:02 -0800\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 1:41 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> Okay, let's remove the documentation then. What do you think about the\\n> updated version attached?\\n> (Even this patch enters into \\\"Needs Review\\\" state).\\n\\nLGTM. I'll commit it if there are not objections.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Nov 2016 14:16:31 -0500\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 11:16 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Thu, Nov 17, 2016 at 1:41 PM, Michael Paquier\\n> <michael.paquier@gmail.com> wrote:\\n>> Okay, let's remove the documentation then. What do you think about the\\n>> updated version attached?\\n>> (Even this patch enters into \\\"Needs Review\\\" state).\\n>\\n> LGTM. I'll commit it if there are not objections.\\n\\nThank you.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Nov 2016 13:25:06 -0800\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 6:54 AM, Haribabu Kommi\\n<kommi.haribabu@gmail.com> wrote:\\n> you assigned as reviewer to the current patch in the 11-2016 commitfest.\\n> But you haven't shared your review yet. Can you please try to share your\\n> views\\n> about the patch. This will help us in smoother operation of commitfest.\\n>\\n> Michael had sent an updated patch based on some discussion.\\n>\\n> Please Ignore if you already shared your review.\\n\\n\\nHi Hari,\\n\\nSo far I haven't spent time on this, I am planning to spend in next week.\\nBut it seems that lot of review has happened and patch is already in\\ngood shapes. So I think other reviewers can take decision.\\n\\n-- \\nRegards,\\nDilip Kumar\\nEnterpriseDB: http://www.enterprisedb.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 18 Nov 2016 20:00:40 +0530\",\n \"msg_from\": \"Dilip Kumar <dilipbalaut@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Thu, Nov 17, 2016 at 4:25 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> On Thu, Nov 17, 2016 at 11:16 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> On Thu, Nov 17, 2016 at 1:41 PM, Michael Paquier\\n>> <michael.paquier@gmail.com> wrote:\\n>>> Okay, let's remove the documentation then. What do you think about the\\n>>> updated version attached?\\n>>> (Even this patch enters into \\\"Needs Review\\\" state).\\n>>\\n>> LGTM. I'll commit it if there are not objections.\\n>\\n> Thank you.\\n\\nOn further reflection, I'm not sure this fixes the original complaint.\\nIn fact, it might even make it worse. The performDeletion() call here\\nis going to run inside of a loop that's scanning through pg_class, so\\nall in a single transaction. So we'll actually try to drop ALL\\norphaned tables for ALL backends that failed to clean up in a single\\ntransaction, as opposed to the current state of affairs where we will\\ndrop all orphaned tables for ONE backend in a single transaction. If\\nanything, that could require MORE locks. And if it starts failing,\\nthen all autovacuum activity in that database will cease. Oops.\\n\\nSo now I think that we probably need to make this logic a bit smarter.\\nAdd all of the OIDs that need to be dropped to a list. Then have a\\nloop prior to the main loop (where it says \\\"Perform operations on\\ncollected tables.\\\") which iterates over that list and drops those\\ntables one by one, starting a transaction every (say) 100 tables or\\nafter an error. For bonus points, if a transaction fails, put all of\\nthe OIDs except the one that provoked the failure back into the list\\nof OIDs to be dropped, so that we still make a progress even if some\\nDROPs are failing for some reason.\\n\\nThat might sound adding unnecessary work just for the sake of\\nparanoia, but I don't think it is. Failures here won't be common, but\\nsince they are entirely automated there will be no human intelligence\\navailable to straighten things out. Barring considerable caution,\\nwe'll just enter a flaming death spiral.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 18 Nov 2016 16:11:57 -0500\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Fri, Nov 18, 2016 at 1:11 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> So now I think that we probably need to make this logic a bit smarter.\\n> Add all of the OIDs that need to be dropped to a list. Then have a\\n> loop prior to the main loop (where it says \\\"Perform operations on\\n> collected tables.\\\") which iterates over that list and drops those\\n> tables one by one, starting a transaction every (say) 100 tables or\\n> after an error. For bonus points, if a transaction fails, put all of\\n> the OIDs except the one that provoked the failure back into the list\\n> of OIDs to be dropped, so that we still make a progress even if some\\n> DROPs are failing for some reason.\\n\\nOkay.\\n\\n> That might sound adding unnecessary work just for the sake of\\n> paranoia, but I don't think it is. Failures here won't be common, but\\n> since they are entirely automated there will be no human intelligence\\n> available to straighten things out. Barring considerable caution,\\n> we'll just enter a flaming death spiral.\\n\\nThinking more paranoid, an extra way to enter in this flaming death\\nspiral is to not limit the maximum number of failures authorized when\\ndropping a set of orphaned tables and transactions fail multiple\\ntimes. This is basically not important as the relation on which the\\ndrop failed gets dropped from the list but failing on each one of them\\nis a good way to slow down autovacuum, so putting a limit of say 10\\ntransactions failing is I think really important.\\n\\nI have played with what you suggested, and finished with the patch\\nattached. I have run some tests using this function to create some\\ntemp tables with several backends to be sure that multiple backend IDs\\nare used:\\n\\nCREATE FUNCTION create_temp_tables(i int) RETURNS void\\nAS $$\\nBEGIN\\nFOR i IN 1..i LOOP\\n EXECUTE 'CREATE TEMP TABLE aa' || i || ' (a int);';\\nEND LOOP;\\nEND\\n$$ LANGUAGE plpgsql;\\n\\nThen I killed the instance. At restart I could see a bunch of temp\\ntables in pg_class, and I let autovacuum do the cleanup after restart.\\nI have tested as well the error code path in the PG_TRY() block by\\nenforcing manually a elog(ERROR) to be sure that the maximum number of\\nfailures is correctly handled, better safe than sorry.\\n-- \\nMichael\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 18 Nov 2016 21:16:00 -0800\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Sat, Nov 19, 2016 at 2:16 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> On Fri, Nov 18, 2016 at 1:11 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> That might sound adding unnecessary work just for the sake of\\n>> paranoia, but I don't think it is. Failures here won't be common, but\\n>> since they are entirely automated there will be no human intelligence\\n>> available to straighten things out. Barring considerable caution,\\n>> we'll just enter a flaming death spiral.\\n>\\n> Thinking more paranoid, an extra way to enter in this flaming death\\n> spiral is to not limit the maximum number of failures authorized when\\n> dropping a set of orphaned tables and transactions fail multiple\\n> times. This is basically not important as the relation on which the\\n> drop failed gets dropped from the list but failing on each one of them\\n> is a good way to slow down autovacuum, so putting a limit of say 10\\n> transactions failing is I think really important.\\n\\nBy the way, when hacking this patch I asked myself three questions:\\n1) How many objects should be dropped per transaction? 50 sounds like\\na fine number to me so the patch I sent is doing so. This should\\ndefinitely not be more than the default for max_locks_per_transaction,\\naka 64. Another thing to consider would be to use a number depending\\non max_locks_per_transaction, like half of it.\\n2) How many transaction failures should autovacuum forgive? The patch\\nuses 10. Honestly I put that number out of thin air.\\n3) Should the drop of orphaned tables be done for a wraparound\\nautovacuum? Obviously, the answer is no. It is vital not to consume\\ntransaction XIDs in this case. The patch I sent is dropping the\\nobjects even for a wraparound job, that's easily switchable.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 21 Nov 2016 12:42:07 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Sun, Nov 20, 2016 at 10:42 PM, Michael Paquier\\n<michael.paquier@gmail.com> wrote:\\n> On Sat, Nov 19, 2016 at 2:16 PM, Michael Paquier\\n> <michael.paquier@gmail.com> wrote:\\n>> On Fri, Nov 18, 2016 at 1:11 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>> That might sound adding unnecessary work just for the sake of\\n>>> paranoia, but I don't think it is. Failures here won't be common, but\\n>>> since they are entirely automated there will be no human intelligence\\n>>> available to straighten things out. Barring considerable caution,\\n>>> we'll just enter a flaming death spiral.\\n>>\\n>> Thinking more paranoid, an extra way to enter in this flaming death\\n>> spiral is to not limit the maximum number of failures authorized when\\n>> dropping a set of orphaned tables and transactions fail multiple\\n>> times. This is basically not important as the relation on which the\\n>> drop failed gets dropped from the list but failing on each one of them\\n>> is a good way to slow down autovacuum, so putting a limit of say 10\\n>> transactions failing is I think really important.\\n>\\n> By the way, when hacking this patch I asked myself three questions:\\n> 1) How many objects should be dropped per transaction? 50 sounds like\\n> a fine number to me so the patch I sent is doing so. This should\\n> definitely not be more than the default for max_locks_per_transaction,\\n> aka 64. Another thing to consider would be to use a number depending\\n> on max_locks_per_transaction, like half of it.\\n> 2) How many transaction failures should autovacuum forgive? The patch\\n> uses 10. Honestly I put that number out of thin air.\\n> 3) Should the drop of orphaned tables be done for a wraparound\\n> autovacuum? Obviously, the answer is no. It is vital not to consume\\n> transaction XIDs in this case. The patch I sent is dropping the\\n> objects even for a wraparound job, that's easily switchable.\\n\\nI don't think that you should skip it in the wraparound case, because\\nit might be one of the temp tables that is threatening wraparound.\\n\\nI've committed the patch after doing some work on the comments.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 21 Nov 2016 13:06:08 -0500\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n },\n {\n \"msg_contents\": \"On Tue, Nov 22, 2016 at 3:06 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> I don't think that you should skip it in the wraparound case, because\\n> it might be one of the temp tables that is threatening wraparound.\\n>\\n> I've committed the patch after doing some work on the comments.\\n\\nOK, thanks.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 22 Nov 2016 06:15:29 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Fun fact about autovacuum and orphan temp tables\"\n }\n]","isConversational":false}}},{"rowIdx":43092,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi guys,\n\nCan anyone suggest a project for my first PG contribution?\n\nMy first two ideas didn't pan out: Yury doesn't seem to need help\nwith CMake, and the TODO list's \"-Wcast-align\" project (now deleted)\nappeared impractical.\n\nI can continue trying things from the TODO list, but if someone knows\nof a project that's definitely worth doing, all the better.\n\nI'd prefer doing back-end coding, but I'm flexible. The only two\ncaveats are: (1) I can't work on speedup-focused changes without my\nemployer's permission, and (2) I only have access to Linux boxes.\n\nAny advice would be greatly appreciated.\n\nKind regards,\nChristian\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 13:25:03 -0400","msg_from":"Christian Convey <christian.convey@gmail.com>","msg_from_op":true,"msg_subject":"Suggestions for first contribution?"},{"msg_contents":"Hi\n\n2016-09-05 19:25 GMT+02:00 Christian Convey <christian.convey@gmail.com>:\n\n> Hi guys,\n>\n> Can anyone suggest a project for my first PG contribution?\n>\n> My first two ideas didn't pan out: Yury doesn't seem to need help\n> with CMake, and the TODO list's \"-Wcast-align\" project (now deleted)\n> appeared impractical.\n>\n> I can continue trying things from the TODO list, but if someone knows\n> of a project that's definitely worth doing, all the better.\n>\n> I'd prefer doing back-end coding, but I'm flexible. The only two\n> caveats are: (1) I can't work on speedup-focused changes without my\n> employer's permission, and (2) I only have access to Linux boxes.\n>\n> Any advice would be greatly appreciated.\n\n\nI wrote XMLTABLE function, and I am thinking about JSON_TABLE function. But\nthere is one blocker - missing JsonPath support in our JSON implementation.\n\nSo one idea - implement JsonPath support and related JSON query functions.\nThis can help with better standard conformance.\n\nRegards\n\nPavel\n\n\n\n>\n> Kind regards,\n> Christian\n>\n>\n> --\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\n> To make changes to your subscription:\n> http://www.postgresql.org/mailpref/pgsql-hackers\n>\n\nHi2016-09-05 19:25 GMT+02:00 Christian Convey <christian.convey@gmail.com>:Hi guys,\n\nCan anyone suggest a project for my first PG contribution?\n\nMy first two ideas didn't pan out: Yury doesn't seem to need help\nwith CMake, and the TODO list's \"-Wcast-align\" project (now deleted)\nappeared impractical.\n\nI can continue trying things from the TODO list, but if someone knows\nof a project that's definitely worth doing, all the better.\n\nI'd prefer doing back-end coding, but I'm flexible. The only two\ncaveats are: (1) I can't work on speedup-focused changes without my\nemployer's permission, and (2) I only have access to Linux boxes.\n\nAny advice would be greatly appreciated.I wrote XMLTABLE function, and I am thinking about JSON_TABLE function. But there is one blocker - missing JsonPath support in our JSON implementation. So one idea - implement JsonPath support and related JSON query functions. This can help with better standard conformance.RegardsPavel \n\nKind regards,\nChristian\n\n\n--\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 5 Sep 2016 19:44:11 +0200","msg_from":"Pavel Stehule <pavel.stehule@gmail.com>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"On Mon, Sep 05, 2016 at 01:25:03PM -0400, Christian Convey wrote:\n> Hi guys,\n> \n> Can anyone suggest a project for my first PG contribution?\n\nHow about adding PIVOT tables? MS SQL Server and Oracle both have\nthem. If you're interested, I have some ideas about the UI parts and\na few about the implementation.\n\nBest,\nDavid.\n-- \nDavid Fetter <david(at)fetter(dot)org> http://fetter.org/\nPhone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter\nSkype: davidfetter XMPP: david(dot)fetter(at)gmail(dot)com\n\nRemember to vote!\nConsider donating to Postgres: http://www.postgresql.org/about/donate\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 5 Sep 2016 16:18:58 -0700","msg_from":"David Fetter <david@fetter.org>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"Hello, Christian\n\n> Can anyone suggest a project for my first PG contribution?\n\nIn my experience good starting points are:\n\n* Doing code review. It's really important for PostgreSQL project.\n Everyone likes to write code, no one likes to read or test it :)\n* Finding typos, there are a lot of them.\n* Finding bugs: static code analysis, sanitizers, etc. Also subscribe to\n pgsql-bugs@ mailing list.\n* Fixing bottlenecks. Tricky part here is to find one. Could be\n difficult unless you are working for a company with many clients or\n maintain a project that uses PostgreSQL.\n\nAlso please note that such activity as answering questions on IRC or in\npgsql-general@, highlighting project news in your blog, writing articles\n(or maybe even a book) about PostgreSQL internals, organizing local user\ngroup, etc - all of this are very significant contributions.\n\nGood luck!\n\n-- \nBest regards,\nAleksander Alekseev\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 11:20:27 +0300","msg_from":"Aleksander Alekseev <a.alekseev@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"Thanks everyone for the suggestions.\n\nIt sounds like the most useful thing I can do at the moment is perform\ncode reviews. I assumed I'd need more experience with the PG code\nbase, but I keep on reading that newcomers' reviews are welcome.\nUnless someone has a better idea, I'll start with that.\n\nThe projects that Pavel and David mentioned sound very interesting.\nHopefully I can tackle one of them after I've done a few code reviews.\n\nThanks again,\nChristian\n\n\nOn Tue, Sep 6, 2016 at 4:20 AM, Aleksander Alekseev\n<a.alekseev@postgrespro.ru> wrote:\n> Hello, Christian\n>\n>> Can anyone suggest a project for my first PG contribution?\n>\n> In my experience good starting points are:\n>\n> * Doing code review. It's really important for PostgreSQL project.\n> Everyone likes to write code, no one likes to read or test it :)\n> * Finding typos, there are a lot of them.\n> * Finding bugs: static code analysis, sanitizers, etc. Also subscribe to\n> pgsql-bugs@ mailing list.\n> * Fixing bottlenecks. Tricky part here is to find one. Could be\n> difficult unless you are working for a company with many clients or\n> maintain a project that uses PostgreSQL.\n>\n> Also please note that such activity as answering questions on IRC or in\n> pgsql-general@, highlighting project news in your blog, writing articles\n> (or maybe even a book) about PostgreSQL internals, organizing local user\n> group, etc - all of this are very significant contributions.\n>\n> Good luck!\n>\n> --\n> Best regards,\n> Aleksander Alekseev\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 13:32:10 -0400","msg_from":"Christian Convey <christian.convey@gmail.com>","msg_from_op":true,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"On Tue, Sep 06, 2016 at 01:32:10PM -0400, Christian Convey wrote:\n> It sounds like the most useful thing I can do at the moment is perform\n> code reviews. I assumed I'd need more experience with the PG code\n> base, but I keep on reading that newcomers' reviews are welcome.\n> Unless someone has a better idea, I'll start with that.\n\nThat is a good choice. Thanks for getting involved in this way.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 22:54:08 -0400","msg_from":"Noah Misch <noah@leadboat.com>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"On 7 September 2016 at 10:54, Noah Misch <noah@leadboat.com> wrote:\n> On Tue, Sep 06, 2016 at 01:32:10PM -0400, Christian Convey wrote:\n>> It sounds like the most useful thing I can do at the moment is perform\n>> code reviews. I assumed I'd need more experience with the PG code\n>> base, but I keep on reading that newcomers' reviews are welcome.\n>> Unless someone has a better idea, I'll start with that.\n>\n> That is a good choice. Thanks for getting involved in this way.\n\nYeah, code review is hard when you don't know the codebase, but it's\nalso a good way to learn it.\n\nA reviewer who doesn't already know the part of the code of interest\nwell is in a good position to say \"hey, this makes no sense unless you\nknow that X, Y, Z and 42, maybe you should have a comment here so the\nnext reader doesn't have to spend 4 hours studying calls through three\ndifferent subsystems to figure it out?\" . That's actually quite nice\nfor maintainability, though obviously we can't describe everything in\ndetail everywhere, there has to be a balance.\n\nSometimes you'll also ask \"dumb\" questions that force someone to\nexplain assumptions they'd made... and in the process figure out that\nactually their assumptions don't fit reality / make sense. I certainly\nfind myself writing \"well, it does X\" explanations then figure I\nshould re-check, go read the code and find out that actually ... no,\nnot so much.\n\nThe main thing that's hard is knowing where to look to start learning\nabout the basic subsystems you need to know and the ones a particular\npatch touches on. fmgr, relcache/syscache (and invalidation, oh fun),\nhow the whole Datum variant business works, memory contexts, PGPROC,\nwalsenders and walreceivers, startup process, bgwriter, checkpointer,\nbgworkers, latches and LWLocks, shmem and private memory and\ncopy-on-write postmaster memory, elog/ereport(...) and longjmp() error\nunwinding, visibility/xmin/xmax/cmin/cmax, infomask/hintbits/locks,\nSLRUs and clog, multixacts and comboxacts, low level heap/index access\nroutines, the SPI, the parser/rewriter/planner and its subsystems like\ninheritance_planner, extensions, timelines, logical decoding, slots,\n.... etc etc. We really could use a developer's primer. The current\ndeveloper docs and scattered READMEs are nice for what they cover, but\nsomewhat spotty. That said, who's volunteering? Nope nope nope! Though\nI am trying to blog about various subsystems occasionally.\n\n-- \n Craig Ringer http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 11:22:39 +0800","msg_from":"Craig Ringer <craig@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"Here is another idea for a contribution - refactoring.\n\nCurrently there are a lot of procedures in PostgreSQL code that\ndefinitely don't fit on one screen (i.e. ~50 lines). Also many files are\nlarger than say 1000 lines of code. For instance, psql_completion\nprocedure is more than 2000 lines long! I think patches that would make\nsuch code easier to read would have a good chance to be accepted.\n\nIn case you are interested I wrote a script that scans PostgreSQL code\nand then prints procedures names and corresponding number of lines of\ncode (see attachment).\n\n-- \nBest regards,\nAleksander Alekseev\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 7 Sep 2016 17:14:44 +0300","msg_from":"Aleksander Alekseev <a.alekseev@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"Christian Convey wrote:\n> Yury doesn't seem to need help\n> with CMake\nHello.\nI am sorry that the only answer is now.\nI need help but with write CMake code:\n1. Make ecpg tests\n2. Make MinGW/Msys support\n3. many many .......\nall targets and discussion here: \nhttps://github.com/stalkerg/postgres_cmake/issues\n\nIf you can only test CMake for Ubuntu x86_64 that it is not necessary.\nIf I not fully understand you - sorry. \n\n\n\n-- \nYury Zhuravlev\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 07 Sep 2016 17:34:12 +0300","msg_from":"Yury Zhuravlev <u.zhuravlev@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Suggestions for first =?iso-8859-1?Q?contribution=3F?="},{"msg_contents":"> On 05 Sep 2016, at 20:25, Christian Convey <christian.convey@gmail.com> wrote:\n> \n> Hi guys,\n> \n> Can anyone suggest a project for my first PG contribution?\n> \n> My first two ideas didn't pan out: Yury doesn't seem to need help\n> with CMake, and the TODO list's \"-Wcast-align\" project (now deleted)\n> appeared impractical.\n\nThere is also a list of projects for google summer of code: https://wiki.postgresql.org/wiki/GSoC_2016\n\nThat topics expected to be doable by a newcomer during several months. It is also slightly\noutdated, but you always can check current state of things by searching this mail list on interesting topic.\n\nAlso postgres have several internal API’s like fdw[1] or gist[2] that allows you to implements something\nuseful without digging too much into a postgres internals.\n\n[1] https://www.postgresql.org/docs/current/static/fdwhandler.html\n[2] https://www.postgresql.org/docs/current/static/gist-extensibility.html\n\n-- \nStas Kelvich\nPostgres Professional: http://www.postgrespro.com\nRussian Postgres Company\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 17:44:09 +0300","msg_from":"Stas Kelvich <s.kelvich@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"On Wed, Sep 07, 2016 at 05:14:44PM +0300, Aleksander Alekseev wrote:\n> Here is another idea for a contribution - refactoring.\n\nRefactoring is not a good early contribution. Refactoring is more likely to\nsucceed once you internalize community code practices through much study of\nfunctional patches. However, even committer-initiated refactoring has a high\nfailure rate.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 03:00:58 -0400","msg_from":"Noah Misch <noah@leadboat.com>","msg_from_op":false,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"On Wed, Sep 7, 2016 at 10:14 AM, Aleksander Alekseev\n<a.alekseev@postgrespro.ru> wrote:\n> Here is another idea for a contribution - refactoring.\n>\n> Currently there are a lot of procedures in PostgreSQL code that\n> definitely don't fit on one screen (i.e. ~50 lines). Also many files are\n> larger than say 1000 lines of code. For instance, psql_completion\n> procedure is more than 2000 lines long! I think patches that would make\n> such code easier to read would have a good chance to be accepted.\n\nThanks for the suggestion! I can see how refactoring could make a lot\nof sense for some functions. That's probably a task I'd want to take\non after I had more experience with PG's code base. I think being\nfamiliar with most/all of PG's code would make that task go more\nsmoothly.\n\n- Christian\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 08:24:27 -0400","msg_from":"Christian Convey <christian.convey@gmail.com>","msg_from_op":true,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"On Wed, Sep 7, 2016 at 10:34 AM, Yury Zhuravlev\n<u.zhuravlev@postgrespro.ru> wrote:\n> Christian Convey wrote:\n>>\n>> Yury doesn't seem to need help\n>> with CMake\n>\n> Hello.\n> I am sorry that the only answer is now.\n> I need help but with write CMake code:\n> 1. Make ecpg tests\n> 2. Make MinGW/Msys support\n> 3. many many .......\n> all targets and discussion here:\n> https://github.com/stalkerg/postgres_cmake/issues\n>\n> If you can only test CMake for Ubuntu x86_64 that it is not necessary.\n> If I not fully understand you - sorry.\n\nHi Yury, no problem. It sounds like most of the platform testing you\nwant requires hardware I don't have, unfortunately.\n\n- Christian\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 08:30:16 -0400","msg_from":"Christian Convey <christian.convey@gmail.com>","msg_from_op":true,"msg_subject":"Re: Suggestions for first contribution?"},{"msg_contents":"On Wed, Sep 7, 2016 at 10:44 AM, Stas Kelvich <s.kelvich@postgrespro.ru> wrote:\n> There is also a list of projects for google summer of code: https://wiki.postgresql.org/wiki/GSoC_2016\n>\n> That topics expected to be doable by a newcomer during several months. It is also slightly\n> outdated, but you always can check current state of things by searching this mail list on interesting topic.\n>\n> Also postgres have several internal API’s like fdw[1] or gist[2] that allows you to implements something\n> useful without digging too much into a postgres internals.\n>\n> [1] https://www.postgresql.org/docs/current/static/fdwhandler.html\n> [2] https://www.postgresql.org/docs/current/static/gist-extensibility.html\n\nThanks Stas, I'll have a look at those. I appreciate the links.\n\n- Christian\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 08:32:33 -0400","msg_from":"Christian Convey <christian.convey@gmail.com>","msg_from_op":true,"msg_subject":"Re: Suggestions for first contribution?"}],"string":"[\n {\n \"msg_contents\": \"Hi guys,\\n\\nCan anyone suggest a project for my first PG contribution?\\n\\nMy first two ideas didn't pan out: Yury doesn't seem to need help\\nwith CMake, and the TODO list's \\\"-Wcast-align\\\" project (now deleted)\\nappeared impractical.\\n\\nI can continue trying things from the TODO list, but if someone knows\\nof a project that's definitely worth doing, all the better.\\n\\nI'd prefer doing back-end coding, but I'm flexible. The only two\\ncaveats are: (1) I can't work on speedup-focused changes without my\\nemployer's permission, and (2) I only have access to Linux boxes.\\n\\nAny advice would be greatly appreciated.\\n\\nKind regards,\\nChristian\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 13:25:03 -0400\",\n \"msg_from\": \"Christian Convey <christian.convey@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"Hi\\n\\n2016-09-05 19:25 GMT+02:00 Christian Convey <christian.convey@gmail.com>:\\n\\n> Hi guys,\\n>\\n> Can anyone suggest a project for my first PG contribution?\\n>\\n> My first two ideas didn't pan out: Yury doesn't seem to need help\\n> with CMake, and the TODO list's \\\"-Wcast-align\\\" project (now deleted)\\n> appeared impractical.\\n>\\n> I can continue trying things from the TODO list, but if someone knows\\n> of a project that's definitely worth doing, all the better.\\n>\\n> I'd prefer doing back-end coding, but I'm flexible. The only two\\n> caveats are: (1) I can't work on speedup-focused changes without my\\n> employer's permission, and (2) I only have access to Linux boxes.\\n>\\n> Any advice would be greatly appreciated.\\n\\n\\nI wrote XMLTABLE function, and I am thinking about JSON_TABLE function. But\\nthere is one blocker - missing JsonPath support in our JSON implementation.\\n\\nSo one idea - implement JsonPath support and related JSON query functions.\\nThis can help with better standard conformance.\\n\\nRegards\\n\\nPavel\\n\\n\\n\\n>\\n> Kind regards,\\n> Christian\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\n>\\n\\nHi2016-09-05 19:25 GMT+02:00 Christian Convey <christian.convey@gmail.com>:Hi guys,\\n\\nCan anyone suggest a project for my first PG contribution?\\n\\nMy first two ideas didn't pan out: Yury doesn't seem to need help\\nwith CMake, and the TODO list's \\\"-Wcast-align\\\" project (now deleted)\\nappeared impractical.\\n\\nI can continue trying things from the TODO list, but if someone knows\\nof a project that's definitely worth doing, all the better.\\n\\nI'd prefer doing back-end coding, but I'm flexible. The only two\\ncaveats are: (1) I can't work on speedup-focused changes without my\\nemployer's permission, and (2) I only have access to Linux boxes.\\n\\nAny advice would be greatly appreciated.I wrote XMLTABLE function, and I am thinking about JSON_TABLE function. But there is one blocker - missing JsonPath support in our JSON implementation. So one idea - implement JsonPath support and related JSON query functions. This can help with better standard conformance.RegardsPavel \\n\\nKind regards,\\nChristian\\n\\n\\n--\\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 5 Sep 2016 19:44:11 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 05, 2016 at 01:25:03PM -0400, Christian Convey wrote:\\n> Hi guys,\\n> \\n> Can anyone suggest a project for my first PG contribution?\\n\\nHow about adding PIVOT tables? MS SQL Server and Oracle both have\\nthem. If you're interested, I have some ideas about the UI parts and\\na few about the implementation.\\n\\nBest,\\nDavid.\\n-- \\nDavid Fetter <david(at)fetter(dot)org> http://fetter.org/\\nPhone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter\\nSkype: davidfetter XMPP: david(dot)fetter(at)gmail(dot)com\\n\\nRemember to vote!\\nConsider donating to Postgres: http://www.postgresql.org/about/donate\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 5 Sep 2016 16:18:58 -0700\",\n \"msg_from\": \"David Fetter <david@fetter.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"Hello, Christian\\n\\n> Can anyone suggest a project for my first PG contribution?\\n\\nIn my experience good starting points are:\\n\\n* Doing code review. It's really important for PostgreSQL project.\\n Everyone likes to write code, no one likes to read or test it :)\\n* Finding typos, there are a lot of them.\\n* Finding bugs: static code analysis, sanitizers, etc. Also subscribe to\\n pgsql-bugs@ mailing list.\\n* Fixing bottlenecks. Tricky part here is to find one. Could be\\n difficult unless you are working for a company with many clients or\\n maintain a project that uses PostgreSQL.\\n\\nAlso please note that such activity as answering questions on IRC or in\\npgsql-general@, highlighting project news in your blog, writing articles\\n(or maybe even a book) about PostgreSQL internals, organizing local user\\ngroup, etc - all of this are very significant contributions.\\n\\nGood luck!\\n\\n-- \\nBest regards,\\nAleksander Alekseev\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 11:20:27 +0300\",\n \"msg_from\": \"Aleksander Alekseev <a.alekseev@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"Thanks everyone for the suggestions.\\n\\nIt sounds like the most useful thing I can do at the moment is perform\\ncode reviews. I assumed I'd need more experience with the PG code\\nbase, but I keep on reading that newcomers' reviews are welcome.\\nUnless someone has a better idea, I'll start with that.\\n\\nThe projects that Pavel and David mentioned sound very interesting.\\nHopefully I can tackle one of them after I've done a few code reviews.\\n\\nThanks again,\\nChristian\\n\\n\\nOn Tue, Sep 6, 2016 at 4:20 AM, Aleksander Alekseev\\n<a.alekseev@postgrespro.ru> wrote:\\n> Hello, Christian\\n>\\n>> Can anyone suggest a project for my first PG contribution?\\n>\\n> In my experience good starting points are:\\n>\\n> * Doing code review. It's really important for PostgreSQL project.\\n> Everyone likes to write code, no one likes to read or test it :)\\n> * Finding typos, there are a lot of them.\\n> * Finding bugs: static code analysis, sanitizers, etc. Also subscribe to\\n> pgsql-bugs@ mailing list.\\n> * Fixing bottlenecks. Tricky part here is to find one. Could be\\n> difficult unless you are working for a company with many clients or\\n> maintain a project that uses PostgreSQL.\\n>\\n> Also please note that such activity as answering questions on IRC or in\\n> pgsql-general@, highlighting project news in your blog, writing articles\\n> (or maybe even a book) about PostgreSQL internals, organizing local user\\n> group, etc - all of this are very significant contributions.\\n>\\n> Good luck!\\n>\\n> --\\n> Best regards,\\n> Aleksander Alekseev\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 13:32:10 -0400\",\n \"msg_from\": \"Christian Convey <christian.convey@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 06, 2016 at 01:32:10PM -0400, Christian Convey wrote:\\n> It sounds like the most useful thing I can do at the moment is perform\\n> code reviews. I assumed I'd need more experience with the PG code\\n> base, but I keep on reading that newcomers' reviews are welcome.\\n> Unless someone has a better idea, I'll start with that.\\n\\nThat is a good choice. Thanks for getting involved in this way.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 22:54:08 -0400\",\n \"msg_from\": \"Noah Misch <noah@leadboat.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"On 7 September 2016 at 10:54, Noah Misch <noah@leadboat.com> wrote:\\n> On Tue, Sep 06, 2016 at 01:32:10PM -0400, Christian Convey wrote:\\n>> It sounds like the most useful thing I can do at the moment is perform\\n>> code reviews. I assumed I'd need more experience with the PG code\\n>> base, but I keep on reading that newcomers' reviews are welcome.\\n>> Unless someone has a better idea, I'll start with that.\\n>\\n> That is a good choice. Thanks for getting involved in this way.\\n\\nYeah, code review is hard when you don't know the codebase, but it's\\nalso a good way to learn it.\\n\\nA reviewer who doesn't already know the part of the code of interest\\nwell is in a good position to say \\\"hey, this makes no sense unless you\\nknow that X, Y, Z and 42, maybe you should have a comment here so the\\nnext reader doesn't have to spend 4 hours studying calls through three\\ndifferent subsystems to figure it out?\\\" . That's actually quite nice\\nfor maintainability, though obviously we can't describe everything in\\ndetail everywhere, there has to be a balance.\\n\\nSometimes you'll also ask \\\"dumb\\\" questions that force someone to\\nexplain assumptions they'd made... and in the process figure out that\\nactually their assumptions don't fit reality / make sense. I certainly\\nfind myself writing \\\"well, it does X\\\" explanations then figure I\\nshould re-check, go read the code and find out that actually ... no,\\nnot so much.\\n\\nThe main thing that's hard is knowing where to look to start learning\\nabout the basic subsystems you need to know and the ones a particular\\npatch touches on. fmgr, relcache/syscache (and invalidation, oh fun),\\nhow the whole Datum variant business works, memory contexts, PGPROC,\\nwalsenders and walreceivers, startup process, bgwriter, checkpointer,\\nbgworkers, latches and LWLocks, shmem and private memory and\\ncopy-on-write postmaster memory, elog/ereport(...) and longjmp() error\\nunwinding, visibility/xmin/xmax/cmin/cmax, infomask/hintbits/locks,\\nSLRUs and clog, multixacts and comboxacts, low level heap/index access\\nroutines, the SPI, the parser/rewriter/planner and its subsystems like\\ninheritance_planner, extensions, timelines, logical decoding, slots,\\n.... etc etc. We really could use a developer's primer. The current\\ndeveloper docs and scattered READMEs are nice for what they cover, but\\nsomewhat spotty. That said, who's volunteering? Nope nope nope! Though\\nI am trying to blog about various subsystems occasionally.\\n\\n-- \\n Craig Ringer http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 11:22:39 +0800\",\n \"msg_from\": \"Craig Ringer <craig@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"Here is another idea for a contribution - refactoring.\\n\\nCurrently there are a lot of procedures in PostgreSQL code that\\ndefinitely don't fit on one screen (i.e. ~50 lines). Also many files are\\nlarger than say 1000 lines of code. For instance, psql_completion\\nprocedure is more than 2000 lines long! I think patches that would make\\nsuch code easier to read would have a good chance to be accepted.\\n\\nIn case you are interested I wrote a script that scans PostgreSQL code\\nand then prints procedures names and corresponding number of lines of\\ncode (see attachment).\\n\\n-- \\nBest regards,\\nAleksander Alekseev\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 7 Sep 2016 17:14:44 +0300\",\n \"msg_from\": \"Aleksander Alekseev <a.alekseev@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"Christian Convey wrote:\\n> Yury doesn't seem to need help\\n> with CMake\\nHello.\\nI am sorry that the only answer is now.\\nI need help but with write CMake code:\\n1. Make ecpg tests\\n2. Make MinGW/Msys support\\n3. many many .......\\nall targets and discussion here: \\nhttps://github.com/stalkerg/postgres_cmake/issues\\n\\nIf you can only test CMake for Ubuntu x86_64 that it is not necessary.\\nIf I not fully understand you - sorry. \\n\\n\\n\\n-- \\nYury Zhuravlev\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 07 Sep 2016 17:34:12 +0300\",\n \"msg_from\": \"Yury Zhuravlev <u.zhuravlev@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first =?iso-8859-1?Q?contribution=3F?=\"\n },\n {\n \"msg_contents\": \"> On 05 Sep 2016, at 20:25, Christian Convey <christian.convey@gmail.com> wrote:\\n> \\n> Hi guys,\\n> \\n> Can anyone suggest a project for my first PG contribution?\\n> \\n> My first two ideas didn't pan out: Yury doesn't seem to need help\\n> with CMake, and the TODO list's \\\"-Wcast-align\\\" project (now deleted)\\n> appeared impractical.\\n\\nThere is also a list of projects for google summer of code: https://wiki.postgresql.org/wiki/GSoC_2016\\n\\nThat topics expected to be doable by a newcomer during several months. It is also slightly\\noutdated, but you always can check current state of things by searching this mail list on interesting topic.\\n\\nAlso postgres have several internal API’s like fdw[1] or gist[2] that allows you to implements something\\nuseful without digging too much into a postgres internals.\\n\\n[1] https://www.postgresql.org/docs/current/static/fdwhandler.html\\n[2] https://www.postgresql.org/docs/current/static/gist-extensibility.html\\n\\n-- \\nStas Kelvich\\nPostgres Professional: http://www.postgrespro.com\\nRussian Postgres Company\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 17:44:09 +0300\",\n \"msg_from\": \"Stas Kelvich <s.kelvich@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 07, 2016 at 05:14:44PM +0300, Aleksander Alekseev wrote:\\n> Here is another idea for a contribution - refactoring.\\n\\nRefactoring is not a good early contribution. Refactoring is more likely to\\nsucceed once you internalize community code practices through much study of\\nfunctional patches. However, even committer-initiated refactoring has a high\\nfailure rate.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 03:00:58 -0400\",\n \"msg_from\": \"Noah Misch <noah@leadboat.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 7, 2016 at 10:14 AM, Aleksander Alekseev\\n<a.alekseev@postgrespro.ru> wrote:\\n> Here is another idea for a contribution - refactoring.\\n>\\n> Currently there are a lot of procedures in PostgreSQL code that\\n> definitely don't fit on one screen (i.e. ~50 lines). Also many files are\\n> larger than say 1000 lines of code. For instance, psql_completion\\n> procedure is more than 2000 lines long! I think patches that would make\\n> such code easier to read would have a good chance to be accepted.\\n\\nThanks for the suggestion! I can see how refactoring could make a lot\\nof sense for some functions. That's probably a task I'd want to take\\non after I had more experience with PG's code base. I think being\\nfamiliar with most/all of PG's code would make that task go more\\nsmoothly.\\n\\n- Christian\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 08:24:27 -0400\",\n \"msg_from\": \"Christian Convey <christian.convey@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 7, 2016 at 10:34 AM, Yury Zhuravlev\\n<u.zhuravlev@postgrespro.ru> wrote:\\n> Christian Convey wrote:\\n>>\\n>> Yury doesn't seem to need help\\n>> with CMake\\n>\\n> Hello.\\n> I am sorry that the only answer is now.\\n> I need help but with write CMake code:\\n> 1. Make ecpg tests\\n> 2. Make MinGW/Msys support\\n> 3. many many .......\\n> all targets and discussion here:\\n> https://github.com/stalkerg/postgres_cmake/issues\\n>\\n> If you can only test CMake for Ubuntu x86_64 that it is not necessary.\\n> If I not fully understand you - sorry.\\n\\nHi Yury, no problem. It sounds like most of the platform testing you\\nwant requires hardware I don't have, unfortunately.\\n\\n- Christian\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 08:30:16 -0400\",\n \"msg_from\": \"Christian Convey <christian.convey@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 7, 2016 at 10:44 AM, Stas Kelvich <s.kelvich@postgrespro.ru> wrote:\\n> There is also a list of projects for google summer of code: https://wiki.postgresql.org/wiki/GSoC_2016\\n>\\n> That topics expected to be doable by a newcomer during several months. It is also slightly\\n> outdated, but you always can check current state of things by searching this mail list on interesting topic.\\n>\\n> Also postgres have several internal API’s like fdw[1] or gist[2] that allows you to implements something\\n> useful without digging too much into a postgres internals.\\n>\\n> [1] https://www.postgresql.org/docs/current/static/fdwhandler.html\\n> [2] https://www.postgresql.org/docs/current/static/gist-extensibility.html\\n\\nThanks Stas, I'll have a look at those. I appreciate the links.\\n\\n- Christian\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 08:32:33 -0400\",\n \"msg_from\": \"Christian Convey <christian.convey@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Suggestions for first contribution?\"\n }\n]","isConversational":false}}},{"rowIdx":43093,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"While working on my parallel CREATE INDEX patch, I came across a\nproblem. I initially assumed that what I saw was just a bug in my\ndevelopment branch. During a final merge in a parallel worker, with\nvery little maintenance_work_mem, workers attempted to allocate an\namount of memory slightly less than 2 ^ 64, and fail, since that\nexceeds MaxAllocHugeSize. I noticed that this happened immediately\nfollowing batchmemtuples() leaving us in a LACKMEM() state due to a\nfault in its calculation (or, if you prefer, the lack of any defense\nagainst that fault).\n\nFurther analysis led me to believe that this is a 9.6 bug. We should\nhave a check for sane memtuples growth, in line with the\ngrow_memtuples() check, where \"We need to be sure that we do not cause\nLACKMEM to become true, else the space management algorithm will go\nnuts\". Because of the way grow_memtuples() is called by\nbatchmemtuples() in practice (in particular, because\navailMemLessRefund may be < 0 in these corner cases),\ngrow_memtuples()'s own protections may not save us as previously\nassumed. FREEMEM() *takes away* memory from the availMem budget when\n\"availMemLessRefund < 0\", just after the conventional grow_memtuples()\nchecks run.\n\nAttached patch adds a defense. FWIW, there is no reason to think that\nmore careful accounting could fix this problem, since in general a\nLACKMEM() condition may not immediately lead to tuples being dumped\nout.\n\nI haven't been able to reproduce this on 9.6, but that seems\nunnecessary. I can reproduce it with my parallel CREATE INDEX patch\napplied, with just the right test case and right number of workers\n(it's rather delicate). After careful consideration, I can think of no\nreason why 9.6 would be unaffected.\n\n-- \nPeter Geoghegan\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 5 Sep 2016 14:54:54 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":true,"msg_subject":"Bug in 9.6 tuplesort batch memory growth logic"},{"msg_contents":"Peter Geoghegan <pg@heroku.com> writes:\n> While working on my parallel CREATE INDEX patch, I came across a\n> problem.\n\nI took a quick look at this. I do not follow the logic in this new bit:\n\n+\tif (availMemLessRefund <=\n+\t\t(int64) state->activeTapes * ALLOCSET_DEFAULT_INITSIZE)\n+\t return;\n\nIt doesn't seem to me that this limit has anything to do with anything,\nand the comment claiming only that it's \"noncritical\" isn't helping.\nIf the point is to prevent the later LACKMEM check from failing, then\ncertainly there is something critical somewhere. I'd rather see this\nexplained as \"we need at least X, but we choose to require at least Y\nto avoid repalloc thrashing\". And maybe the code should use Max(X,Y)\nrather than blindly assuming that ALLOCSET_DEFAULT_INITSIZE exceeds\nwhatever the true minimum is.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 06 Sep 2016 09:17:55 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Bug in 9.6 tuplesort batch memory growth logic"},{"msg_contents":"On Tue, Sep 6, 2016 at 6:17 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> It doesn't seem to me that this limit has anything to do with anything,\n> and the comment claiming only that it's \"noncritical\" isn't helping.\n> If the point is to prevent the later LACKMEM check from failing, then\n> certainly there is something critical somewhere. I'd rather see this\n> explained as \"we need at least X, but we choose to require at least Y\n> to avoid repalloc thrashing\".\n\nYou've not understood the problem at all. The only thing that's\ncritical is that the calculation not fail at all, through a later\navailMem that is < 0 (i.e. a LACKMEM() condition).\n\n> And maybe the code should use Max(X,Y)\n> rather than blindly assuming that ALLOCSET_DEFAULT_INITSIZE exceeds\n> whatever the true minimum is.\n\nThe true minimum is 0, so that seems like a safe bet. Comments point\nthis out directly, and that we are not reliant on having any\nparticular amount of memory available, even enough for one tuple (the\noverflow mechanism will later save us).\n\nI knew that the patch would be criticized for still allowing a useless\npalloc, and some threshold was needed. I also knew any choice of\nconstant would be criticized (e.g., \"that's voodoo\"), so pointed out\nspecifically that it was non-critical.\n\nWhat threshold would you use?\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 08:40:34 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":true,"msg_subject":"Re: Bug in 9.6 tuplesort batch memory growth logic"},{"msg_contents":"Peter Geoghegan <pg@heroku.com> writes:\n> On Tue, Sep 6, 2016 at 6:17 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n>> It doesn't seem to me that this limit has anything to do with anything,\n>> and the comment claiming only that it's \"noncritical\" isn't helping.\n\n> You've not understood the problem at all. The only thing that's\n> critical is that the calculation not fail at all, through a later\n> availMem that is < 0 (i.e. a LACKMEM() condition).\n\nI see. The comment could do with a bit of rewriting, perhaps.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 06 Sep 2016 12:41:48 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Bug in 9.6 tuplesort batch memory growth logic"},{"msg_contents":"I wrote:\n> I see. The comment could do with a bit of rewriting, perhaps.\n\nI rewrote the comment and pushed it.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 06 Sep 2016 15:51:35 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Bug in 9.6 tuplesort batch memory growth logic"},{"msg_contents":"On Tue, Sep 6, 2016 at 12:51 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> I rewrote the comment and pushed it.\n\nThank you.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 12:52:06 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":true,"msg_subject":"Re: Bug in 9.6 tuplesort batch memory growth logic"}],"string":"[\n {\n \"msg_contents\": \"While working on my parallel CREATE INDEX patch, I came across a\\nproblem. I initially assumed that what I saw was just a bug in my\\ndevelopment branch. During a final merge in a parallel worker, with\\nvery little maintenance_work_mem, workers attempted to allocate an\\namount of memory slightly less than 2 ^ 64, and fail, since that\\nexceeds MaxAllocHugeSize. I noticed that this happened immediately\\nfollowing batchmemtuples() leaving us in a LACKMEM() state due to a\\nfault in its calculation (or, if you prefer, the lack of any defense\\nagainst that fault).\\n\\nFurther analysis led me to believe that this is a 9.6 bug. We should\\nhave a check for sane memtuples growth, in line with the\\ngrow_memtuples() check, where \\\"We need to be sure that we do not cause\\nLACKMEM to become true, else the space management algorithm will go\\nnuts\\\". Because of the way grow_memtuples() is called by\\nbatchmemtuples() in practice (in particular, because\\navailMemLessRefund may be < 0 in these corner cases),\\ngrow_memtuples()'s own protections may not save us as previously\\nassumed. FREEMEM() *takes away* memory from the availMem budget when\\n\\\"availMemLessRefund < 0\\\", just after the conventional grow_memtuples()\\nchecks run.\\n\\nAttached patch adds a defense. FWIW, there is no reason to think that\\nmore careful accounting could fix this problem, since in general a\\nLACKMEM() condition may not immediately lead to tuples being dumped\\nout.\\n\\nI haven't been able to reproduce this on 9.6, but that seems\\nunnecessary. I can reproduce it with my parallel CREATE INDEX patch\\napplied, with just the right test case and right number of workers\\n(it's rather delicate). After careful consideration, I can think of no\\nreason why 9.6 would be unaffected.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 5 Sep 2016 14:54:54 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Bug in 9.6 tuplesort batch memory growth logic\"\n },\n {\n \"msg_contents\": \"Peter Geoghegan <pg@heroku.com> writes:\\n> While working on my parallel CREATE INDEX patch, I came across a\\n> problem.\\n\\nI took a quick look at this. I do not follow the logic in this new bit:\\n\\n+\\tif (availMemLessRefund <=\\n+\\t\\t(int64) state->activeTapes * ALLOCSET_DEFAULT_INITSIZE)\\n+\\t return;\\n\\nIt doesn't seem to me that this limit has anything to do with anything,\\nand the comment claiming only that it's \\\"noncritical\\\" isn't helping.\\nIf the point is to prevent the later LACKMEM check from failing, then\\ncertainly there is something critical somewhere. I'd rather see this\\nexplained as \\\"we need at least X, but we choose to require at least Y\\nto avoid repalloc thrashing\\\". And maybe the code should use Max(X,Y)\\nrather than blindly assuming that ALLOCSET_DEFAULT_INITSIZE exceeds\\nwhatever the true minimum is.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 09:17:55 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Bug in 9.6 tuplesort batch memory growth logic\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 6:17 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> It doesn't seem to me that this limit has anything to do with anything,\\n> and the comment claiming only that it's \\\"noncritical\\\" isn't helping.\\n> If the point is to prevent the later LACKMEM check from failing, then\\n> certainly there is something critical somewhere. I'd rather see this\\n> explained as \\\"we need at least X, but we choose to require at least Y\\n> to avoid repalloc thrashing\\\".\\n\\nYou've not understood the problem at all. The only thing that's\\ncritical is that the calculation not fail at all, through a later\\navailMem that is < 0 (i.e. a LACKMEM() condition).\\n\\n> And maybe the code should use Max(X,Y)\\n> rather than blindly assuming that ALLOCSET_DEFAULT_INITSIZE exceeds\\n> whatever the true minimum is.\\n\\nThe true minimum is 0, so that seems like a safe bet. Comments point\\nthis out directly, and that we are not reliant on having any\\nparticular amount of memory available, even enough for one tuple (the\\noverflow mechanism will later save us).\\n\\nI knew that the patch would be criticized for still allowing a useless\\npalloc, and some threshold was needed. I also knew any choice of\\nconstant would be criticized (e.g., \\\"that's voodoo\\\"), so pointed out\\nspecifically that it was non-critical.\\n\\nWhat threshold would you use?\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 08:40:34 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Bug in 9.6 tuplesort batch memory growth logic\"\n },\n {\n \"msg_contents\": \"Peter Geoghegan <pg@heroku.com> writes:\\n> On Tue, Sep 6, 2016 at 6:17 AM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n>> It doesn't seem to me that this limit has anything to do with anything,\\n>> and the comment claiming only that it's \\\"noncritical\\\" isn't helping.\\n\\n> You've not understood the problem at all. The only thing that's\\n> critical is that the calculation not fail at all, through a later\\n> availMem that is < 0 (i.e. a LACKMEM() condition).\\n\\nI see. The comment could do with a bit of rewriting, perhaps.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 12:41:48 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Bug in 9.6 tuplesort batch memory growth logic\"\n },\n {\n \"msg_contents\": \"I wrote:\\n> I see. The comment could do with a bit of rewriting, perhaps.\\n\\nI rewrote the comment and pushed it.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 15:51:35 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Bug in 9.6 tuplesort batch memory growth logic\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 12:51 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> I rewrote the comment and pushed it.\\n\\nThank you.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 12:52:06 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Bug in 9.6 tuplesort batch memory growth logic\"\n }\n]","isConversational":false}}},{"rowIdx":43094,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Attached fixes a typo in header comment in libpq-be.h.\n\ns/libpq_be.h/libpq-be.h/g\n\nThanks,\nAmit\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 6 Sep 2016 10:52:22 +0900","msg_from":"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Comment Typo"},{"msg_contents":"On Tue, Sep 6, 2016 at 10:52:22AM +0900, Amit Langote wrote:\n> Attached fixes a typo in header comment in libpq-be.h.\n> \n> s/libpq_be.h/libpq-be.h/g\n\nApplied.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n+ As you are, so once was I. As I am, so you will be. +\n+ Ancient Roman grave inscription +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 00:04:02 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":false,"msg_subject":"Re: Comment Typo"}],"string":"[\n {\n \"msg_contents\": \"Attached fixes a typo in header comment in libpq-be.h.\\n\\ns/libpq_be.h/libpq-be.h/g\\n\\nThanks,\\nAmit\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 6 Sep 2016 10:52:22 +0900\",\n \"msg_from\": \"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Comment Typo\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 10:52:22AM +0900, Amit Langote wrote:\\n> Attached fixes a typo in header comment in libpq-be.h.\\n> \\n> s/libpq_be.h/libpq-be.h/g\\n\\nApplied.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 00:04:02 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Comment Typo\"\n }\n]","isConversational":false}}},{"rowIdx":43095,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"While reviewing Jeff's notice_lock_waits patch, I came across his comment\nabout having a general facility for promoting selected LOG messages. So I\nthought I should post it here, even though the patch is probably far from\nbeing accepted in Postgres.\n\nI recently wrote a patch for Postgres-XL to do exactly this and I found it\nvery useful, especially while debugging race conditions and problems with\nongoing sessions. I'm attaching a patch rebased on PG-master. It works, but\nTBH I don't think it's anywhere close for being acceptable in PG. But I\nhope this is good enough to show how this can be done with minimal changes\nand spark ideas.\n\nThe patch uses some preprocessing and scripting magic to assign distinct\nidentifiers to each module (a subdir in the source code), to each file and\nto each elog message. It then provides a set of functions by which an user\ncan increase/decrease/set log levels for either individual messages or all\nmessages within a source file or source module. The log levels can be\nchanged only for specific backends or all current or future backends. If\nyou configure with --enable-genmsgids switch, a MSGMODULES and MSGIDS file\nis created in $srcdir, which can later be used to know ids assigned to\nvarious modules/messages.\n\nNow there are several problems with the patch:\n\n- I don't know if it will work for anything other than clang and gcc (I've\ntested those two, but only specific versions)\n- The shared memory representation for msgs is not at all optimal and with\na large value of max_connections, it can quickly go out of control. But I\nbelieve we can find a better representation without losing runtime\nperformance.\n- The APIs themselves can be significantly improved.\n- MSGMODULES and MSGIDS should probably be some sort of a view that user\ncan readily access without requiring access to the environment where it was\nbuilt.\n- Right now it only supports changing levels for DEBUG[1-5] and LOG\nmessages. But that could be easily extended to cover INFO or NOTICE.\n- The patch should probably have many more comments\n- Finally, I don't know if better and more elegant ways exist to\nautomatically assigning module/file/msgids. I couldn't think of any without\nmaking excessive changes to all source files and hence did what I did. That\ndoes not mean better ways don't exists.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 6 Sep 2016 14:56:24 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":true,"msg_subject":"Override compile time log levels of specific messages/modules"},{"msg_contents":"On 6 Sep. 2016 17:28, \"Pavan Deolasee\" <pavan.deolasee@gmail.com> wrote:\n>\n\n>\n> The patch uses some preprocessing and scripting magic to assign distinct\nidentifiers to each module (a subdir in the source code), to each file and\nto each elog message. It then provides a set of functions by which an user\ncan increase/decrease/set log levels for either individual messages or all\nmessages within a source file or source module. The log levels can be\nchanged only for specific backends or all current or future backends. If\nyou configure with --enable-genmsgids switch, a MSGMODULES and MSGIDS file\nis created in $srcdir, which can later be used to know ids assigned to\nvarious modules/messages.\n\nI think it's worth looking at how Java handles logging. We can't achieve an\nexact parallel in C as we don't really have a class hierarchy ... but we do\nhave subsystems roughly grouped by file and directory structure.\n\nBeing able to promote/demote these or selective lower the log level\nthreshold on a directory, file, function and line level would be\nexceedingly handy. Pretty much all of that can be magic'd up from macro\noutput so hopefully no postprocessing should be needed. (Though only gcc\nhas _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)\n\n\nOn 6 Sep. 2016 17:28, \"Pavan Deolasee\" <pavan.deolasee@gmail.com> wrote:\n>\n>\n> The patch uses some preprocessing and scripting magic to assign distinct identifiers to each module (a subdir in the source code), to each file and to each elog message. It then provides a set of functions by which an user can increase/decrease/set log levels for either individual messages or all messages within a source file or source module. The log levels can be changed only for specific backends or all current or future backends. If you configure with --enable-genmsgids switch, a MSGMODULES and MSGIDS file is created in $srcdir, which can later be used to know ids assigned to various modules/messages.\nI think it's worth looking at how Java handles logging. We can't achieve an exact parallel in C as we don't really have a class hierarchy ... but we do have subsystems roughly grouped by file and directory structure.\nBeing able to promote/demote these or selective lower the log level threshold on a directory, file, function and line level would be exceedingly handy. Pretty much all of that can be magic'd up from macro output so hopefully no postprocessing should be needed. (Though only gcc has _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)","msg_date":"Tue, 6 Sep 2016 17:36:53 +0800","msg_from":"Craig Ringer <craig.ringer@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Override compile time log levels of specific messages/modules"},{"msg_contents":"On Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com>\nwrote:\n\n>\n> I think it's worth looking at how Java handles logging. We can't achieve\n> an exact parallel in C as we don't really have a class hierarchy ... but we\n> do have subsystems roughly grouped by file and directory structure.\n>\n> Sure. In some large, popular enterprise softwares I've worked with many\nyears ago, we used to define modules within each source file and then\nmanually assign distinct integer IDs to each message and then provide\nvarious utilities to turn on/off specific messages or range of messages\nwithin a module.\n\n> Being able to promote/demote these or selective lower the log level\n> threshold on a directory, file, function and line level would be\n> exceedingly handy. Pretty much all of that can be magic'd up from macro\n> output so hopefully no postprocessing should be needed. (Though only gcc\n> has _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)\n>\nWell, __FUNCTION__ expands to function name and lookup based on string\nidentifiers will always be costly, especially if you want to sprinkle the\ncode with lot many debug messages. Same with __FILE__. I believe we need an\nunique integer constant to make it a fast, O(1) lookup. I couldn't find any\nother method to do that when I wrote the facility and hence did what I did.\n\nThanks,\nPavan\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com> wrote:\n\nI think it's worth looking at how Java handles logging. We can't achieve an exact parallel in C as we don't really have a class hierarchy ... but we do have subsystems roughly grouped by file and directory structure.\nSure. In some large, popular enterprise softwares I've worked with many years ago, we used to define modules within each source file and then manually assign distinct integer IDs to each message and then provide various utilities to turn on/off specific messages or range of messages within a module. Being able to promote/demote these or selective lower the log level threshold on a directory, file, function and line level would be exceedingly handy. Pretty much all of that can be magic'd up from macro output so hopefully no postprocessing should be needed. (Though only gcc has _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)\nWell, __FUNCTION__ expands to function name and lookup based on string identifiers will always be costly, especially if you want to sprinkle the code with lot many debug messages. Same with __FILE__. I believe we need an unique integer constant to make it a fast, O(1) lookup. I couldn't find any other method to do that when I wrote the facility and hence did what I did.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Tue, 6 Sep 2016 15:26:49 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":true,"msg_subject":"Re: Override compile time log levels of specific messages/modules"},{"msg_contents":"On 6 Sep. 2016 17:57, \"Pavan Deolasee\" <pavan.deolasee@gmail.com> wrote:\n>\n>\n>\n> On Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com>\nwrote:\n>>\n>>\n>> I think it's worth looking at how Java handles logging. We can't achieve\nan exact parallel in C as we don't really have a class hierarchy ... but we\ndo have subsystems roughly grouped by file and directory structure.\n>\n> Sure. In some large, popular enterprise softwares I've worked with many\nyears ago, we used to define modules within each source file and then\nmanually assign distinct integer IDs to each message and then provide\nvarious utilities to turn on/off specific messages or range of messages\nwithin a module.\n\nYeah, there same has been discussed for Pg many times and firmly shot down\neach time. I certainly see the argument against making specific elog calls\npart of a sort of api people might expect to be stable ish. That's what we\nhave ERRCODE / SQLSTATE for right? Concerns about backpatch pain were also\nraised. Probably more. I'm not especially for or against it myself, just\nsaying that based on past discussion such a proposal isn't likely to fly.\n\nI think something automatic that we clearly define as unstable and not to\nbe relied upon would be preferable. Plus we already have much of the\ninfrastructure in elog.c as used by errcontext etc.\n\n> Well, __FUNCTION__ expands to function name and lookup based on string\nidentifiers will always be costly, especially if you want to sprinkle the\ncode with lot many debug messages. Same with __FILE__. I believe we need an\nunique integer constant to make it a fast, O(1) lookup. I couldn't find any\nother method to do that when I wrote the facility and hence did what I did.\n\nYeah. High performance logging and filtering isnt easy. Looking at existing\nC logging libraries with dynamic filtering might be informative. Though I\ncan't imagine there being agreement to adopt one, this must be a reasonably\nsolved problem...\n\n>\n> Thanks,\n> Pavan\n> --\n> Pavan Deolasee http://www.2ndQuadrant.com/\n> PostgreSQL Development, 24x7 Support, Training & Services\n\nOn 6 Sep. 2016 17:57, \"Pavan Deolasee\" <pavan.deolasee@gmail.com> wrote:\n>\n>\n>\n> On Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com> wrote:\n>>\n>>\n>> I think it's worth looking at how Java handles logging. We can't achieve an exact parallel in C as we don't really have a class hierarchy ... but we do have subsystems roughly grouped by file and directory structure.\n>\n> Sure. In some large, popular enterprise softwares I've worked with many years ago, we used to define modules within each source file and then manually assign distinct integer IDs to each message and then provide various utilities to turn on/off specific messages or range of messages within a module.\nYeah, there same has been discussed for Pg many times and firmly shot down each time. I certainly see the argument against making specific elog calls part of a sort of api people might expect to be stable ish. That's what we have ERRCODE / SQLSTATE for right? Concerns about backpatch pain were also raised. Probably more. I'm not especially for or against it myself, just saying that based on past discussion such a proposal isn't likely to fly.\nI think something automatic that we clearly define as unstable and not to be relied upon would be preferable. Plus we already have much of the infrastructure in elog.c as used by errcontext etc.\n> Well, __FUNCTION__ expands to function name and lookup based on string identifiers will always be costly, especially if you want to sprinkle the code with lot many debug messages. Same with __FILE__. I believe we need an unique integer constant to make it a fast, O(1) lookup. I couldn't find any other method to do that when I wrote the facility and hence did what I did.\nYeah. High performance logging and filtering isnt easy. Looking at existing C logging libraries with dynamic filtering might be informative. Though I can't imagine there being agreement to adopt one, this must be a reasonably solved problem...\n>\n> Thanks,\n> Pavan\n> -- \n> Pavan Deolasee http://www.2ndQuadrant.com/\n> PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Tue, 6 Sep 2016 18:18:15 +0800","msg_from":"Craig Ringer <craig.ringer@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Override compile time log levels of specific messages/modules"},{"msg_contents":"On 9/6/16 5:18 AM, Craig Ringer wrote:\n> I think something automatic that we clearly define as unstable and not\n> to be relied upon would be preferable. Plus we already have much of the\n> infrastructure in elog.c as used by errcontext etc.\n\nActually, I wish this was a straight-up logging level feature, because I \nneed it all the time when debugging complicated user-level code. \nSpecifically, I wish there was a GUC that would alter \n(client|log)_min_messages upon entering a specific function, either for \njust that function or for anything that function subsequently called. \nBonus points if you could also specify a regex that the message text had \nto match.\n\nI realize that code-wise that's completely incompatible with what you're \ndiscussing here, but I think the same API could be used (maybe as a \ndifferent GUC).\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 10 Sep 2016 22:31:07 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":false,"msg_subject":"Re: Override compile time log levels of specific\n messages/modules"},{"msg_contents":"On 11 Sep. 2016 11:31, \"Jim Nasby\" <Jim.Nasby@bluetreble.com> wrote:\n\n> Actually, I wish this was a straight-up logging level feature, because I\nneed it all the time when debugging complicated user-level code.\nSpecifically, I wish there was a GUC that would alter\n(client|log)_min_messages upon entering a specific function, either for\njust that function or for anything that function subsequently called.\n\nWe have that or close to it, but it's restricted for security. IIRC you\ncan't SET log_min_messages as non superuser including as part of CREATE\nFUNCTION ... SET. Presumably because lowering it would let the user hide\nactivity admins expect to be recorded. Raising it would let them possibly\nDoS via log spam - though that argument is rather undermined by the ability\nto write plpgsql that does RAISE in a tight loop.\n\nI'd like to be able to let users make logging more detailed but not less,\nso they can only SET it to something equal to or more detailed to what\ntheir session has art the start. Should actually be pretty trivial to\nimplement too.\n\nYou can then SET at session level, function level, SET LOCAL, etc. If you\nwant to control it dynamically via GUC you add calls to your functions to\ncheck a custom user GUC and SET log level accordingly. Using whatever logic\nyou like.\n\n> Bonus points if you could also specify a regex that the message text had\nto match.\n>\n\nAn errfinish() hook would be nice for that.\n\n\nOn 11 Sep. 2016 11:31, \"Jim Nasby\" <Jim.Nasby@bluetreble.com> wrote:\n> Actually, I wish this was a straight-up logging level feature, because I need it all the time when debugging complicated user-level code. Specifically, I wish there was a GUC that would alter (client|log)_min_messages upon entering a specific function, either for just that function or for anything that function subsequently called.\nWe have that or close to it, but it's restricted for security. IIRC you can't SET log_min_messages as non superuser including as part of CREATE FUNCTION ... SET. Presumably because lowering it would let the user hide activity admins expect to be recorded. Raising it would let them possibly DoS via log spam - though that argument is rather undermined by the ability to write plpgsql that does RAISE in a tight loop.\nI'd like to be able to let users make logging more detailed but not less, so they can only SET it to something equal to or more detailed to what their session has art the start. Should actually be pretty trivial to implement too.\nYou can then SET at session level, function level, SET LOCAL, etc. If you want to control it dynamically via GUC you add calls to your functions to check a custom user GUC and SET log level accordingly. Using whatever logic you like.\n> Bonus points if you could also specify a regex that the message text had to match.\n>\nAn errfinish() hook would be nice for that.","msg_date":"Sun, 11 Sep 2016 19:42:36 +0800","msg_from":"Craig Ringer <craig.ringer@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Override compile time log levels of specific messages/modules"}],"string":"[\n {\n \"msg_contents\": \"While reviewing Jeff's notice_lock_waits patch, I came across his comment\\nabout having a general facility for promoting selected LOG messages. So I\\nthought I should post it here, even though the patch is probably far from\\nbeing accepted in Postgres.\\n\\nI recently wrote a patch for Postgres-XL to do exactly this and I found it\\nvery useful, especially while debugging race conditions and problems with\\nongoing sessions. I'm attaching a patch rebased on PG-master. It works, but\\nTBH I don't think it's anywhere close for being acceptable in PG. But I\\nhope this is good enough to show how this can be done with minimal changes\\nand spark ideas.\\n\\nThe patch uses some preprocessing and scripting magic to assign distinct\\nidentifiers to each module (a subdir in the source code), to each file and\\nto each elog message. It then provides a set of functions by which an user\\ncan increase/decrease/set log levels for either individual messages or all\\nmessages within a source file or source module. The log levels can be\\nchanged only for specific backends or all current or future backends. If\\nyou configure with --enable-genmsgids switch, a MSGMODULES and MSGIDS file\\nis created in $srcdir, which can later be used to know ids assigned to\\nvarious modules/messages.\\n\\nNow there are several problems with the patch:\\n\\n- I don't know if it will work for anything other than clang and gcc (I've\\ntested those two, but only specific versions)\\n- The shared memory representation for msgs is not at all optimal and with\\na large value of max_connections, it can quickly go out of control. But I\\nbelieve we can find a better representation without losing runtime\\nperformance.\\n- The APIs themselves can be significantly improved.\\n- MSGMODULES and MSGIDS should probably be some sort of a view that user\\ncan readily access without requiring access to the environment where it was\\nbuilt.\\n- Right now it only supports changing levels for DEBUG[1-5] and LOG\\nmessages. But that could be easily extended to cover INFO or NOTICE.\\n- The patch should probably have many more comments\\n- Finally, I don't know if better and more elegant ways exist to\\nautomatically assigning module/file/msgids. I couldn't think of any without\\nmaking excessive changes to all source files and hence did what I did. That\\ndoes not mean better ways don't exists.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 6 Sep 2016 14:56:24 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Override compile time log levels of specific messages/modules\"\n },\n {\n \"msg_contents\": \"On 6 Sep. 2016 17:28, \\\"Pavan Deolasee\\\" <pavan.deolasee@gmail.com> wrote:\\n>\\n\\n>\\n> The patch uses some preprocessing and scripting magic to assign distinct\\nidentifiers to each module (a subdir in the source code), to each file and\\nto each elog message. It then provides a set of functions by which an user\\ncan increase/decrease/set log levels for either individual messages or all\\nmessages within a source file or source module. The log levels can be\\nchanged only for specific backends or all current or future backends. If\\nyou configure with --enable-genmsgids switch, a MSGMODULES and MSGIDS file\\nis created in $srcdir, which can later be used to know ids assigned to\\nvarious modules/messages.\\n\\nI think it's worth looking at how Java handles logging. We can't achieve an\\nexact parallel in C as we don't really have a class hierarchy ... but we do\\nhave subsystems roughly grouped by file and directory structure.\\n\\nBeing able to promote/demote these or selective lower the log level\\nthreshold on a directory, file, function and line level would be\\nexceedingly handy. Pretty much all of that can be magic'd up from macro\\noutput so hopefully no postprocessing should be needed. (Though only gcc\\nhas _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)\\n\\n\\nOn 6 Sep. 2016 17:28, \\\"Pavan Deolasee\\\" <pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n> The patch uses some preprocessing and scripting magic to assign distinct identifiers to each module (a subdir in the source code), to each file and to each elog message. It then provides a set of functions by which an user can increase/decrease/set log levels for either individual messages or all messages within a source file or source module. The log levels can be changed only for specific backends or all current or future backends. If you configure with --enable-genmsgids switch, a MSGMODULES and MSGIDS file is created in $srcdir, which can later be used to know ids assigned to various modules/messages.\\nI think it's worth looking at how Java handles logging. We can't achieve an exact parallel in C as we don't really have a class hierarchy ... but we do have subsystems roughly grouped by file and directory structure.\\nBeing able to promote/demote these or selective lower the log level threshold on a directory, file, function and line level would be exceedingly handy. Pretty much all of that can be magic'd up from macro output so hopefully no postprocessing should be needed. (Though only gcc has _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)\",\n \"msg_date\": \"Tue, 6 Sep 2016 17:36:53 +0800\",\n \"msg_from\": \"Craig Ringer <craig.ringer@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Override compile time log levels of specific messages/modules\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com>\\nwrote:\\n\\n>\\n> I think it's worth looking at how Java handles logging. We can't achieve\\n> an exact parallel in C as we don't really have a class hierarchy ... but we\\n> do have subsystems roughly grouped by file and directory structure.\\n>\\n> Sure. In some large, popular enterprise softwares I've worked with many\\nyears ago, we used to define modules within each source file and then\\nmanually assign distinct integer IDs to each message and then provide\\nvarious utilities to turn on/off specific messages or range of messages\\nwithin a module.\\n\\n> Being able to promote/demote these or selective lower the log level\\n> threshold on a directory, file, function and line level would be\\n> exceedingly handy. Pretty much all of that can be magic'd up from macro\\n> output so hopefully no postprocessing should be needed. (Though only gcc\\n> has _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)\\n>\\nWell, __FUNCTION__ expands to function name and lookup based on string\\nidentifiers will always be costly, especially if you want to sprinkle the\\ncode with lot many debug messages. Same with __FILE__. I believe we need an\\nunique integer constant to make it a fast, O(1) lookup. I couldn't find any\\nother method to do that when I wrote the facility and hence did what I did.\\n\\nThanks,\\nPavan\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com> wrote:\\n\\nI think it's worth looking at how Java handles logging. We can't achieve an exact parallel in C as we don't really have a class hierarchy ... but we do have subsystems roughly grouped by file and directory structure.\\nSure. In some large, popular enterprise softwares I've worked with many years ago, we used to define modules within each source file and then manually assign distinct integer IDs to each message and then provide various utilities to turn on/off specific messages or range of messages within a module. Being able to promote/demote these or selective lower the log level threshold on a directory, file, function and line level would be exceedingly handy. Pretty much all of that can be magic'd up from macro output so hopefully no postprocessing should be needed. (Though only gcc has _FUNC_ or _FUNCTION_ I think so we'd have selective support there.)\\nWell, __FUNCTION__ expands to function name and lookup based on string identifiers will always be costly, especially if you want to sprinkle the code with lot many debug messages. Same with __FILE__. I believe we need an unique integer constant to make it a fast, O(1) lookup. I couldn't find any other method to do that when I wrote the facility and hence did what I did.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Tue, 6 Sep 2016 15:26:49 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Override compile time log levels of specific messages/modules\"\n },\n {\n \"msg_contents\": \"On 6 Sep. 2016 17:57, \\\"Pavan Deolasee\\\" <pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n>\\n> On Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com>\\nwrote:\\n>>\\n>>\\n>> I think it's worth looking at how Java handles logging. We can't achieve\\nan exact parallel in C as we don't really have a class hierarchy ... but we\\ndo have subsystems roughly grouped by file and directory structure.\\n>\\n> Sure. In some large, popular enterprise softwares I've worked with many\\nyears ago, we used to define modules within each source file and then\\nmanually assign distinct integer IDs to each message and then provide\\nvarious utilities to turn on/off specific messages or range of messages\\nwithin a module.\\n\\nYeah, there same has been discussed for Pg many times and firmly shot down\\neach time. I certainly see the argument against making specific elog calls\\npart of a sort of api people might expect to be stable ish. That's what we\\nhave ERRCODE / SQLSTATE for right? Concerns about backpatch pain were also\\nraised. Probably more. I'm not especially for or against it myself, just\\nsaying that based on past discussion such a proposal isn't likely to fly.\\n\\nI think something automatic that we clearly define as unstable and not to\\nbe relied upon would be preferable. Plus we already have much of the\\ninfrastructure in elog.c as used by errcontext etc.\\n\\n> Well, __FUNCTION__ expands to function name and lookup based on string\\nidentifiers will always be costly, especially if you want to sprinkle the\\ncode with lot many debug messages. Same with __FILE__. I believe we need an\\nunique integer constant to make it a fast, O(1) lookup. I couldn't find any\\nother method to do that when I wrote the facility and hence did what I did.\\n\\nYeah. High performance logging and filtering isnt easy. Looking at existing\\nC logging libraries with dynamic filtering might be informative. Though I\\ncan't imagine there being agreement to adopt one, this must be a reasonably\\nsolved problem...\\n\\n>\\n> Thanks,\\n> Pavan\\n> --\\n> Pavan Deolasee http://www.2ndQuadrant.com/\\n> PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn 6 Sep. 2016 17:57, \\\"Pavan Deolasee\\\" <pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n>\\n> On Tue, Sep 6, 2016 at 3:06 PM, Craig Ringer <craig.ringer@2ndquadrant.com> wrote:\\n>>\\n>>\\n>> I think it's worth looking at how Java handles logging. We can't achieve an exact parallel in C as we don't really have a class hierarchy ... but we do have subsystems roughly grouped by file and directory structure.\\n>\\n> Sure. In some large, popular enterprise softwares I've worked with many years ago, we used to define modules within each source file and then manually assign distinct integer IDs to each message and then provide various utilities to turn on/off specific messages or range of messages within a module.\\nYeah, there same has been discussed for Pg many times and firmly shot down each time. I certainly see the argument against making specific elog calls part of a sort of api people might expect to be stable ish. That's what we have ERRCODE / SQLSTATE for right? Concerns about backpatch pain were also raised. Probably more. I'm not especially for or against it myself, just saying that based on past discussion such a proposal isn't likely to fly.\\nI think something automatic that we clearly define as unstable and not to be relied upon would be preferable. Plus we already have much of the infrastructure in elog.c as used by errcontext etc.\\n> Well, __FUNCTION__ expands to function name and lookup based on string identifiers will always be costly, especially if you want to sprinkle the code with lot many debug messages. Same with __FILE__. I believe we need an unique integer constant to make it a fast, O(1) lookup. I couldn't find any other method to do that when I wrote the facility and hence did what I did.\\nYeah. High performance logging and filtering isnt easy. Looking at existing C logging libraries with dynamic filtering might be informative. Though I can't imagine there being agreement to adopt one, this must be a reasonably solved problem...\\n>\\n> Thanks,\\n> Pavan\\n> -- \\n> Pavan Deolasee http://www.2ndQuadrant.com/\\n> PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Tue, 6 Sep 2016 18:18:15 +0800\",\n \"msg_from\": \"Craig Ringer <craig.ringer@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Override compile time log levels of specific messages/modules\"\n },\n {\n \"msg_contents\": \"On 9/6/16 5:18 AM, Craig Ringer wrote:\\n> I think something automatic that we clearly define as unstable and not\\n> to be relied upon would be preferable. Plus we already have much of the\\n> infrastructure in elog.c as used by errcontext etc.\\n\\nActually, I wish this was a straight-up logging level feature, because I \\nneed it all the time when debugging complicated user-level code. \\nSpecifically, I wish there was a GUC that would alter \\n(client|log)_min_messages upon entering a specific function, either for \\njust that function or for anything that function subsequently called. \\nBonus points if you could also specify a regex that the message text had \\nto match.\\n\\nI realize that code-wise that's completely incompatible with what you're \\ndiscussing here, but I think the same API could be used (maybe as a \\ndifferent GUC).\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 10 Sep 2016 22:31:07 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Override compile time log levels of specific\\n messages/modules\"\n },\n {\n \"msg_contents\": \"On 11 Sep. 2016 11:31, \\\"Jim Nasby\\\" <Jim.Nasby@bluetreble.com> wrote:\\n\\n> Actually, I wish this was a straight-up logging level feature, because I\\nneed it all the time when debugging complicated user-level code.\\nSpecifically, I wish there was a GUC that would alter\\n(client|log)_min_messages upon entering a specific function, either for\\njust that function or for anything that function subsequently called.\\n\\nWe have that or close to it, but it's restricted for security. IIRC you\\ncan't SET log_min_messages as non superuser including as part of CREATE\\nFUNCTION ... SET. Presumably because lowering it would let the user hide\\nactivity admins expect to be recorded. Raising it would let them possibly\\nDoS via log spam - though that argument is rather undermined by the ability\\nto write plpgsql that does RAISE in a tight loop.\\n\\nI'd like to be able to let users make logging more detailed but not less,\\nso they can only SET it to something equal to or more detailed to what\\ntheir session has art the start. Should actually be pretty trivial to\\nimplement too.\\n\\nYou can then SET at session level, function level, SET LOCAL, etc. If you\\nwant to control it dynamically via GUC you add calls to your functions to\\ncheck a custom user GUC and SET log level accordingly. Using whatever logic\\nyou like.\\n\\n> Bonus points if you could also specify a regex that the message text had\\nto match.\\n>\\n\\nAn errfinish() hook would be nice for that.\\n\\n\\nOn 11 Sep. 2016 11:31, \\\"Jim Nasby\\\" <Jim.Nasby@bluetreble.com> wrote:\\n> Actually, I wish this was a straight-up logging level feature, because I need it all the time when debugging complicated user-level code. Specifically, I wish there was a GUC that would alter (client|log)_min_messages upon entering a specific function, either for just that function or for anything that function subsequently called.\\nWe have that or close to it, but it's restricted for security. IIRC you can't SET log_min_messages as non superuser including as part of CREATE FUNCTION ... SET. Presumably because lowering it would let the user hide activity admins expect to be recorded. Raising it would let them possibly DoS via log spam - though that argument is rather undermined by the ability to write plpgsql that does RAISE in a tight loop.\\nI'd like to be able to let users make logging more detailed but not less, so they can only SET it to something equal to or more detailed to what their session has art the start. Should actually be pretty trivial to implement too.\\nYou can then SET at session level, function level, SET LOCAL, etc. If you want to control it dynamically via GUC you add calls to your functions to check a custom user GUC and SET log level accordingly. Using whatever logic you like.\\n> Bonus points if you could also specify a regex that the message text had to match.\\n>\\nAn errfinish() hook would be nice for that.\",\n \"msg_date\": \"Sun, 11 Sep 2016 19:42:36 +0800\",\n \"msg_from\": \"Craig Ringer <craig.ringer@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Override compile time log levels of specific messages/modules\"\n }\n]","isConversational":false}}},{"rowIdx":43096,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"In vacuumlazy.c, VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL is described as\nbeing in ms on line 85, yet it is used on line 1759 in a call to\npg_usleep, so is treated as microseconds rather than milliseconds.\n\nAs a result, the timeout during lazy_truncate_heap() is actually only\n5ms long, not 5s long.\n\nSo this looks to me like a bug, patch attached, for back-patching to 9.1\nvacuum_lock_wait_ms.v1,patch\n\nObjections?\n\n\n\nNote that VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL is described as being in\nms and is actually in ms, so no change there.\n\n\nI'm also wondering why we don't use lock_timeout when the user sets it?\nNot a bug, but patch attached anyway.\nvacuum_truncate_use_lock_timeout.v1.patch\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 6 Sep 2016 11:30:57 +0100","msg_from":"Simon Riggs <simon@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Bug in VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"},{"msg_contents":"On Tue, Sep 6, 2016 at 4:00 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\n> I'm also wondering why we don't use lock_timeout when the user sets it?\n> Not a bug, but patch attached anyway.\n> vacuum_truncate_use_lock_timeout.v1.patch\n\nThis part seems fairly random. I don't think it makes sense to assume\nthat the timeout after which the user wants a lock acquisition request\nto error out is the same time that they want as the interval between\nretries. Those things seem fairly thoroughly unconnected, and this\nchange could fairly easily cause truncation problems for people who\nhave the lock timeout set to a relatively long time (e.g. 10 minutes).\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 17:40:18 +0530","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Bug in VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"},{"msg_contents":"On 6 September 2016 at 11:30, Simon Riggs <simon@2ndquadrant.com> wrote:\n> In vacuumlazy.c, VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL is described as\n> being in ms on line 85, yet it is used on line 1759 in a call to\n> pg_usleep, so is treated as microseconds rather than milliseconds.\n>\n> As a result, the timeout during lazy_truncate_heap() is actually only\n> 5ms long, not 5s long.\n>\n> So this looks to me like a bug, patch attached, for back-patching to 9.1\n> vacuum_lock_wait_ms.v1,patch\n>\n> Objections?\n\nI'm inclined to backpatch this for 9.6 only, unless I hear more.\n\nFor earlier releases this will suddenly make VACUUMs take 5 secs where\nthey used to take 50ms, which could be a big surprise for some people\nrunning database wide VACUUMs.\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 15:17:53 +0100","msg_from":"Simon Riggs <simon@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: Bug in VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"}],"string":"[\n {\n \"msg_contents\": \"In vacuumlazy.c, VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL is described as\\nbeing in ms on line 85, yet it is used on line 1759 in a call to\\npg_usleep, so is treated as microseconds rather than milliseconds.\\n\\nAs a result, the timeout during lazy_truncate_heap() is actually only\\n5ms long, not 5s long.\\n\\nSo this looks to me like a bug, patch attached, for back-patching to 9.1\\nvacuum_lock_wait_ms.v1,patch\\n\\nObjections?\\n\\n\\n\\nNote that VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL is described as being in\\nms and is actually in ms, so no change there.\\n\\n\\nI'm also wondering why we don't use lock_timeout when the user sets it?\\nNot a bug, but patch attached anyway.\\nvacuum_truncate_use_lock_timeout.v1.patch\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 6 Sep 2016 11:30:57 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Bug in VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 4:00 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> I'm also wondering why we don't use lock_timeout when the user sets it?\\n> Not a bug, but patch attached anyway.\\n> vacuum_truncate_use_lock_timeout.v1.patch\\n\\nThis part seems fairly random. I don't think it makes sense to assume\\nthat the timeout after which the user wants a lock acquisition request\\nto error out is the same time that they want as the interval between\\nretries. Those things seem fairly thoroughly unconnected, and this\\nchange could fairly easily cause truncation problems for people who\\nhave the lock timeout set to a relatively long time (e.g. 10 minutes).\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 17:40:18 +0530\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Bug in VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n },\n {\n \"msg_contents\": \"On 6 September 2016 at 11:30, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> In vacuumlazy.c, VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL is described as\\n> being in ms on line 85, yet it is used on line 1759 in a call to\\n> pg_usleep, so is treated as microseconds rather than milliseconds.\\n>\\n> As a result, the timeout during lazy_truncate_heap() is actually only\\n> 5ms long, not 5s long.\\n>\\n> So this looks to me like a bug, patch attached, for back-patching to 9.1\\n> vacuum_lock_wait_ms.v1,patch\\n>\\n> Objections?\\n\\nI'm inclined to backpatch this for 9.6 only, unless I hear more.\\n\\nFor earlier releases this will suddenly make VACUUMs take 5 secs where\\nthey used to take 50ms, which could be a big surprise for some people\\nrunning database wide VACUUMs.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 15:17:53 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Bug in VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n }\n]","isConversational":false}}},{"rowIdx":43097,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"While reviewing Peter's latest round of sorting patches, and trying to \nunderstand the new \"batch allocation\" mechanism, I started to wonder how \nuseful the pre-reading in the merge stage is in the first place.\n\nI'm talking about the code that reads a bunch of from each tape, loading \nthem into the memtuples array. That code was added by Tom Lane, back in \n1999:\n\ncommit cf627ab41ab9f6038a29ddd04dd0ff0ccdca714e\nAuthor: Tom Lane <tgl@sss.pgh.pa.us>\nDate: Sat Oct 30 17:27:15 1999 +0000\n\n Further performance improvements in sorting: reduce number of \ncomparisons\n during initial run formation by keeping both current run and next-run\n tuples in the same heap (yup, Knuth is smarter than I am). And, during\n merge passes, make use of available sort memory to load multiple tuples\n from any one input 'tape' at a time, thereby improving locality of\n access to the temp file.\n\nSo apparently there was a benefit back then, but is it still worthwhile? \nThe LogicalTape buffers one block at a time, anyway, how much gain are \nwe getting from parsing the tuples into SortTuple format in batches?\n\nI wrote a quick patch to test that, attached. It seems to improve \nperformance, at least in this small test case:\n\ncreate table lotsofints(i integer);\ninsert into lotsofints select random() * 1000000000.0 from \ngenerate_series(1, 10000000);\nvacuum freeze;\n\nselect count(*) FROM (select * from lotsofints order by i) t;\n\nOn my laptop, with default work_mem=4MB, that select takes 7.8 s on \nunpatched master, and 6.2 s with the attached patch.\n\nSo, at least in some cases, the pre-loading hurts. I think we should get \nrid of it. This patch probably needs some polishing: I replaced the \nbatch allocations with a simpler scheme with a buffer to hold just a \nsingle tuple for each tape, and that might need some more work to allow \ndownsizing those buffers if you have a few very large tuples in an \notherwise narrow table. And perhaps we should free and reallocate a \nsmaller memtuples array for the merging, now that we're not making use \nof the whole of it. And perhaps we should teach LogicalTape to use \nlarger buffers, if we can't rely on the OS to do the buffering for us. \nBut overall, this seems to make the code both simpler and faster.\n\nAm I missing something?\n\n- Heikki\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 6 Sep 2016 15:20:30 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Tuplesort merge pre-reading"},{"msg_contents":"On Tue, Sep 6, 2016 at 5:20 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> I wrote a quick patch to test that, attached. It seems to improve\n> performance, at least in this small test case:\n>\n> create table lotsofints(i integer);\n> insert into lotsofints select random() * 1000000000.0 from\n> generate_series(1, 10000000);\n> vacuum freeze;\n>\n> select count(*) FROM (select * from lotsofints order by i) t;\n>\n> On my laptop, with default work_mem=4MB, that select takes 7.8 s on\n> unpatched master, and 6.2 s with the attached patch.\n\nThe benefits have a lot to do with OS read-ahead, and efficient use of\nmemory bandwidth during the merge, where we want to access the caller\ntuples sequentially per tape (i.e. that's what the batch memory stuff\nadded -- it also made much better use of available memory). Note that\nI've been benchmarking the parallel CREATE INDEX patch on a server\nwith many HDDs, since sequential performance is mostly all that\nmatters. I think that in 1999, the preloading had a lot more to do\nwith logtape.c's ability to aggressively recycle blocks during merges,\nsuch that the total storage overhead does not exceed the original size\nof the caller tuples (plus what it calls \"trivial bookkeeping\noverhead\" IIRC). That's less important these days, but still matters\nsome (it's more of an issue when you can't complete the sort in one\npass, which is rare these days).\n\nOffhand, I would think that taken together this is very important. I'd\ncertainly want to see cases in the hundreds of megabytes or gigabytes\nof work_mem alongside your 4MB case, even just to be able to talk\ninformally about this. As you know, the default work_mem value is very\nconservative.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 12:08:33 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\n> Offhand, I would think that taken together this is very important. I'd\n> certainly want to see cases in the hundreds of megabytes or gigabytes\n> of work_mem alongside your 4MB case, even just to be able to talk\n> informally about this. As you know, the default work_mem value is very\n> conservative.\n\nIt looks like your benchmark relies on multiple passes, which can be\nmisleading. I bet it suffers some amount of problems from palloc()\nfragmentation. When very memory constrained, that can get really bad.\n\nNon-final merge passes (merges with more than one run -- real or dummy\n-- on any given tape) can have uneven numbers of runs on each tape.\nSo, tuplesort.c needs to be prepared to doll out memory among tapes\n*unevenly* there (same applies to memtuples \"slots\"). This is why\nbatch memory support is so hard for those cases (the fact that they're\nso rare anyway also puts me off it). As you know, I wrote a patch that\nadds batch memory support to cases that require randomAccess (final\noutput on a materialized tape), for their final merge. These final\nmerges happen to not be a final on-the-fly merge only due to this\nrandomAccess requirement from caller. It's possible to support these\ncases in the future, with that patch, only because I am safe to assume\nthat each run/tape is the same size there (well, the assumption is\nexactly as safe as it was for the 9.6 final on-the-fly merge, at\nleast).\n\nMy point about non-final merges is that you have to be very careful\nthat you're comparing apples to apples, memory accounting wise, when\nlooking into something like this. I'm not saying that you didn't, but\nit's worth considering.\n\nFWIW, I did try an increase in the buffer size in LogicalTape at one\ntime several months back, and so no benefit there (at least, with no\nother changes).\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 6 Sep 2016 12:26:54 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\n> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>> Offhand, I would think that taken together this is very important. I'd\n>> certainly want to see cases in the hundreds of megabytes or gigabytes\n>> of work_mem alongside your 4MB case, even just to be able to talk\n>> informally about this. As you know, the default work_mem value is very\n>> conservative.\n\nI spent some more time polishing this up, and also added some code to \nlogtape.c, to use larger read buffers, to compensate for the fact that \nwe don't do pre-reading from tuplesort.c anymore. That should trigger \nthe OS read-ahead, and make the I/O more sequential, like was the \npurpose of the old pre-reading code. But simpler. I haven't tested that \npart much yet, but I plan to run some tests on larger data sets that \ndon't fit in RAM, to make the I/O effects visible.\n\nI wrote a little testing toolkit, see third patch. I'm not proposing to \ncommit that, but that's what I used for testing. It creates four tables, \nabout 1GB in size each (it also creates smaller and larger tables, but I \nused the \"medium\" sized ones for these tests). Two of the tables contain \nintegers, and two contain text strings. Two of the tables are completely \nordered, two are in random order. To measure, it runs ORDER BY queries \non the tables, with different work_mem settings.\n\nAttached are the full results. In summary, these patches improve \nperformance in some of the tests, and are a wash on others. The patches \nhelp in particular in the randomly ordered cases, with up to 512 MB of \nwork_mem.\n\nFor example, with work_mem=256MB, which is enough to get a single merge \npass:\n\nwith patches:\n\nordered_ints: 7078 ms, 6910 ms, 6849 ms\nrandom_ints: 15639 ms, 15575 ms, 15625 ms\nordered_text: 11121 ms, 12318 ms, 10824 ms\nrandom_text: 53462 ms, 53420 ms, 52949 ms\n\nunpatched master:\n\nordered_ints: 6961 ms, 7040 ms, 7044 ms\nrandom_ints: 19205 ms, 18797 ms, 18955 ms\nordered_text: 11045 ms, 11377 ms, 11203 ms\nrandom_text: 57117 ms, 54489 ms, 54806 ms\n\n(The same queries were run three times in a row, that's what the three \nnumbers on each row mean. I.e. the differences between the numbers on \nsame row are noise)\n\n> It looks like your benchmark relies on multiple passes, which can be\n> misleading. I bet it suffers some amount of problems from palloc()\n> fragmentation. When very memory constrained, that can get really bad.\n>\n> Non-final merge passes (merges with more than one run -- real or dummy\n> -- on any given tape) can have uneven numbers of runs on each tape.\n> So, tuplesort.c needs to be prepared to doll out memory among tapes\n> *unevenly* there (same applies to memtuples \"slots\"). This is why\n> batch memory support is so hard for those cases (the fact that they're\n> so rare anyway also puts me off it). As you know, I wrote a patch that\n> adds batch memory support to cases that require randomAccess (final\n> output on a materialized tape), for their final merge. These final\n> merges happen to not be a final on-the-fly merge only due to this\n> randomAccess requirement from caller. It's possible to support these\n> cases in the future, with that patch, only because I am safe to assume\n> that each run/tape is the same size there (well, the assumption is\n> exactly as safe as it was for the 9.6 final on-the-fly merge, at\n> least).\n>\n> My point about non-final merges is that you have to be very careful\n> that you're comparing apples to apples, memory accounting wise, when\n> looking into something like this. I'm not saying that you didn't, but\n> it's worth considering.\n\nI'm not 100% sure I'm accounting for all the memory correctly. But I \ndidn't touch the way the initial quicksort works, nor the way the runs \nare built. And the merge passes don't actually need or benefit from a \nlot of memory, so I doubt it's very sensitive to that.\n\nIn this patch, the memory available for the read buffers is just divided \nevenly across maxTapes. The buffers for the tapes that are not currently \nactive are wasted. It could be made smarter, by freeing all the \ncurrently-unused buffers for tapes that are not active at the moment. \nMight do that later, but this is what I'm going to benchmark for now. I \ndon't think adding buffers is helpful beyond a certain point, so this is \nprobably good enough in practice. Although it would be nice to free the \nmemory we don't need earlier, in case there are other processes that \ncould make use of it.\n\n> FWIW, I did try an increase in the buffer size in LogicalTape at one\n> time several months back, and so no benefit there (at least, with no\n> other changes).\n\nYeah, unless you get rid of the pre-reading in tuplesort.c, you're just \ndouble-buffering.\n\n- Heikki\n\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 8 Sep 2016 21:59:41 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/08/2016 09:59 PM, Heikki Linnakangas wrote:\n> On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\n>> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>>> Offhand, I would think that taken together this is very important. I'd\n>>> certainly want to see cases in the hundreds of megabytes or gigabytes\n>>> of work_mem alongside your 4MB case, even just to be able to talk\n>>> informally about this. As you know, the default work_mem value is very\n>>> conservative.\n>\n> I spent some more time polishing this up, and also added some code to\n> logtape.c, to use larger read buffers, to compensate for the fact that\n> we don't do pre-reading from tuplesort.c anymore. That should trigger\n> the OS read-ahead, and make the I/O more sequential, like was the\n> purpose of the old pre-reading code. But simpler. I haven't tested that\n> part much yet, but I plan to run some tests on larger data sets that\n> don't fit in RAM, to make the I/O effects visible.\n\nOk, I ran a few tests with 20 GB tables. I thought this would show any \ndifferences in I/O behaviour, but in fact it was still completely CPU \nbound, like the tests on smaller tables I posted yesterday. I guess I \nneed to point temp_tablespaces to a USB drive or something. But here we go.\n\nIt looks like there was a regression when sorting random text, with 256 \nMB work_mem. I suspect that was a fluke - I only ran these tests once \nbecause they took so long. But I don't know for sure.\n\nClaudio, if you could also repeat the tests you ran on Peter's patch set \non the other thread, with these patches, that'd be nice. These patches \nare effectively a replacement for \n0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review \nwould be much appreciated too, of course.\n\nAttached are new versions. Compared to last set, they contain a few \ncomment fixes, and a change to the 2nd patch to not allocate tape \nbuffers for tapes that were completely unused.\n\n- Heikki\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 9 Sep 2016 14:13:49 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/09/2016 02:13 PM, Heikki Linnakangas wrote:\n> On 09/08/2016 09:59 PM, Heikki Linnakangas wrote:\n>> On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\n>>> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>>>> Offhand, I would think that taken together this is very important. I'd\n>>>> certainly want to see cases in the hundreds of megabytes or gigabytes\n>>>> of work_mem alongside your 4MB case, even just to be able to talk\n>>>> informally about this. As you know, the default work_mem value is very\n>>>> conservative.\n>>\n>> I spent some more time polishing this up, and also added some code to\n>> logtape.c, to use larger read buffers, to compensate for the fact that\n>> we don't do pre-reading from tuplesort.c anymore. That should trigger\n>> the OS read-ahead, and make the I/O more sequential, like was the\n>> purpose of the old pre-reading code. But simpler. I haven't tested that\n>> part much yet, but I plan to run some tests on larger data sets that\n>> don't fit in RAM, to make the I/O effects visible.\n>\n> Ok, I ran a few tests with 20 GB tables. I thought this would show any\n> differences in I/O behaviour, but in fact it was still completely CPU\n> bound, like the tests on smaller tables I posted yesterday. I guess I\n> need to point temp_tablespaces to a USB drive or something. But here we go.\n\nI took a different tact at demonstrating the I/O pattern effects. I \nadded some instrumentation code to logtape.c, that prints a line to a \nfile whenever it reads a block, with the block number. I ran the same \nquery with master and with these patches, and plotted the access pattern \nwith gnuplot.\n\nI'm happy with what it looks like. We are in fact getting a more \nsequential access pattern with these patches, because we're not \nexpanding the pre-read tuples into SortTuples. Keeping densely-packed \nblocks in memory, instead of SortTuples, allows caching more data overall.\n\nAttached is the patch I used to generate these traces, the gnuplot \nscript, and traces from I got from sorting a 1 GB table of random \nintegers, with work_mem=16MB.\n\nNote that in the big picture, what appear to be individual dots, are \nactually clusters of a bunch of dots. So the access pattern is a lot \nmore sequential than it looks like at first glance, with or without \nthese patches. The zoomed-in pictures show that. If you want to inspect \nthese in more detail, I recommend running gnuplot in interactive mode, \nso that you can zoom in and out easily.\n\nI'm happy with the amount of testing I've done now, and the results. \nDoes anyone want to throw out any more test cases where there might be a \nregression? If not, let's get these reviewed and committed.\n\n- Heikki\n\n\n\n\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 9 Sep 2016 14:55:40 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"(Resending with compressed files, to get below the message size limit of \nthe list)\n\nOn 09/09/2016 02:13 PM, Heikki Linnakangas wrote:\n> On 09/08/2016 09:59 PM, Heikki Linnakangas wrote:\n>> On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\n>>> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>>>> Offhand, I would think that taken together this is very important. I'd\n>>>> certainly want to see cases in the hundreds of megabytes or gigabytes\n>>>> of work_mem alongside your 4MB case, even just to be able to talk\n>>>> informally about this. As you know, the default work_mem value is very\n>>>> conservative.\n>>\n>> I spent some more time polishing this up, and also added some code to\n>> logtape.c, to use larger read buffers, to compensate for the fact that\n>> we don't do pre-reading from tuplesort.c anymore. That should trigger\n>> the OS read-ahead, and make the I/O more sequential, like was the\n>> purpose of the old pre-reading code. But simpler. I haven't tested that\n>> part much yet, but I plan to run some tests on larger data sets that\n>> don't fit in RAM, to make the I/O effects visible.\n>\n> Ok, I ran a few tests with 20 GB tables. I thought this would show any\n> differences in I/O behaviour, but in fact it was still completely CPU\n> bound, like the tests on smaller tables I posted yesterday. I guess I\n> need to point temp_tablespaces to a USB drive or something. But here we go.\n\nI took a different tact at demonstrating the I/O pattern effects. I \nadded some instrumentation code to logtape.c, that prints a line to a \nfile whenever it reads a block, with the block number. I ran the same \nquery with master and with these patches, and plotted the access pattern \nwith gnuplot.\n\nI'm happy with what it looks like. We are in fact getting a more \nsequential access pattern with these patches, because we're not \nexpanding the pre-read tuples into SortTuples. Keeping densely-packed \nblocks in memory, instead of SortTuples, allows caching more data overall.\n\nAttached is the patch I used to generate these traces, the gnuplot \nscript, and traces from I got from sorting a 1 GB table of random \nintegers, with work_mem=16MB.\n\nNote that in the big picture, what appear to be individual dots, are \nactually clusters of a bunch of dots. So the access pattern is a lot \nmore sequential than it looks like at first glance, with or without \nthese patches. The zoomed-in pictures show that. If you want to inspect \nthese in more detail, I recommend running gnuplot in interactive mode, \nso that you can zoom in and out easily.\n\nI'm happy with the amount of testing I've done now, and the results. \nDoes anyone want to throw out any more test cases where there might be a \nregression? If not, let's get these reviewed and committed.\n\n- Heikki\n\n\n\n\n\n\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 9 Sep 2016 15:01:06 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Sep 9, 2016 at 1:01 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> I'm happy with what it looks like. We are in fact getting a more sequential\n> access pattern with these patches, because we're not expanding the pre-read\n> tuples into SortTuples. Keeping densely-packed blocks in memory, instead of\n> SortTuples, allows caching more data overall.\n\n\nWow, this is really cool. We should do something like this for query\nexecution too.\n\nI still didn't follow exactly why removing the prefetching allows more\nsequential i/o. I thought the whole point of prefetching was to reduce\nthe random i/o from switching tapes.\n\n-- \ngreg\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 9 Sep 2016 13:25:29 +0100","msg_from":"Greg Stark <stark@mit.edu>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/09/2016 03:25 PM, Greg Stark wrote:\n> On Fri, Sep 9, 2016 at 1:01 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> I'm happy with what it looks like. We are in fact getting a more sequential\n>> access pattern with these patches, because we're not expanding the pre-read\n>> tuples into SortTuples. Keeping densely-packed blocks in memory, instead of\n>> SortTuples, allows caching more data overall.\n>\n>\n> Wow, this is really cool. We should do something like this for query\n> execution too.\n>\n> I still didn't follow exactly why removing the prefetching allows more\n> sequential i/o. I thought the whole point of prefetching was to reduce\n> the random i/o from switching tapes.\n\nThe first patch removed prefetching, but the second patch re-introduced \nit, in a different form. The prefetching is now done in logtape.c, by \nreading multiple pages at a time. The on-tape representation of tuples \nis more compact than having them in memory as SortTuples, so you can fit \nmore data in memory overall, which makes the access pattern more sequential.\n\nThere's one difference between these approaches that I didn't point out \nearlier: We used to prefetch tuples from each *run*, and stopped \npre-reading when we reached the end of the run. Now that we're doing the \nprefetching as raw tape blocks, we don't stop at run boundaries. I don't \nthink that makes any big difference one way or another, but I thought \nI'd mention it.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 9 Sep 2016 15:48:46 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Sep 9, 2016 at 4:55 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> I'm happy with the amount of testing I've done now, and the results. Does\n> anyone want to throw out any more test cases where there might be a\n> regression? If not, let's get these reviewed and committed.\n\nI'll try to look at this properly tomorrow. Currently still working\naway at creating a new revision of my sorting patchset. Obviously this\nis interesting, but it raises certain questions for the parallel\nCREATE INDEX patch in particular that I'd like to get straight, aside\nfrom everything else.\n\nI've been using an AWS d2.4xlarge instance for testing all my recent\nsort patches, with 16 vCPUs, 122 GiB RAM, 12 x 2 TB disks. It worked\nwell to emphasize I/O throughput and parallelism over latency. I'd\nlike to investigate how this pre-reading stuff does there. I recall\nthat for one very large case, it took a full minute to do just the\nfirst round of preloading during the leader's final merge (this was\nwith something like 50GB of maintenance_work_mem). So, it will be\ninteresting.\n\nBTW, noticed a typo here:\n\n> + * track memory usage of indivitual tuples.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 9 Sep 2016 09:50:22 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Sep 9, 2016 at 5:25 AM, Greg Stark <stark@mit.edu> wrote:\n> Wow, this is really cool. We should do something like this for query\n> execution too.\n\nWe should certainly do this for tuplestore.c, too. I've been meaning\nto adopt it to use batch memory. I did look at it briefly, and recall\nthat it was surprisingly awkward because a surprisingly large number\nof callers want to have memory that they can manage independently of\nthe lifetime of their tuplestore.\n\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 9 Sep 2016 10:22:38 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>\n> Claudio, if you could also repeat the tests you ran on Peter's patch set on\n> the other thread, with these patches, that'd be nice. These patches are\n> effectively a replacement for\n> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\n> would be much appreciated too, of course.\n>\n> Attached are new versions. Compared to last set, they contain a few comment\n> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\n> that were completely unused.\n\n\nWill do so\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 9 Sep 2016 21:51:08 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>\n>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\n>> the other thread, with these patches, that'd be nice. These patches are\n>> effectively a replacement for\n>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\n>> would be much appreciated too, of course.\n>>\n>> Attached are new versions. Compared to last set, they contain a few comment\n>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\n>> that were completely unused.\n>\n>\n> Will do so\n\nIt seems both 1 and 1+2 break make check.\n\nDid I misunderstand something? I'm applying the first patch of Peter's\nseries (cap number of tapes), then your first one (remove prefetch)\nand second one (use larger read buffers).\n\nPeter's patch needs some rebasing on top of those but nothing major.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 9 Sep 2016 22:21:58 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/10/2016 04:21 AM, Claudio Freire wrote:\n> On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>>\n>>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\n>>> the other thread, with these patches, that'd be nice. These patches are\n>>> effectively a replacement for\n>>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\n>>> would be much appreciated too, of course.\n>>>\n>>> Attached are new versions. Compared to last set, they contain a few comment\n>>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\n>>> that were completely unused.\n>>\n>> Will do so\n\nThanks!\n\n> It seems both 1 and 1+2 break make check.\n\nOh. Works for me. What's the failure you're getting?\n\n> Did I misunderstand something? I'm applying the first patch of Peter's\n> series (cap number of tapes), then your first one (remove prefetch)\n> and second one (use larger read buffers).\n\nYes. I have been testing without Peter's first patch, with just the two \npatches I posted. But it should work together (and does, I just tested) \nwith that one as well.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 10 Sep 2016 10:04:02 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Sat, Sep 10, 2016 at 12:04 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Did I misunderstand something? I'm applying the first patch of Peter's\n>> series (cap number of tapes), then your first one (remove prefetch)\n>> and second one (use larger read buffers).\n>\n>\n> Yes. I have been testing without Peter's first patch, with just the two\n> patches I posted. But it should work together (and does, I just tested) with\n> that one as well.\n\nYou're going to need to rebase, since the root displace patch is based\non top of my patch 0002-*, not Heikki's alternative. But, that should\nbe very straightforward.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 10 Sep 2016 12:09:41 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"Here's a new version of these patches, rebased over current master. I \nsquashed the two patches into one, there's not much point to keep them \nseparate.\n\n- Heikki\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Sun, 11 Sep 2016 18:47:21 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Sun, Sep 11, 2016 at 8:47 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Here's a new version of these patches, rebased over current master. I\n> squashed the two patches into one, there's not much point to keep them\n> separate.\n\nI think I have my head fully around this now. For some reason, I\ninitially thought that this patch was a great deal more radical than\nit actually is. (Like Greg, I somehow initially thought that you were\nrejecting the idea of batch memory in general, and somehow (over)\nleveraging the filesystem cache. I think I misunderstood your remarks\nwhen we talked on IM about it early on.)\n\nI don't know what the difference is between accessing 10 pages\nrandomly, and accessing a random set of 10 single pages sequentially,\nin close succession. As Tom would say, that's above my pay grade. I\nsuppose it comes down to how close \"close\" actually is (but in any\ncase, it's all very fudged).\n\nI mention this because I think that cost_sort() should be updated to\nconsider sequential I/O the norm, alongside this patch of yours (your\npatch strengthens the argument [1] for that general idea). The reason\nthat this new approach produces more sequential I/O, apart from the\nsimple fact that you effectively have much more memory available and\nso fewer rounds of preloading, is that the indirection block stuff can\nmake I/O less sequential in order to support eager reclamation of\nspace. For example, maybe there is interleaving of blocks as logtape.c\nmanages to reclaim blocks in the event of multiple merge steps. I care\nabout that second factor a lot more now than I would have a year ago,\nwhen a final on-the-fly merge generally avoids multiple passes (and\nassociated logtape.c block fragmentation), because parallel CREATE\nINDEX is usually affected by that (workers will often want to do their\nown merge ahead of the leader's final merge), and because I want to\ncap the number of tapes used, which will make multiple passes a bit\nmore common in practice.\n\nI was always suspicious of the fact that memtuples is so large during\nmerging, and had a vague plan to fix that (although I was the one\nresponsible for growing memtuples even more for the merge in 9.6, that\nwas just because under the status quo of having many memtuples during\nthe merge, the size of memtuples should at least be in balance with\nremaining memory for caller tuples -- it wasn't an endorsement of the\nstatus quo). However, it never occurred to me to do that by pushing\nbatch memory into the head of logtape.c, which now seems like an\nexcellent idea.\n\nTo summarize my understanding of this patch: If it wasn't for my work\non parallel CREATE INDEX, I would consider this patch to give us only\na moderate improvement to user-visible performance, since it doesn't\nreally help memory rich cases very much (cases that are not likely to\nhave much random I/O anyway). In that universe, I'd be more\nappreciative of the patch as a simplifying exercise, since while\nrefactoring. It's nice to get a boost for more memory constrained\ncases, it's not a huge win. However, that's not the universe we live\nin -- I *am* working on parallel CREATE INDEX, of course. And so, I\nreally am very excited about this patch, because it really helps with\nthe particular challenges I have there, even though it's fair to\nassume that we have a reasonable amount of memory available when\nparallelism is used. If workers are going to do their own merges, as\nthey often will, then multiple merge pass cases become far more\nimportant, and any additional I/O is a real concern, *especially*\nadditional random I/O (say from logtape.c fragmentation). The patch\ndirectly addresses that, which is great. Your patch, alongside my\njust-committed patch concerning how we maintain the heap invariant,\ntogether attack the merge bottleneck from two different directions:\nthey address I/O costs, and CPU costs, respectively.\n\nOther things I noticed:\n\n* You should probably point out that typically, access to batch memory\nwill still be sequential, despite your block-based scheme. The\npreloading will now more or less make that the normal case. Any\nfragmentation will now be essentially in memory, not on disk, which is\na big win.\n\n* I think that logtape.c header comments are needed for this. Maybe\nthat's where you should point out that memory access is largely\nsequential. But it's surely true that logtape.c needs to take\nresponsibility for being the place where the vast majority of memory\nis allocated during merging.\n\n* i think you should move \"bool *mergeactive; /* active input run\nsource? */\" within Tuplesortstate to be next to the other batch memory\nstuff. No point in having separate merge and batch \"sections\" there\nanymore.\n\n* You didn't carry over my 0002-* batch memory patch modifications to\ncomments, even though you should have in a few cases. There remains\nsome references in comments to batch memory, as a thing exclusively\nusable by final on-the-fly merges. That's not true anymore -- it's\nusable by final merges, too. For example, readtup_alloc() still\nreferences the final on-the-fly merge.\n\n* You also fail to take credit in the commit message for making batch\nmemory usable when returning caller tuples to callers that happen to\nrequest \"randomAccess\" (So, I guess the aforementioned comments above\nroutines like readtup_alloc() shouldn't even refer to merging, unless\nit's to say that non-final merges are not supported due to their\nunusual requirements). My patch didn't go that far (I only addressed\nthe final merge itself, not the subsequent access to tuples when\nreading from that materialized final output tape by TSS_SORTEDONTAPE\ncase). But, that's actually really useful for randomAccess callers,\nabove and beyond what I proposed (which in any case was mostly written\nwith parallel workers in mind, which never do TSS_SORTEDONTAPE\nprocessing).\n\n* Furthermore, readtup_alloc() will not just be called in WRITETUP()\nroutines -- please update comments.\n\n* There is a very subtle issue here:\n\n> + /*\n> + * We no longer need a large memtuples array, only one slot per tape. Shrink\n> + * it, to make the memory available for other use. We only need one slot per\n> + * tape.\n> + */\n> + pfree(state->memtuples);\n> + FREEMEM(state, state->memtupsize * sizeof(SortTuple));\n> + state->memtupsize = state->maxTapes;\n> + state->memtuples = (SortTuple *) palloc(state->maxTapes * sizeof(SortTuple));\n> + USEMEM(state, state->memtupsize * sizeof(SortTuple));\n\nThe FREEMEM() call needs to count the chunk overhead in both cases. In\nshort, I think you need to copy the GetMemoryChunkSpace() stuff that\nyou see within grow_memtuples().\n\n* Whitespace issue here:\n\n> @@ -2334,7 +2349,8 @@ inittapes(Tuplesortstate *state)\n> #endif\n>\n> /*\n> - * Decrease availMem to reflect the space needed for tape buffers; but\n> + * Decrease availMem to reflect the space needed for tape buffers, when\n> + * writing the initial runs; but\n> * don't decrease it to the point that we have no room for tuples. (That\n> * case is only likely to occur if sorting pass-by-value Datums; in all\n> * other scenarios the memtuples[] array is unlikely to occupy more than\n> @@ -2359,14 +2375,6 @@ inittapes(Tuplesortstate *state)\n> state->tapeset = LogicalTapeSetCreate(maxTapes);\n\n* I think that you need to comment on why state->tuplecontext is not\nused for batch memory now. It is still useful, for multiple merge\npasses, but the situation has notably changed for it.\n\n* Doesn't this code need to call MemoryContextAllocHuge() rather than palloc()?:\n\n> @@ -709,18 +765,19 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)\n> Assert(lt->frozen);\n> datablocknum = ltsRewindFrozenIndirectBlock(lts, lt->indirect);\n> }\n> +\n> + /* Allocate a read buffer */\n> + if (lt->buffer)\n> + pfree(lt->buffer);\n> + lt->buffer = palloc(lt->read_buffer_size);\n> + lt->buffer_size = lt->read_buffer_size;\n\n* Typo:\n\n> +\n> + /*\n> + * from this point on, we no longer use the usemem()/lackmem() mechanism to\n> + * track memory usage of indivitual tuples.\n> + */\n> + state->batchused = true;\n\n* Please make this use the \".., + 1023\" natural rounding trick that is\nused in the similar traces that are removed:\n\n> +#ifdef TRACE_SORT\n> + if (trace_sort)\n> + elog(LOG, \"using %d kB of memory for read buffers in %d tapes, %d kB per tape\",\n> + (int) (state->availMem / 1024), maxTapes, (int) (per_tape * BLCKSZ) / 1024);\n> +#endif\n\n* It couldn't hurt to make this code paranoid about LACKMEM() becoming\ntrue, which will cause havoc (we saw this recently in 9.6; a patch of\nmine to fix that just went in):\n\n> + /*\n> + * Use all the spare memory we have available for read buffers. Divide it\n> + * memory evenly among all the tapes.\n> + */\n> + avail_blocks = state->availMem / BLCKSZ;\n> + per_tape = avail_blocks / maxTapes;\n> + cutoff = avail_blocks % maxTapes;\n> + if (per_tape == 0)\n> + {\n> + per_tape = 1;\n> + cutoff = 0;\n> + }\n> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\n> + {\n> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\n> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\n> + }\n\nIn other words, we really don't want availMem to become < 0, since\nit's int64, but a derived value is passed to\nLogicalTapeAssignReadBufferSize() as an argument of type \"Size\". Now,\nif LACKMEM() did happen it would be a bug anyway, but I recommend\ndefensive code also be added. Per grow_memtuples(), \"We need to be\nsure that we do not cause LACKMEM to become true, else the space\nmanagement algorithm will go nuts\". Let's be sure that we get that\nright, since, as we saw recently, especially since grow_memtuples()\nwill not actually have the chance to save us here (if there is a bug\nalong these lines, let's at least make the right \"can't happen error\"\ncomplaint to user when it pops up).\n\n* It looks like your patch makes us less eager about freeing per-tape\nbatch memory, now held as preload buffer space within logtape.c.\n\nISTM that there should be some way to have the \"tape exhausted\" code\npath within tuplesort_gettuple_common() (as well as the similar spot\nwithin mergeonerun()) instruct logtape.c that we're done with that\ntape. In other words, when mergeprereadone() (now renamed to\nmergereadnext()) detects the tape is exhausted, it should have\nlogtape.c free its huge tape buffer immediately. Think about cases\nwhere input is presorted, and earlier tapes can be freed quite early\non. It's worth keeping that around, (you removed the old way that this\nhappened, through mergebatchfreetape()).\n\nThat's all I have right now. I like the direction this is going in,\nbut I think this needs more polishing.\n\n[1] https://www.postgresql.org/message-id/CAM3SWZQLP6e=1si1NcQjYft7R-VYpprrf_i59tZOZX5m7VFK-w@mail.gmail.com\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 11 Sep 2016 15:13:55 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\n> * Please make this use the \".., + 1023\" natural rounding trick that is\n> used in the similar traces that are removed:\n>\n>> +#ifdef TRACE_SORT\n>> + if (trace_sort)\n>> + elog(LOG, \"using %d kB of memory for read buffers in %d tapes, %d kB per tape\",\n>> + (int) (state->availMem / 1024), maxTapes, (int) (per_tape * BLCKSZ) / 1024);\n>> +#endif\n\nAlso, please remove the int cast, and use INT64_FORMAT. Again, this\nshould match existing trace_sort traces concerning batch memory.\n\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 11 Sep 2016 15:34:17 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\n> * Doesn't this code need to call MemoryContextAllocHuge() rather than palloc()?:\n>\n>> @@ -709,18 +765,19 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)\n>> Assert(lt->frozen);\n>> datablocknum = ltsRewindFrozenIndirectBlock(lts, lt->indirect);\n>> }\n>> +\n>> + /* Allocate a read buffer */\n>> + if (lt->buffer)\n>> + pfree(lt->buffer);\n>> + lt->buffer = palloc(lt->read_buffer_size);\n>> + lt->buffer_size = lt->read_buffer_size;\n\nOf course, when you do that you're going to have to make the new\n\"buffer_size\" and \"read_buffer_size\" fields of type \"Size\" (or,\npossibly, \"int64\", to match tuplesort.c's own buffer sizing variables\never since Noah added MaxAllocSizeHuge). Ditto for the existing \"pos\"\nand \"nbytes\" fields next to \"buffer_size\" within the struct\nLogicalTape, I think. ISTM that logtape.c blocknums can remain of type\n\"long\", though, since that reflects an existing hardly-relevant\nlimitation that you're not making any worse.\n\nMore generally, I think you also need to explain in comments why there\nis a \"read_buffer_size\" field in addition to the \"buffer_size\" field.\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 11 Sep 2016 15:59:18 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\n>> + {\n>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\n>> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\n>> + }\n\nSpotted another issue with this code just now. Shouldn't it be based\non state->tapeRange? You don't want the destTape to get memory, since\nyou don't use batch memory for tapes that are written to (and final\non-the-fly merges don't use their destTape at all).\n\n(Looks again...)\n\nWait, you're using a local variable maxTapes here, which potentially\ndiffers from state->maxTapes:\n\n> + /*\n> + * If we had fewer runs than tapes, refund buffers for tapes that were never\n> + * allocated.\n> + */\n> + maxTapes = state->maxTapes;\n> + if (state->currentRun < maxTapes)\n> + {\n> + FREEMEM(state, (maxTapes - state->currentRun) * TAPE_BUFFER_OVERHEAD);\n> + maxTapes = state->currentRun;\n> + }\n\nI find this confusing, and think it's probably buggy. I don't think\nyou should have a local variable called maxTapes that you modify at\nall, since state->maxTapes is supposed to not change once established.\nYou can't use state->currentRun like that, either, I think, because\nit's the high watermark number of runs (quicksorted runs), not runs\nafter any particular merge phase, where we end up with fewer runs as\nthey're merged (we must also consider dummy runs to get this) -- we\nwant something like activeTapes. cf. the code you removed for the\nbeginmerge() finalMergeBatch case. Of course, activeTapes will vary if\nthere are multiple merge passes, which suggests all this code really\nhas no business being in mergeruns() (it should instead be in\nbeginmerge(), or code that beginmerge() reliably calls).\n\nImmediately afterwards, you do this:\n\n> + /* Initialize the merge tuple buffer arena. */\n> + state->batchMemoryBegin = palloc((maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\n> + state->batchMemoryEnd = state->batchMemoryBegin + (maxTapes + 1) * MERGETUPLEBUFFER_SIZE;\n> + state->freeBufferHead = (MergeTupleBuffer *) state->batchMemoryBegin;\n> + USEMEM(state, (maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\n\nThe fact that you size the buffer based on \"maxTapes + 1\" also\nsuggests a problem. I think that the code looks like this because it\nmust instruct logtape.c that the destTape tape requires some buffer\n(iff there is to be a non-final merge). Is that right? I hope that you\ndon't give the typically unused destTape tape a full share of batch\nmemory all the time (the same applies to any other\ninactive-at-final-merge tapes).\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 11 Sep 2016 16:39:54 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 12/09/16 10:13, Peter Geoghegan wrote:\n> On Sun, Sep 11, 2016 at 8:47 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n[...]\n> I don't know what the difference is between accessing 10 pages\n> randomly, and accessing a random set of 10 single pages sequentially,\n> in close succession. As Tom would say, that's above my pay grade. I\n> suppose it comes down to how close \"close\" actually is (but in any\n> case, it's all very fudged).\n\nIf you select ten pages at random and sort them, then consecutive reads \nof the sorted list are more likely to access pages in the same block or \nclosely adjacent (is my understanding).\n\neg\n\nblocks: XXXX XXXX XXXX XXXX XXXX\npages: 0 1 2 3 4 5 6 7 8 9\n\nif the ten 'random pages' were selected in the random order:\n6 1 7 8 4 2 9 3 0\nConsecutive reads would always read new blocks, but the sorted list \nwould have blocks read sequentially.\n\nIn practice, it would be rarely this simple. However, if any of the \nrandom pages where in the same block, then that block would only need to \nbe fetched once - similarly if 2 of the random pages where in \nconsecutive blocks, then the two blocks would be logically adjacent \n(which means they are likely to be physically close together, but not \nguaranteed!).\n\n[...]\n\n\nCheers,\nGavin\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 12 Sep 2016 12:16:23 +1200","msg_from":"Gavin Flower <GavinFlower@archidevsys.co.nz>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 12/09/16 12:16, Gavin Flower wrote:\n[...]\n> two blocks would be logically adjacent (which means they are likely \n> to be physically close together, but not guaranteed!).\n>\n[...]\n\nActual disk layouts are quite complicated, the above is an over \nsimplification, but the message is still valid.\n\nThere are various tricks of disc layout ( & low level handling) that can \nbe used to minimise the time taken to read 2 blocks that are logically \nadjacent. I had to know this stuff for discs that MainFrame computers \nused in the 1980's - modern disk systems are way more complicated, but \nthe conclusions are still valid.\n\nI am extremely glad that I no longer have to concern myself with \nunderstanding the precise low stuff on discs these days - there is no \nlonger a one-to-one correspondence of what the O/S thinks is a disk \nblock, with how the data is physically recorded on the disc.\n\n\nCheers,\nGavin\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 12 Sep 2016 12:34:48 +1200","msg_from":"Gavin Flower <GavinFlower@archidevsys.co.nz>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Sun, Sep 11, 2016 at 12:47 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Here's a new version of these patches, rebased over current master. I\n> squashed the two patches into one, there's not much point to keep them\n> separate.\n\n\nI don't know what was up with the other ones, but this one works fine.\n\nBenchmarking now.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 12 Sep 2016 12:02:53 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Mon, Sep 12, 2016 at 12:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Sun, Sep 11, 2016 at 12:47 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Here's a new version of these patches, rebased over current master. I\n>> squashed the two patches into one, there's not much point to keep them\n>> separate.\n>\n>\n> I don't know what was up with the other ones, but this one works fine.\n>\n> Benchmarking now.\n\n\nI spoke too soon, git AM had failed and I didn't notice.\n\nregression.diffs attached\n\nBuilt with\n\n./configure --enable-debug --enable-cassert && make clean && make -j7\n&& make check\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 12 Sep 2016 12:47:28 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Mon, Sep 12, 2016 at 8:47 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> I spoke too soon, git AM had failed and I didn't notice.\n\nI wrote the regression test that causes Postgres to crash with the\npatch applied. It tests, among other things, that CLUSTER tuples are\nfixed-up by a routine like the current MOVETUP(), which is removed in\nHeikki's patch. (There was a 9.6 bug where CLUSTER was broken due to\nthat.)\n\nIt shouldn't be too difficult for Heikki to fix this.\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 12 Sep 2016 08:51:59 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/12/2016 06:47 PM, Claudio Freire wrote:\n> On Mon, Sep 12, 2016 at 12:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Sun, Sep 11, 2016 at 12:47 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>> Here's a new version of these patches, rebased over current master. I\n>>> squashed the two patches into one, there's not much point to keep them\n>>> separate.\n>>\n>> I don't know what was up with the other ones, but this one works fine.\n>>\n>> Benchmarking now.\n>\n> I spoke too soon, git AM had failed and I didn't notice.\n>\n> regression.diffs attached\n>\n> Built with\n>\n> ./configure --enable-debug --enable-cassert && make clean && make -j7\n> && make check\n\nAh, of course! I had been building without assertions, as I was doing \nperformance testing. With --enable-cassert, it failed for me as well \n(and there was even a compiler warning pointing out one of the issues). \nSorry about that.\n\nHere's a fixed version. I'll go through Peter's comments and address \nthose, but I don't think there was anything there that should affect \nperformance much, so I think you can proceed with your benchmarking with \nthis version. (You'll also need to turn off assertions for that!)\n\n- Heikki\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 12 Sep 2016 22:07:40 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Mon, Sep 12, 2016 at 12:07 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Here's a fixed version. I'll go through Peter's comments and address those,\n> but I don't think there was anything there that should affect performance\n> much, so I think you can proceed with your benchmarking with this version.\n> (You'll also need to turn off assertions for that!)\n\nI agree that it's unlikely that addressing any of my feedback will\nresult in any major change to performance.\n\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 12 Sep 2016 12:09:22 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"Addressed all your comments one way or another, new patch attached. \nComments on some specific points below:\n\nOn 09/12/2016 01:13 AM, Peter Geoghegan wrote:\n> Other things I noticed:\n>\n> * You should probably point out that typically, access to batch memory\n> will still be sequential, despite your block-based scheme. The\n> preloading will now more or less make that the normal case. Any\n> fragmentation will now be essentially in memory, not on disk, which is\n> a big win.\n\nThat's not true, the \"buffers\" in batch memory are not accessed \nsequentially. When we pull the next tuple from a tape, we store it in \nthe next free buffer. Usually, that buffer was used to hold the previous \ntuple that was returned from gettuple(), and was just added to the free \nlist.\n\nIt's still quite cache-friendly, though, because we only need a small \nnumber of slots (one for each tape).\n\n> * i think you should move \"bool *mergeactive; /* active input run\n> source? */\" within Tuplesortstate to be next to the other batch memory\n> stuff. No point in having separate merge and batch \"sections\" there\n> anymore.\n\nHmm. I think I prefer to keep the memory management stuff in a separate \nsection. While it's true that it's currently only used during merging, \nit's not hard to imagine using it when building the initial runs, for \nexample. Except for replacement selection, the pattern for building the \nruns is: add a bunch of tuples, sort, flush them out. It would be \nstraightforward to use one large chunk of memory to hold all the tuples. \nI'm not going to do that now, but I think keeping the memory management \nstuff separate from merge-related state makes sense.\n\n> * I think that you need to comment on why state->tuplecontext is not\n> used for batch memory now. It is still useful, for multiple merge\n> passes, but the situation has notably changed for it.\n\nHmm. We don't actually use it after the initial runs at all anymore. I \nadded a call to destroy it in mergeruns().\n\nNow that we use the batch memory buffers for allocations < 1 kB (I \npulled that number out of a hat, BTW), and we only need one allocation \nper tape (plus one), there's not much risk of fragmentation.\n\n> On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>> * Doesn't this code need to call MemoryContextAllocHuge() rather than palloc()?:\n>>\n>>> @@ -709,18 +765,19 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)\n>>> Assert(lt->frozen);\n>>> datablocknum = ltsRewindFrozenIndirectBlock(lts, lt->indirect);\n>>> }\n>>> +\n>>> + /* Allocate a read buffer */\n>>> + if (lt->buffer)\n>>> + pfree(lt->buffer);\n>>> + lt->buffer = palloc(lt->read_buffer_size);\n>>> + lt->buffer_size = lt->read_buffer_size;\n>\n> Of course, when you do that you're going to have to make the new\n> \"buffer_size\" and \"read_buffer_size\" fields of type \"Size\" (or,\n> possibly, \"int64\", to match tuplesort.c's own buffer sizing variables\n> ever since Noah added MaxAllocSizeHuge). Ditto for the existing \"pos\"\n> and \"nbytes\" fields next to \"buffer_size\" within the struct\n> LogicalTape, I think. ISTM that logtape.c blocknums can remain of type\n> \"long\", though, since that reflects an existing hardly-relevant\n> limitation that you're not making any worse.\n\nTrue. I fixed that by putting a MaxAllocSize cap on the buffer size \ninstead. I doubt that doing > 1 GB of read-ahead of a single tape will \ndo any good.\n\nI wonder if we should actually have a smaller cap there. Even 1 GB seems \nexcessive. Might be better to start the merging sooner, rather than wait \nfor the read of 1 GB to complete. The point of the OS readahead is that \nthe OS will do that for us, in the background. And other processes might \nhave better use for the memory anyway.\n\n> * It couldn't hurt to make this code paranoid about LACKMEM() becoming\n> true, which will cause havoc (we saw this recently in 9.6; a patch of\n> mine to fix that just went in):\n>\n>> + /*\n>> + * Use all the spare memory we have available for read buffers. Divide it\n>> + * memory evenly among all the tapes.\n>> + */\n>> + avail_blocks = state->availMem / BLCKSZ;\n>> + per_tape = avail_blocks / maxTapes;\n>> + cutoff = avail_blocks % maxTapes;\n>> + if (per_tape == 0)\n>> + {\n>> + per_tape = 1;\n>> + cutoff = 0;\n>> + }\n>> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\n>> + {\n>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\n>> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\n>> + }\n>\n> In other words, we really don't want availMem to become < 0, since\n> it's int64, but a derived value is passed to\n> LogicalTapeAssignReadBufferSize() as an argument of type \"Size\". Now,\n> if LACKMEM() did happen it would be a bug anyway, but I recommend\n> defensive code also be added. Per grow_memtuples(), \"We need to be\n> sure that we do not cause LACKMEM to become true, else the space\n> management algorithm will go nuts\". Let's be sure that we get that\n> right, since, as we saw recently, especially since grow_memtuples()\n> will not actually have the chance to save us here (if there is a bug\n> along these lines, let's at least make the right \"can't happen error\"\n> complaint to user when it pops up).\n\nHmm. We don't really need the availMem accounting at all, after we have \nstarted merging. There is nothing we can do to free memory if we run \nout, and we use fairly little memory anyway. But yes, better safe than \nsorry. I tried to clarify the comments on that.\n\n> * It looks like your patch makes us less eager about freeing per-tape\n> batch memory, now held as preload buffer space within logtape.c.\n>\n> ISTM that there should be some way to have the \"tape exhausted\" code\n> path within tuplesort_gettuple_common() (as well as the similar spot\n> within mergeonerun()) instruct logtape.c that we're done with that\n> tape. In other words, when mergeprereadone() (now renamed to\n> mergereadnext()) detects the tape is exhausted, it should have\n> logtape.c free its huge tape buffer immediately. Think about cases\n> where input is presorted, and earlier tapes can be freed quite early\n> on. It's worth keeping that around, (you removed the old way that this\n> happened, through mergebatchfreetape()).\n\nOK. I solved that by calling LogicalTapeRewind(), when we're done \nreading a tape. Rewinding a tape has the side-effect of freeing the \nbuffer. I was going to put that into mergereadnext(), but it turns out \nthat it's tricky to figure out if there are any more runs on the same \ntape, because we have the \"actual\" tape number there, but the tp_runs is \nindexed by \"logical\" tape number. So I put the rewind calls at the end \nof mergeruns(), and in TSS_FINALMERGE processing, instead. It means that \nwe don't free the buffers quite as early as we could, but I think this \nis good enough.\n\n> On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>>> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\n>>> + {\n>>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\n>>> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\n>>> + }\n>\n> Spotted another issue with this code just now. Shouldn't it be based\n> on state->tapeRange? You don't want the destTape to get memory, since\n> you don't use batch memory for tapes that are written to (and final\n> on-the-fly merges don't use their destTape at all).\n\nlogtape.c will only actually allocate the memory when reading.\n\n> (Looks again...)\n>\n> Wait, you're using a local variable maxTapes here, which potentially\n> differs from state->maxTapes:\n>\n>> + /*\n>> + * If we had fewer runs than tapes, refund buffers for tapes that were never\n>> + * allocated.\n>> + */\n>> + maxTapes = state->maxTapes;\n>> + if (state->currentRun < maxTapes)\n>> + {\n>> + FREEMEM(state, (maxTapes - state->currentRun) * TAPE_BUFFER_OVERHEAD);\n>> + maxTapes = state->currentRun;\n>> + }\n>\n> I find this confusing, and think it's probably buggy. I don't think\n> you should have a local variable called maxTapes that you modify at\n> all, since state->maxTapes is supposed to not change once established.\n\nI changed that so that it does actually change state->maxTapes. I \nconsidered having a separate numTapes field, that can be smaller than \nmaxTapes, but we don't need the original maxTapes value after that point \nanymore, so it would've been just pro forma to track them separately. I \nhope the comment now explains that better.\n\n> You can't use state->currentRun like that, either, I think, because\n> it's the high watermark number of runs (quicksorted runs), not runs\n> after any particular merge phase, where we end up with fewer runs as\n> they're merged (we must also consider dummy runs to get this) -- we\n> want something like activeTapes. cf. the code you removed for the\n> beginmerge() finalMergeBatch case. Of course, activeTapes will vary if\n> there are multiple merge passes, which suggests all this code really\n> has no business being in mergeruns() (it should instead be in\n> beginmerge(), or code that beginmerge() reliably calls).\n\nHmm, yes, using currentRun here is wrong. It needs to be \"currentRun + \n1\", because we need one more tape than there are runs, to hold the output.\n\nNote that I'm not re-allocating the read buffers depending on which \ntapes are used in the current merge pass. I'm just dividing up the \nmemory among all tapes. Now that the pre-reading is done in logtape.c, \nwhen we reach the end of a run on a tape, we will already have data from \nthe next run on the same tape in the read buffer.\n\n> Immediately afterwards, you do this:\n>\n>> + /* Initialize the merge tuple buffer arena. */\n>> + state->batchMemoryBegin = palloc((maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\n>> + state->batchMemoryEnd = state->batchMemoryBegin + (maxTapes + 1) * MERGETUPLEBUFFER_SIZE;\n>> + state->freeBufferHead = (MergeTupleBuffer *) state->batchMemoryBegin;\n>> + USEMEM(state, (maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\n>\n> The fact that you size the buffer based on \"maxTapes + 1\" also\n> suggests a problem. I think that the code looks like this because it\n> must instruct logtape.c that the destTape tape requires some buffer\n> (iff there is to be a non-final merge). Is that right? I hope that you\n> don't give the typically unused destTape tape a full share of batch\n> memory all the time (the same applies to any other\n> inactive-at-final-merge tapes).\n\nAh, no, the \"+ 1\" comes from the need to hold the tuple that we last \nreturned to the caller in tuplesort_gettuple, until the next call. See \nlastReturnedTuple. I tried to clarify the comments on that.\n\nThanks for the thorough review! Let me know how this looks now.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 14 Sep 2016 20:43:36 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Addressed all your comments one way or another, new patch attached. Comments\n> on some specific points below:\n\nCool. My response here is written under time pressure, which is not\nideal. I think it's still useful, though.\n\n>> * You should probably point out that typically, access to batch memory\n>> will still be sequential, despite your block-based scheme.\n\n> That's not true, the \"buffers\" in batch memory are not accessed\n> sequentially. When we pull the next tuple from a tape, we store it in the\n> next free buffer. Usually, that buffer was used to hold the previous tuple\n> that was returned from gettuple(), and was just added to the free list.\n>\n> It's still quite cache-friendly, though, because we only need a small number\n> of slots (one for each tape).\n\nThat's kind of what I meant, I think -- it's more or less sequential.\nEspecially in the common case where there is only one merge pass.\n\n> True. I fixed that by putting a MaxAllocSize cap on the buffer size instead.\n> I doubt that doing > 1 GB of read-ahead of a single tape will do any good.\n\nYou may well be right about that, but ideally that could be verified.\nI think that the tuplesort is entitled to have whatever memory the\nuser makes available, unless that's almost certainly useless. It\ndoesn't seem like our job to judge that it's always wrong to use extra\nmemory with only a small expected benefit. If it's actually a\nmicroscopic expected benefit, or just as often negative to the sort\noperation's performance, then I'd say it's okay to cap it at\nMaxAllocSize. But it's not obvious to me that this is true; not yet,\nanyway.\n\n> Hmm. We don't really need the availMem accounting at all, after we have\n> started merging. There is nothing we can do to free memory if we run out,\n> and we use fairly little memory anyway. But yes, better safe than sorry. I\n> tried to clarify the comments on that.\n\nIt is true that we don't really care about the accounting at all. But,\nthe same applies to the existing grow_memtuples() case at the\nbeginning of merging. The point is, we *do* care about availMem, this\none last time. We must at least produce a sane (i.e. >= 0) number in\nany calculation. (I think you understand this already -- just saying.)\n\n> OK. I solved that by calling LogicalTapeRewind(), when we're done reading a\n> tape. Rewinding a tape has the side-effect of freeing the buffer. I was\n> going to put that into mergereadnext(), but it turns out that it's tricky to\n> figure out if there are any more runs on the same tape, because we have the\n> \"actual\" tape number there, but the tp_runs is indexed by \"logical\" tape\n> number. So I put the rewind calls at the end of mergeruns(), and in\n> TSS_FINALMERGE processing, instead. It means that we don't free the buffers\n> quite as early as we could, but I think this is good enough.\n\nThat seems adequate.\n\n>> Spotted another issue with this code just now. Shouldn't it be based\n>> on state->tapeRange? You don't want the destTape to get memory, since\n>> you don't use batch memory for tapes that are written to (and final\n>> on-the-fly merges don't use their destTape at all).\n\n>> Wait, you're using a local variable maxTapes here, which potentially\n>> differs from state->maxTapes:\n\n> I changed that so that it does actually change state->maxTapes. I considered\n> having a separate numTapes field, that can be smaller than maxTapes, but we\n> don't need the original maxTapes value after that point anymore, so it\n> would've been just pro forma to track them separately. I hope the comment\n> now explains that better.\n\nI still don't get why you're doing all of this within mergeruns() (the\nbeginning of when we start merging -- we merge all quicksorted runs),\nrather than within beginmerge() (the beginning of one particular merge\npass, of which there are potentially more than one). As runs are\nmerged in a non-final merge pass, fewer tapes will remain active for\nthe next merge pass. It doesn't do to do all that up-front when we\nhave multiple merge passes, which will happen from time to time.\n\nCorrect me if I'm wrong, but I think that you're more skeptical of the\nneed for polyphase merge than I am. I at least see no reason to not\nkeep it around. I also think it has some value. It doesn't make this\noptimization any harder, really.\n\n> Hmm, yes, using currentRun here is wrong. It needs to be \"currentRun + 1\",\n> because we need one more tape than there are runs, to hold the output.\n\nAs I said, I think it should be the number of active tapes, as you see\ntoday within beginmerge() + mergebatch(). Why not do it that way? If\nyou don't get the distinction, see my remarks below on final merges\nalways using batch memory, even when there are to be multiple merge\npasses (no reason to add that restriction here). More generally, I\nreally don't want to mess with the long standing definition of\nmaxTapes and things like that, because I see no advantage.\n\n> Ah, no, the \"+ 1\" comes from the need to hold the tuple that we last\n> returned to the caller in tuplesort_gettuple, until the next call. See\n> lastReturnedTuple. I tried to clarify the comments on that.\n\nI see. I don't think that you need to do any of that. Just have the\nsizing be based on an even share among activeTapes on final merges\n(not necessarily final on-the-fly merges, per my 0002-* patch --\nyou've done that here, it looks like). However, It looks like you're\ndoing the wrong thing by only having the check at the top of\nbeginmerge() -- \"if (state->Level == 1)\". You're not going to use\nbatch memory for the final merge just because there happened to be\nmultiple merges, that way. Sure, you shouldn't be using batch memory\nfor non-final merges (due to their need for an uneven amount of memory\nper active tape), which you're not doing, but the mere fact that you\nhad a non-final merge should not affect the final merge at all. Which\nis the kind of thing I'm concerned about when I talk about\nbeginmerge() being the right place for all that new code (not\nmergeruns()). Even if you can make it work, it fits a lot better to\nput it in beginmerge() -- that's the existing flow of things, which\nshould be preserved. I don't think you need to examine \"state->Level\"\nor \"state->currentRun\" at all.\n\nDid you do it this way to make the \"replacement selection best case\"\nstuff within mergeruns() catch on, so it does the right thing during\nits TSS_SORTEDONTAPE processing?\n\nThanks\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 12:12:43 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/15/2016 10:12 PM, Peter Geoghegan wrote:\n> On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>> Spotted another issue with this code just now. Shouldn't it be based\n>>> on state->tapeRange? You don't want the destTape to get memory, since\n>>> you don't use batch memory for tapes that are written to (and final\n>>> on-the-fly merges don't use their destTape at all).\n>\n>>> Wait, you're using a local variable maxTapes here, which potentially\n>>> differs from state->maxTapes:\n>\n>> I changed that so that it does actually change state->maxTapes. I considered\n>> having a separate numTapes field, that can be smaller than maxTapes, but we\n>> don't need the original maxTapes value after that point anymore, so it\n>> would've been just pro forma to track them separately. I hope the comment\n>> now explains that better.\n>\n> I still don't get why you're doing all of this within mergeruns() (the\n> beginning of when we start merging -- we merge all quicksorted runs),\n> rather than within beginmerge() (the beginning of one particular merge\n> pass, of which there are potentially more than one). As runs are\n> merged in a non-final merge pass, fewer tapes will remain active for\n> the next merge pass. It doesn't do to do all that up-front when we\n> have multiple merge passes, which will happen from time to time.\n\nNow that the pre-reading is done in logtape.c, it doesn't stop at a run \nboundary. For example, when we read the last 1 MB of the first run on a \ntape, and we're using a 10 MB read buffer, we will merrily also read the \nfirst 9 MB from the next run. You cannot un-read that data, even if the \ntape is inactive in the next merge pass.\n\nI don't think it makes much difference in practice, because most merge \npasses use all, or almost all, of the available tapes. BTW, I think the \npolyphase algorithm prefers to do all the merges that don't use all \ntapes upfront, so that the last final merge always uses all the tapes. \nI'm not 100% sure about that, but that's my understanding of the \nalgorithm, and that's what I've seen in my testing.\n\n> Correct me if I'm wrong, but I think that you're more skeptical of the\n> need for polyphase merge than I am. I at least see no reason to not\n> keep it around. I also think it has some value. It doesn't make this\n> optimization any harder, really.\n\nWe certainly still need multi-pass merges.\n\nBTW, does a 1-way merge make any sense? I was surprised to see this in \nthe log, even without this patch:\n\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \nBY i) t;\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \nBY i) t;\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \nBY i) t;\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \nBY i) t;\nLOG: finished 3-way merge step: CPU 0.62s/7.23u sec elapsed 8.44 sec\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \nBY i) t;\nLOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.44 sec\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \nBY i) t;\nLOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.45 sec\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \nBY i) t;\n\n- Heikki\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 23:51:19 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 15, 2016 at 1:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> I still don't get why you're doing all of this within mergeruns() (the\n>> beginning of when we start merging -- we merge all quicksorted runs),\n>> rather than within beginmerge() (the beginning of one particular merge\n>> pass, of which there are potentially more than one). As runs are\n>> merged in a non-final merge pass, fewer tapes will remain active for\n>> the next merge pass. It doesn't do to do all that up-front when we\n>> have multiple merge passes, which will happen from time to time.\n>\n>\n> Now that the pre-reading is done in logtape.c, it doesn't stop at a run\n> boundary. For example, when we read the last 1 MB of the first run on a\n> tape, and we're using a 10 MB read buffer, we will merrily also read the\n> first 9 MB from the next run. You cannot un-read that data, even if the tape\n> is inactive in the next merge pass.\n\nI'm not sure that I like that approach. At the very least, it seems to\nnot be a good fit with the existing structure of things. I need to\nthink about it some more, and study how that plays out in practice.\n\n> BTW, does a 1-way merge make any sense?\n\nNot really, no, but it's something that I've seen plenty of times.\n\nThis is seen when runs are distributed such that mergeonerun() only\nfinds one real run on all active tapes, with all other active tapes\nhaving only dummy runs. In general, dummy runs are \"logically merged\"\n(decremented) in preference to any real runs on the same tape (that's\nthe reason why they exist), so you end up with what we call a \"1-way\nmerge\" when you see one real one on one active tape only. You never\nsee something like \"0-way merge\" within trace_sort output, though,\nbecause that case is optimized to be almost a no-op.\n\nIt's almost a no-op because when it happens then mergeruns() knows to\nitself directly decrement the number of dummy runs once for each\nactive tape, making that \"logical merge\" completed with only that\nsimple change in metadata (that is, the \"merge\" completes by just\ndecrementing dummy run counts -- no actual call to mergeonerun()).\n\nWe could optimize away \"1-way merge\" cases, perhaps, so that tuples\ndon't have to be spilt out one at a time (there could perhaps instead\nbe just some localized change to metadata, a bit like the all-dummy\ncase). That doesn't seem worth bothering with, especially with this\nnew approach of yours. I prefer to avoid special cases like that.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 14:07:25 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 15, 2016 at 1:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> BTW, does a 1-way merge make any sense? I was surprised to see this in the\n> log, even without this patch:\n>\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\n> i) t;\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\n> i) t;\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\n> i) t;\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\n> i) t;\n> LOG: finished 3-way merge step: CPU 0.62s/7.23u sec elapsed 8.44 sec\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\n> i) t;\n> LOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.44 sec\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\n> i) t;\n> LOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.45 sec\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\n> i) t;\n\nAnother thing that I think it worth pointing out here is that the\nnumber of merge passes shown is excessive, practically speaking. I\nsuggested that we have something like checkpoint_warning for this last\nyear, which Greg Stark eventually got behind, but Robert Haas didn't\nseem to like. Maybe this idea should be revisited. What do you think?\n\nThere is no neat explanation for why it's considered excessive to\ncheckpoint every 10 seconds, but not every 2 minutes. But, we warn\nabout the former case by default, and not the latter. It's hard to\nknow exactly where to draw the line, but that isn't a great reason to\nnot do it (maybe one extra merge pass is a good threshold -- that's\nwhat I suggested once). I think that other database systems similarly\nsurface multiple merge passes. It's just inefficient to ever do\nmultiple merge passes, even if you're very frugal with memory.\nCertainly, it's almost impossible to defend doing 3+ passes these\ndays.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Sep 2016 14:26:01 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Addressed all your comments one way or another, new patch attached.\n\nSo, it's clear that this isn't ready today. As I mentioned, I'm going\naway for a week now. I ask that you hold off on committing this until\nI return, and have a better opportunity to review the performance\ncharacteristics of this latest revision, for one thing.\n\nThanks\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 17 Sep 2016 09:27:44 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/17/2016 07:27 PM, Peter Geoghegan wrote:\n> On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Addressed all your comments one way or another, new patch attached.\n>\n> So, it's clear that this isn't ready today. As I mentioned, I'm going\n> away for a week now. I ask that you hold off on committing this until\n> I return, and have a better opportunity to review the performance\n> characteristics of this latest revision, for one thing.\n\nOk. I'll probably read through it myself once more some time next week, \nand also have a first look at your actual parallel sorting patch. Have a \ngood trip!\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 17 Sep 2016 19:41:22 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Sat, Sep 17, 2016 at 9:41 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Ok. I'll probably read through it myself once more some time next week, and\n> also have a first look at your actual parallel sorting patch. Have a good\n> trip!\n\nThanks! It will be good to get away for a while.\n\nI'd be delighted to recruit you to work on the parallel CREATE INDEX\npatch. I've already explained how I think this preread patch of yours\nworks well with parallel tuplesort (as proposed) in particular. To\nreiterate: while what you've come up with here is technically an\nindependent improvement to merging, it's much more valuable in the\noverall context of parallel sort, where disproportionate wall clock\ntime is spent merging, and where multiple passes are the norm (one\npass in each worker, plus one big final pass in the leader process\nalone -- logtape.c fragmentation becomes a real issue). The situation\nis actually similar to the original batch memory preloading patch that\nwent into 9.6 (which your new patch supersedes), and the subsequently\ncommitted quicksort for external sort patch (which my new patch\nextends to work in parallel).\n\nBecause I think of your preload patch as a part of the overall\nparallel CREATE INDEX effort, if that was the limit of your\ninvolvement then I'd still think it fair to credit you as my\nco-author. I hope it isn't the limit of your involvement, though,\nbecause it seems likely that the final result will be better still if\nyou get involved with the big patch that formally introduces parallel\nCREATE INDEX.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 17 Sep 2016 11:49:42 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>\n>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\n>> the other thread, with these patches, that'd be nice. These patches are\n>> effectively a replacement for\n>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\n>> would be much appreciated too, of course.\n>>\n>> Attached are new versions. Compared to last set, they contain a few comment\n>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\n>> that were completely unused.\n>\n>\n> Will do so\n\nWell, here they are, the results.\n\nODS format only (unless you've got issues opening the ODS).\n\nThe results seem all over the map. Some regressions seem significant\n(both in the amount of performance lost and their significance, since\nall 4 runs show a similar regression). The worst being \"CREATE INDEX\nix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\" with 4GB\nwork_mem, which should be an in-memory sort, which makes it odd.\n\nI will re-run it overnight just in case to confirm the outcome.\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 20 Sep 2016 15:34:29 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Tue, Sep 20, 2016 at 3:34 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n> On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>>\n>>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\n>>> the other thread, with these patches, that'd be nice. These patches are\n>>> effectively a replacement for\n>>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\n>>> would be much appreciated too, of course.\n>>>\n>>> Attached are new versions. Compared to last set, they contain a few comment\n>>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\n>>> that were completely unused.\n>>\n>>\n>> Will do so\n>\n> Well, here they are, the results.\n>\n> ODS format only (unless you've got issues opening the ODS).\n>\n> The results seem all over the map. Some regressions seem significant\n> (both in the amount of performance lost and their significance, since\n> all 4 runs show a similar regression). The worst being \"CREATE INDEX\n> ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\" with 4GB\n> work_mem, which should be an in-memory sort, which makes it odd.\n>\n> I will re-run it overnight just in case to confirm the outcome.\n\nA new run for \"patched\" gives better results, it seems it was some\nkind of glitch in the run (maybe some cron decided to do something\nwhile running those queries).\n\nAttached\n\nIn essence, it doesn't look like it's harmfully affecting CPU\nefficiency. Results seem neutral on the CPU front.\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 21 Sep 2016 21:40:23 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/22/2016 03:40 AM, Claudio Freire wrote:\n> On Tue, Sep 20, 2016 at 3:34 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\n>> The results seem all over the map. Some regressions seem significant\n>> (both in the amount of performance lost and their significance, since\n>> all 4 runs show a similar regression). The worst being \"CREATE INDEX\n>> ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\" with 4GB\n>> work_mem, which should be an in-memory sort, which makes it odd.\n>>\n>> I will re-run it overnight just in case to confirm the outcome.\n>\n> A new run for \"patched\" gives better results, it seems it was some\n> kind of glitch in the run (maybe some cron decided to do something\n> while running those queries).\n>\n> Attached\n>\n> In essence, it doesn't look like it's harmfully affecting CPU\n> efficiency. Results seem neutral on the CPU front.\n\nLooking at the spreadsheet, there is a 40% slowdown in the \"slow\" \n\"CREATE INDEX ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\" \ntest with 4GB of work_mem. I can't reproduce that on my laptop, though. \nGot any clue what's going on there?\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 22 Sep 2016 10:17:06 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 22, 2016 at 4:17 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> On 09/22/2016 03:40 AM, Claudio Freire wrote:\n>>\n>> On Tue, Sep 20, 2016 at 3:34 PM, Claudio Freire <klaussfreire@gmail.com>\n>> wrote:\n>>>\n>>> The results seem all over the map. Some regressions seem significant\n>>> (both in the amount of performance lost and their significance, since\n>>> all 4 runs show a similar regression). The worst being \"CREATE INDEX\n>>> ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\" with 4GB\n>>> work_mem, which should be an in-memory sort, which makes it odd.\n>>>\n>>> I will re-run it overnight just in case to confirm the outcome.\n>>\n>>\n>> A new run for \"patched\" gives better results, it seems it was some\n>> kind of glitch in the run (maybe some cron decided to do something\n>> while running those queries).\n>>\n>> Attached\n>>\n>> In essence, it doesn't look like it's harmfully affecting CPU\n>> efficiency. Results seem neutral on the CPU front.\n>\n>\n> Looking at the spreadsheet, there is a 40% slowdown in the \"slow\" \"CREATE\n> INDEX ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\" test with 4GB\n> of work_mem. I can't reproduce that on my laptop, though. Got any clue\n> what's going on there?\n\nIt's not present in other runs, so I think it's a fluke the\nspreadsheet isn't filtering out. Especially considering that one\nshould be a fully in-memory fast sort and thus unaffected by the\ncurrent patch (z and z2 being integers, IIRC, most comparisons should\nbe about comparing the first columns and thus rarely involve the big\nstrings).\n\nI'll try to confirm that's the case though.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 22 Sep 2016 05:00:18 -0300","msg_from":"Claudio Freire <klaussfreire@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 15, 2016 at 9:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> I still don't get why you're doing all of this within mergeruns() (the\n>> beginning of when we start merging -- we merge all quicksorted runs),\n>> rather than within beginmerge() (the beginning of one particular merge\n>> pass, of which there are potentially more than one). As runs are\n>> merged in a non-final merge pass, fewer tapes will remain active for\n>> the next merge pass. It doesn't do to do all that up-front when we\n>> have multiple merge passes, which will happen from time to time.\n>\n>\n> Now that the pre-reading is done in logtape.c, it doesn't stop at a run\n> boundary. For example, when we read the last 1 MB of the first run on a\n> tape, and we're using a 10 MB read buffer, we will merrily also read the\n> first 9 MB from the next run. You cannot un-read that data, even if the tape\n> is inactive in the next merge pass.\n\nI've had a chance to think about this some more. I did a flying review\nof the same revision that I talk about here, but realized some more\nthings. First, I will do a recap.\n\n> I don't think it makes much difference in practice, because most merge\n> passes use all, or almost all, of the available tapes. BTW, I think the\n> polyphase algorithm prefers to do all the merges that don't use all tapes\n> upfront, so that the last final merge always uses all the tapes. I'm not\n> 100% sure about that, but that's my understanding of the algorithm, and\n> that's what I've seen in my testing.\n\nNot sure that I understand. I agree that each merge pass tends to use\nroughly the same number of tapes, but the distribution of real runs on\ntapes is quite unbalanced in earlier merge passes (due to dummy runs).\nIt looks like you're always using batch memory, even for non-final\nmerges. Won't that fail to be in balance much of the time because of\nthe lopsided distribution of runs? Tapes have an uneven amount of real\ndata in earlier merge passes.\n\nFWIW, polyphase merge actually doesn't distribute runs based on the\nFibonacci sequence (at least in Postgres). It uses a generalization of\nthe Fibonacci numbers [1] -- *which* generalization varies according\nto merge order/maxTapes. IIRC, with Knuth's P == 6 (i.e. merge order\n== 6), it's the \"hexanacci\" sequence.\n\nThe following code is from your latest version, posted on 2016-09-14,\nwithin the high-level mergeruns() function (the function that takes\nquicksorted runs, and produces final output following 1 or more merge\npasses):\n\n> + usedBlocks = 0;\n> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\n> + {\n> + int64 numBlocks = blocksPerTape + (tapenum < remainder ? 1 : 0);\n> +\n> + if (numBlocks > MaxAllocSize / BLCKSZ)\n> + numBlocks = MaxAllocSize / BLCKSZ;\n> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\n> + numBlocks * BLCKSZ);\n> + usedBlocks += numBlocks;\n> + }\n> + USEMEM(state, usedBlocks * BLCKSZ);\n\nI'm basically repeating myself here, but: I think it's incorrect that\nLogicalTapeAssignReadBufferSize() is called so indiscriminately (more\ngenerally, it is questionable that it is called in such a high level\nroutine, rather than the start of a specific merge pass -- I said so a\ncouple of times already).\n\nIt's weird that you change the meaning of maxTapes by reassigning in\nadvance of iterating through maxTapes like this. I should point out\nagain that the master branch mergebatch() function does roughly the\nsame thing as you're doing here as follows:\n\nstatic void\nmergebatch(Tuplesortstate *state, int64 spacePerTape)\n{\n int srcTape;\n\n Assert(state->activeTapes > 0);\n Assert(state->tuples);\n\n /*\n * For the purposes of tuplesort's memory accounting, the batch allocation\n * is special, and regular memory accounting through USEMEM() calls is\n * abandoned (see mergeprereadone()).\n */\n for (srcTape = 0; srcTape < state->maxTapes; srcTape++)\n {\n char *mergetuples;\n\n if (!state->mergeactive[srcTape])\n continue;\n\n /* Allocate buffer for each active tape */\n mergetuples = MemoryContextAllocHuge(state->tuplecontext,\n spacePerTape);\n\n /* Initialize state for tape */\n state->mergetuples[srcTape] = mergetuples;\n state->mergecurrent[srcTape] = mergetuples;\n state->mergetail[srcTape] = mergetuples;\n state->mergeoverflow[srcTape] = NULL;\n }\n\n state->batchUsed = true;\n state->spacePerTape = spacePerTape;\n}\n\nNotably, this function:\n\n* Works without altering the meaning of maxTapes. state->maxTapes is\nKnuth's T, which is established very early and doesn't change with\npolyphase merge (same applies to state->tapeRange). What does change\nacross merge passes is the number of *active* tapes. I don't think\nit's necessary to change that in any way. I find it very confusing.\n(Also, that you're using state->currentRun here at all seems bad, for\nmore or less the same reason -- that's the number of quicksorted\nruns.)\n\n* Does allocation for the final merge (that's the only point that it's\ncalled), and so is not based on the number of active tapes that happen\nto be in play when merging begins at a high level (i.e., when\nmergeruns() is first called). Many tapes will be totally inactive by\nthe final merge, so this seems completely necessary for multiple merge\npass cases.\n\nEnd of recap. Here is some new information:\n\nI was previously confused on this last point, because I thought that\nlogtape.c might be able to do something smart to recycle memory that\nis bound per-tape by calls to LogicalTapeAssignReadBufferSize() in\nyour patch. But it doesn't: all the recycling stuff only happens for\nthe much smaller buffers that are juggled and reused to pass tuples\nback to caller within tuplesort_gettuple_common(), etc -- not the\nlogtape.c managed buffers. So, AFAICT there is no justification that I\ncan see for not adopting these notable properties of mergebatch() for\nsome analogous point in this patch. Actually, you should probably not\nget rid of mergebatch(), but instead call\nLogicalTapeAssignReadBufferSize() there. This change would mean that\nthe big per-tape memory allocations would happen in the same place as\nbefore -- you'd just be asking logtape.c to do it for you, instead of\nallocating directly.\n\nPerhaps the practical consequences of not doing something closer to\nmergebatch() are debatable, but I suspect that there is little point\nin actually debating it. I think you might as well do it that way. No?\n\n[1] http://mathworld.wolfram.com/Fibonaccin-StepNumber.html\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 28 Sep 2016 16:05:41 +0100","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/28/2016 06:05 PM, Peter Geoghegan wrote:\n> On Thu, Sep 15, 2016 at 9:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> I don't think it makes much difference in practice, because most merge\n>> passes use all, or almost all, of the available tapes. BTW, I think the\n>> polyphase algorithm prefers to do all the merges that don't use all tapes\n>> upfront, so that the last final merge always uses all the tapes. I'm not\n>> 100% sure about that, but that's my understanding of the algorithm, and\n>> that's what I've seen in my testing.\n>\n> Not sure that I understand. I agree that each merge pass tends to use\n> roughly the same number of tapes, but the distribution of real runs on\n> tapes is quite unbalanced in earlier merge passes (due to dummy runs).\n> It looks like you're always using batch memory, even for non-final\n> merges. Won't that fail to be in balance much of the time because of\n> the lopsided distribution of runs? Tapes have an uneven amount of real\n> data in earlier merge passes.\n\nHow does the distribution of the runs on the tapes matter?\n\n>> + usedBlocks = 0;\n>> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\n>> + {\n>> + int64 numBlocks = blocksPerTape + (tapenum < remainder ? 1 : 0);\n>> +\n>> + if (numBlocks > MaxAllocSize / BLCKSZ)\n>> + numBlocks = MaxAllocSize / BLCKSZ;\n>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\n>> + numBlocks * BLCKSZ);\n>> + usedBlocks += numBlocks;\n>> + }\n>> + USEMEM(state, usedBlocks * BLCKSZ);\n>\n> I'm basically repeating myself here, but: I think it's incorrect that\n> LogicalTapeAssignReadBufferSize() is called so indiscriminately (more\n> generally, it is questionable that it is called in such a high level\n> routine, rather than the start of a specific merge pass -- I said so a\n> couple of times already).\n\nYou can't release the tape buffer at the end of a pass, because the \nbuffer of a tape will already be filled with data from the next run on \nthe same tape.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 28 Sep 2016 19:04:48 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Wed, Sep 28, 2016 at 5:04 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Not sure that I understand. I agree that each merge pass tends to use\n>> roughly the same number of tapes, but the distribution of real runs on\n>> tapes is quite unbalanced in earlier merge passes (due to dummy runs).\n>> It looks like you're always using batch memory, even for non-final\n>> merges. Won't that fail to be in balance much of the time because of\n>> the lopsided distribution of runs? Tapes have an uneven amount of real\n>> data in earlier merge passes.\n>\n>\n> How does the distribution of the runs on the tapes matter?\n\nThe exact details are not really relevant to this discussion (I think\nit's confusing that we simply say \"Target Fibonacci run counts\",\nFWIW), but the simple fact that it can be quite uneven is.\n\nThis is why I never pursued batch memory for non-final merges. Isn't\nthat what you're doing here? You're pretty much always setting\n\"state->batchUsed = true\".\n\n>> I'm basically repeating myself here, but: I think it's incorrect that\n>> LogicalTapeAssignReadBufferSize() is called so indiscriminately (more\n>> generally, it is questionable that it is called in such a high level\n>> routine, rather than the start of a specific merge pass -- I said so a\n>> couple of times already).\n>\n>\n> You can't release the tape buffer at the end of a pass, because the buffer\n> of a tape will already be filled with data from the next run on the same\n> tape.\n\nOkay, but can't you just not use batch memory for non-final merges,\nper my initial approach? That seems far cleaner.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 28 Sep 2016 17:11:52 +0100","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Wed, Sep 28, 2016 at 5:11 PM, Peter Geoghegan <pg@heroku.com> wrote:\n> This is why I never pursued batch memory for non-final merges. Isn't\n> that what you're doing here? You're pretty much always setting\n> \"state->batchUsed = true\".\n\nWait. I guess you feel you have to, since it wouldn't be okay to use\nalmost no memory per tape on non-final merges.\n\nYou're able to throw out so much code here in large part because you\ngive almost all memory over to logtape.c (e.g., you don't manage each\ntape's share of \"slots\" anymore -- better to give everything to\nlogtape.c). So, with your patch, you would actually only have one\ncaller tuple in memory at once per tape for a merge that doesn't use\nbatch memory (if you made it so that a merge *could* avoid the use of\nbatch memory, as I suggest).\n\nIn summary, under your scheme, the \"batchUsed\" variable contains a\ntautological value, since you cannot sensibly not use batch memory.\n(This is even true with !state->tuples callers).\n\nDo I have that right? If so, this seems rather awkward. Hmm.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 28 Sep 2016 17:20:23 +0100","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/28/2016 07:11 PM, Peter Geoghegan wrote:\n> On Wed, Sep 28, 2016 at 5:04 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>>> Not sure that I understand. I agree that each merge pass tends to use\n>>> roughly the same number of tapes, but the distribution of real runs on\n>>> tapes is quite unbalanced in earlier merge passes (due to dummy runs).\n>>> It looks like you're always using batch memory, even for non-final\n>>> merges. Won't that fail to be in balance much of the time because of\n>>> the lopsided distribution of runs? Tapes have an uneven amount of real\n>>> data in earlier merge passes.\n>>\n>>\n>> How does the distribution of the runs on the tapes matter?\n>\n> The exact details are not really relevant to this discussion (I think\n> it's confusing that we simply say \"Target Fibonacci run counts\",\n> FWIW), but the simple fact that it can be quite uneven is.\n\nWell, I claim that the fact that the distribution of runs is uneven, \ndoes not matter. Can you explain why you think it does?\n\n> This is why I never pursued batch memory for non-final merges. Isn't\n> that what you're doing here? You're pretty much always setting\n> \"state->batchUsed = true\".\n\nYep. As the patch stands, we wouldn't really need batchUsed, as we know \nthat it's always true when merging, and false otherwise. But I kept it, \nas it seems like that might not always be true - we might use batch \nmemory when building the initial runs, for example - and because it \nseems nice to have an explicit flag for it, for readability and \ndebugging purposes.\n\n>>> I'm basically repeating myself here, but: I think it's incorrect that\n>>> LogicalTapeAssignReadBufferSize() is called so indiscriminately (more\n>>> generally, it is questionable that it is called in such a high level\n>>> routine, rather than the start of a specific merge pass -- I said so a\n>>> couple of times already).\n>>\n>>\n>> You can't release the tape buffer at the end of a pass, because the buffer\n>> of a tape will already be filled with data from the next run on the same\n>> tape.\n>\n> Okay, but can't you just not use batch memory for non-final merges,\n> per my initial approach? That seems far cleaner.\n\nWhy? I don't see why the final merge should behave differently from the \nnon-final ones.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 28 Sep 2016 21:12:26 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/28/2016 07:20 PM, Peter Geoghegan wrote:\n> On Wed, Sep 28, 2016 at 5:11 PM, Peter Geoghegan <pg@heroku.com> wrote:\n>> This is why I never pursued batch memory for non-final merges. Isn't\n>> that what you're doing here? You're pretty much always setting\n>> \"state->batchUsed = true\".\n>\n> Wait. I guess you feel you have to, since it wouldn't be okay to use\n> almost no memory per tape on non-final merges.\n>\n> You're able to throw out so much code here in large part because you\n> give almost all memory over to logtape.c (e.g., you don't manage each\n> tape's share of \"slots\" anymore -- better to give everything to\n> logtape.c). So, with your patch, you would actually only have one\n> caller tuple in memory at once per tape for a merge that doesn't use\n> batch memory (if you made it so that a merge *could* avoid the use of\n> batch memory, as I suggest).\n\nCorrect.\n\n> In summary, under your scheme, the \"batchUsed\" variable contains a\n> tautological value, since you cannot sensibly not use batch memory.\n> (This is even true with !state->tuples callers).\n\nI suppose.\n\n> Do I have that right? If so, this seems rather awkward. Hmm.\n\nHow is it awkward?\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 29 Sep 2016 12:49:27 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 29, 2016 at 10:49 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Do I have that right? If so, this seems rather awkward. Hmm.\n>\n>\n> How is it awkward?\n\nMaybe that was the wrong choice of words. What I mean is that it seems\nsomewhat unprincipled to give over an equal share of memory to each\nactive-at-least-once tape, regardless of how much that matters in\npractice. One tape could have several runs in memory at once, while\nanother only has a fraction of a single much larger run. Maybe this is\njust the first time that I find myself on the *other* side of a\ndiscussion about an algorithm that seems brute-force compared to what\nit might replace, but is actually better overall. :-)\n\nNow, that could be something that I just need to get over. In any\ncase, I still think:\n\n* Variables like maxTapes have a meaning that is directly traceable\nback to Knuth's description of polyphase merge. I don't think that you\nshould do anything to them, on general principle.\n\n* Everything or almost everything that you've added to mergeruns()\nshould probably be in its own dedicated function. This function can\nhave a comment where you acknowledge that it's not perfectly okay that\nyou claim memory per-tape, but it's simpler and faster overall.\n\n* I think you should be looking at the number of active tapes, and not\nstate->Level or state->currentRun in this new function. Actually,\nmaybe this wouldn't be the exact definition of an active tape that we\nestablish at the beginning of beginmerge() (this considers tapes with\ndummy runs to be inactive for that merge), but it would look similar.\nThe general concern I have here is that you shouldn't rely on\nstate->Level or state->currentRun from a distance for the purposes of\ndetermining which tapes need some batch memory. This is also where you\nmight say something like: \"we don't bother with shifting memory around\ntapes for each merge step, even though that would be fairer. That's\nwhy we don't use the beginmerge() definition of activeTapes --\ninstead, we use our own broader definition of the number of active\ntapes that doesn't exclude dummy-run-tapes with real runs, making the\nallocation reasonably sensible for every merge pass\".\n\n* The \"batchUsed\" terminology really isn't working here, AFAICT. For\none thing, you have two separate areas where caller tuples might\nreside: The small per-tape buffers (sized MERGETUPLEBUFFER_SIZE per\ntape), and the logtape.c controlled preread buffers (sized up to\nMaxAllocSize per tape). Which of these two things is batch memory? I\nthink it might just be the first one, but KiBs of memory do not\nsuggest \"batch\" to me. Isn't that really more like what you might call\ndouble buffer memory, used not to save overhead from palloc (having\nmany palloc headers in memory), but rather to recycle memory\nefficiently? So, these two things should have two new names of their\nown, I think, and neither should be called \"batch memory\" IMV. I see\nseveral assertions remain here and there that were written with my\noriginal definition of batch memory in mind -- assertions like:\n\n case TSS_SORTEDONTAPE:\n Assert(forward || state->randomAccess);\n Assert(!state->batchUsed);\n\n(Isn't state->batchUsed always true now?)\n\nAnd:\n\n case TSS_FINALMERGE:\n Assert(forward);\n Assert(state->batchUsed || !state->tuples);\n\n(Isn't state->tuples only really of interest to datum-tuple-case\nroutines, now that you've made everything use large logtape.c preread\nbuffers?)\n\n* Is is really necessary for !state->tuples cases to do that\nMERGETUPLEBUFFER_SIZE-based allocation? In other words, what need is\nthere for pass-by-value datum cases to have this scratch/double buffer\nmemory at all, since the value is returned to caller by-value, not\nby-reference? This is related to the problem of it not being entirely\nclear what batch memory now is, I think.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 29 Sep 2016 11:52:40 +0100","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 29, 2016 at 6:52 AM, Peter Geoghegan <pg@heroku.com> wrote:\n>> How is it awkward?\n>\n> Maybe that was the wrong choice of words. What I mean is that it seems\n> somewhat unprincipled to give over an equal share of memory to each\n> active-at-least-once tape, ...\n\nI don't get it. If the memory is being used for prereading, then the\npoint is just to avoid doing many small I/Os instead of one big I/O,\nand that goal will be accomplished whether the memory is equally\ndistributed or not; indeed, it's likely to be accomplished BETTER if\nthe memory is equally distributed than if it isn't.\n\nI can imagine that there might be a situation in which it makes sense\nto give a bigger tape more resources than a smaller one; for example,\nif one were going to divide N tapes across K worker processess and\nmake individual workers or groups of workers responsible for sorting\nparticular tapes, one would of course want to divide up the data\nacross the available processes relatively evenly, rather than having\nsome workers responsible for only a small amount of data and others\nfor a very large amount of data. But such considerations are\nirrelevant here.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 29 Sep 2016 09:59:53 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/29/2016 01:52 PM, Peter Geoghegan wrote:\n> * Variables like maxTapes have a meaning that is directly traceable\n> back to Knuth's description of polyphase merge. I don't think that you\n> should do anything to them, on general principle.\n\nOk. I still think that changing maxTapes would make sense, when there \nare fewer runs than tapes, but that is actually orthogonal to the rest \nof the patch, so let's discuss that separately. I've changed the patch \nto not do that.\n\n> * Everything or almost everything that you've added to mergeruns()\n> should probably be in its own dedicated function. This function can\n> have a comment where you acknowledge that it's not perfectly okay that\n> you claim memory per-tape, but it's simpler and faster overall.\n\nOk.\n\n> * I think you should be looking at the number of active tapes, and not\n> state->Level or state->currentRun in this new function. Actually,\n> maybe this wouldn't be the exact definition of an active tape that we\n> establish at the beginning of beginmerge() (this considers tapes with\n> dummy runs to be inactive for that merge), but it would look similar.\n> The general concern I have here is that you shouldn't rely on\n> state->Level or state->currentRun from a distance for the purposes of\n> determining which tapes need some batch memory. This is also where you\n> might say something like: \"we don't bother with shifting memory around\n> tapes for each merge step, even though that would be fairer. That's\n> why we don't use the beginmerge() definition of activeTapes --\n> instead, we use our own broader definition of the number of active\n> tapes that doesn't exclude dummy-run-tapes with real runs, making the\n> allocation reasonably sensible for every merge pass\".\n\nI'm not sure I understood what your concern was, but please have a look \nat this new version, if the comments in initTapeBuffers() explain that \nwell enough.\n\n> * The \"batchUsed\" terminology really isn't working here, AFAICT. For\n> one thing, you have two separate areas where caller tuples might\n> reside: The small per-tape buffers (sized MERGETUPLEBUFFER_SIZE per\n> tape), and the logtape.c controlled preread buffers (sized up to\n> MaxAllocSize per tape). Which of these two things is batch memory? I\n> think it might just be the first one, but KiBs of memory do not\n> suggest \"batch\" to me. Isn't that really more like what you might call\n> double buffer memory, used not to save overhead from palloc (having\n> many palloc headers in memory), but rather to recycle memory\n> efficiently? So, these two things should have two new names of their\n> own, I think, and neither should be called \"batch memory\" IMV. I see\n> several assertions remain here and there that were written with my\n> original definition of batch memory in mind -- assertions like:\n\nOk. I replaced \"batch\" terminology with \"slab allocator\" and \"slab \nslots\", I hope this is less confusing. This isn't exactly like e.g. the \nslab allocator in the Linux kernel, as it has a fixed number of slots, \nso perhaps an \"object pool\" might be more accurate. But I like \"slab\" \nbecause it's not used elsewhere in the system. I also didn't use the \nterm \"cache\" for the \"slots\", as might be typical for slab allocators, \nbecause \"cache\" is such an overloaded term.\n\n> case TSS_SORTEDONTAPE:\n> Assert(forward || state->randomAccess);\n> Assert(!state->batchUsed);\n>\n> (Isn't state->batchUsed always true now?)\n\nGood catch. It wasn't, because mergeruns() set batchUsed only after \nchecking for the TSS_SORTEDONTAPE case, even though it set up the batch \nmemory arena before it. So if replacement selection was able to produce \na single run batchUsed was false. Fixed, the slab allocator (as it's now \ncalled) is now always used in TSS_SORTEDONTAPE case.\n\n> And:\n>\n> case TSS_FINALMERGE:\n> Assert(forward);\n> Assert(state->batchUsed || !state->tuples);\n>\n> (Isn't state->tuples only really of interest to datum-tuple-case\n> routines, now that you've made everything use large logtape.c preread\n> buffers?)\n\nYeah, fixed.\n\n> * Is is really necessary for !state->tuples cases to do that\n> MERGETUPLEBUFFER_SIZE-based allocation? In other words, what need is\n> there for pass-by-value datum cases to have this scratch/double buffer\n> memory at all, since the value is returned to caller by-value, not\n> by-reference? This is related to the problem of it not being entirely\n> clear what batch memory now is, I think.\n\nTrue, fixed. I still set slabAllocatorUsed (was batchUsed), but it's \ninitialized as a dummy 0-slot arena when !state->tuples.\n\nHere's a new patch version, addressing the points you made. Please have \na look!\n\n- Heikki\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 29 Sep 2016 17:41:25 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/29/2016 05:41 PM, Heikki Linnakangas wrote:\n> Here's a new patch version, addressing the points you made. Please have\n> a look!\n\nBah, I fumbled the initSlabAllocator() function, attached is a fixed \nversion.\n\n- Heikki\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Thu, 29 Sep 2016 18:10:03 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 29, 2016 at 2:59 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> Maybe that was the wrong choice of words. What I mean is that it seems\n>> somewhat unprincipled to give over an equal share of memory to each\n>> active-at-least-once tape, ...\n>\n> I don't get it. If the memory is being used for prereading, then the\n> point is just to avoid doing many small I/Os instead of one big I/O,\n> and that goal will be accomplished whether the memory is equally\n> distributed or not; indeed, it's likely to be accomplished BETTER if\n> the memory is equally distributed than if it isn't.\n\nI think it could hurt performance if preloading loads runs on a tape\nthat won't be needed until some subsequent merge pass, in preference\nto using that memory proportionately, giving more to larger input runs\nfor *each* merge pass (giving memory proportionate to the size of each\nrun to be merged from each tape). For tapes with a dummy run, the\nappropriate amount of memory for there next merge pass is zero.\n\nI'm not arguing that it would be worth it to do that, but I do think\nthat that's the sensible way of framing the idea of using a uniform\namount of memory to every maybe-active tape up front. I'm not too\nconcerned about this because I'm never too concerned about multiple\nmerge pass cases, which are relatively rare and relatively\nunimportant. Let's just get our story straight.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 29 Sep 2016 16:38:57 +0100","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 29, 2016 at 11:38 AM, Peter Geoghegan <pg@heroku.com> wrote:\n> On Thu, Sep 29, 2016 at 2:59 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>> Maybe that was the wrong choice of words. What I mean is that it seems\n>>> somewhat unprincipled to give over an equal share of memory to each\n>>> active-at-least-once tape, ...\n>>\n>> I don't get it. If the memory is being used for prereading, then the\n>> point is just to avoid doing many small I/Os instead of one big I/O,\n>> and that goal will be accomplished whether the memory is equally\n>> distributed or not; indeed, it's likely to be accomplished BETTER if\n>> the memory is equally distributed than if it isn't.\n>\n> I think it could hurt performance if preloading loads runs on a tape\n> that won't be needed until some subsequent merge pass, in preference\n> to using that memory proportionately, giving more to larger input runs\n> for *each* merge pass (giving memory proportionate to the size of each\n> run to be merged from each tape). For tapes with a dummy run, the\n> appropriate amount of memory for there next merge pass is zero.\n\nOK, true. But I still suspect that unless the amount of data you need\nto read from a tape is zero or very small, the size of the buffer\ndoesn't matter. For example, if you have a 1GB tape and a 10GB tape,\nI doubt there's any benefit in making the buffer for the 10GB tape 10x\nlarger. They can probably be the same.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 29 Sep 2016 12:56:21 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Sep 29, 2016 at 4:10 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n> Bah, I fumbled the initSlabAllocator() function, attached is a fixed\n> version.\n\nThis looks much better. It's definitely getting close. Thanks for\nbeing considerate of my more marginal concerns. More feedback:\n\n* Should say \"fixed number of...\":\n\n> + * we start merging. Merging only needs to keep a small, fixed number tuples\n\n* Minor concern about these new macros:\n\n> +#define IS_SLAB_SLOT(state, tuple) \\\n> + ((char *) tuple >= state->slabMemoryBegin && \\\n> + (char *) tuple < state->slabMemoryEnd)\n> +\n> +/*\n> + * Return the given tuple to the slab memory free list, or free it\n> + * if it was palloc'd.\n> + */\n> +#define RELEASE_SLAB_SLOT(state, tuple) \\\n> + do { \\\n> + SlabSlot *buf = (SlabSlot *) tuple; \\\n> + \\\n> + if (IS_SLAB_SLOT(state, tuple)) \\\n> + { \\\n> + buf->nextfree = state->slabFreeHead; \\\n> + state->slabFreeHead = buf; \\\n> + } else \\\n> + pfree(tuple); \\\n> + } while(0)\n\nI suggest duplicating the paranoia seen elsewhere around what \"state\"\nmacro argument could expand to. You know, by surrounding \"state\" with\nparenthesis each time it is used. This is what we see with existing,\nsimilar macros.\n\n* Should cast to int64 here (for the benefit of win64):\n\n> + elog(LOG, \"using \" INT64_FORMAT \" KB of memory for read buffers among %d input tapes\",\n> + (long) (availBlocks * BLCKSZ) / 1024, numInputTapes);\n\n* FWIW, I still don't love this bit:\n\n> + * numTapes and numInputTapes reflect the actual number of tapes we will\n> + * use. Note that the output tape's tape number is maxTapes - 1, so the\n> + * tape numbers of the used tapes are not consecutive, so you cannot\n> + * just loop from 0 to numTapes to visit all used tapes!\n> + */\n> + if (state->Level == 1)\n> + {\n> + numInputTapes = state->currentRun;\n> + numTapes = numInputTapes + 1;\n> + FREEMEM(state, (state->maxTapes - numTapes) * TAPE_BUFFER_OVERHEAD);\n> + }\n\nBut I can see how the verbosity of almost-duplicating the activeTapes\nstuff seems unappealing. That said, I think that you should point out\nin comments that you're calculating the number of\nmaybe-active-in-some-merge tapes. They're maybe-active in that they\nhave some number of real tapes. Not going to insist on that, but\nsomething to think about.\n\n* Shouldn't this use state->tapeRange?:\n\n> + else\n> + {\n> + numInputTapes = state->maxTapes - 1;\n> + numTapes = state->maxTapes;\n> + }\n\n* Doesn't it also set numTapes without it being used? Maybe that\nvariable can be declared within \"if (state->Level == 1)\" block.\n\n* Minor issues with initSlabAllocator():\n\nYou call the new function initSlabAllocator() as follows:\n\n> + if (state->tuples)\n> + initSlabAllocator(state, numInputTapes + 1);\n> + else\n> + initSlabAllocator(state, 0);\n\nIsn't the number of slots (the second argument to initSlabAllocator())\nactually just numInputTapes when we're \"state->tuples\"? And so,\nshouldn't the \"+ 1\" bit happen within initSlabAllocator() itself? It\ncan just inspect \"state->tuples\" itself. In short, maybe push a bit\nmore into initSlabAllocator(). Making the arguments match those passed\nto initTapeBuffers() a bit later would be nice, perhaps.\n\n* This could be simpler, I think:\n\n> + /* Release the read buffers on all the other tapes, by rewinding them. */\n> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\n> + {\n> + if (tapenum == state->result_tape)\n> + continue;\n> + LogicalTapeRewind(state->tapeset, tapenum, true);\n> + }\n\nCan't you just use state->tapeRange, and remove the \"continue\"? I\nrecommend referring to \"now-exhausted input tapes\" here, too.\n\n* I'm not completely prepared to give up on using\nMemoryContextAllocHuge() within logtape.c just yet. Maybe you're right\nthat it couldn't possibly matter that we impose a MaxAllocSize cap\nwithin logtape.c (per tape), but I have slight reservations that I\nneed to address. Maybe a better way of putting it would be that I have\nsome reservations about possible regressions at the very high end,\nwith very large workMem. Any thoughts on that?\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 30 Sep 2016 14:08:44 +0100","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 09/30/2016 04:08 PM, Peter Geoghegan wrote:\n> On Thu, Sep 29, 2016 at 4:10 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Bah, I fumbled the initSlabAllocator() function, attached is a fixed\n>> version.\n>\n> This looks much better. It's definitely getting close. Thanks for\n> being considerate of my more marginal concerns. More feedback:\n\nFixed most of the things you pointed out, thanks.\n\n> * Minor issues with initSlabAllocator():\n>\n> You call the new function initSlabAllocator() as follows:\n>\n>> + if (state->tuples)\n>> + initSlabAllocator(state, numInputTapes + 1);\n>> + else\n>> + initSlabAllocator(state, 0);\n>\n> Isn't the number of slots (the second argument to initSlabAllocator())\n> actually just numInputTapes when we're \"state->tuples\"? And so,\n> shouldn't the \"+ 1\" bit happen within initSlabAllocator() itself? It\n> can just inspect \"state->tuples\" itself. In short, maybe push a bit\n> more into initSlabAllocator(). Making the arguments match those passed\n> to initTapeBuffers() a bit later would be nice, perhaps.\n\nThe comment above that explains the \"+ 1\". init_slab_allocator allocates \nthe number of slots that was requested, and the caller is responsible \nfor deciding how many slots are needed. Yeah, we could remove the \nargument and move the logic altogether into init_slab_allocator(), but I \nthink it's clearer this way. Matter of taste, I guess.\n\n> * This could be simpler, I think:\n>\n>> + /* Release the read buffers on all the other tapes, by rewinding them. */\n>> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\n>> + {\n>> + if (tapenum == state->result_tape)\n>> + continue;\n>> + LogicalTapeRewind(state->tapeset, tapenum, true);\n>> + }\n>\n> Can't you just use state->tapeRange, and remove the \"continue\"? I\n> recommend referring to \"now-exhausted input tapes\" here, too.\n\nDon't think so. result_tape == tapeRange only when the merge was done in \na single pass (or you're otherwise lucky).\n\n> * I'm not completely prepared to give up on using\n> MemoryContextAllocHuge() within logtape.c just yet. Maybe you're right\n> that it couldn't possibly matter that we impose a MaxAllocSize cap\n> within logtape.c (per tape), but I have slight reservations that I\n> need to address. Maybe a better way of putting it would be that I have\n> some reservations about possible regressions at the very high end,\n> with very large workMem. Any thoughts on that?\n\nMeh, I can't imagine that using more than 1 GB for a read-ahead buffer \ncould make any difference in practice. If you have a very large \nwork_mem, you'll surely get away with a single merge pass, and \nfragmentation won't become an issue. And 1GB should be more than enough \nto trigger OS read-ahead.\n\nCommitted with some final kibitzing. Thanks for the review!\n\nPS. This patch didn't fix bug #14344, the premature reuse of memory with \ntuplesort_gettupleslot. We'll still need to come up with 1. a \nbackportable fix for that, and 2. perhaps a different fix for master.\n\n- Heikki\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 3 Oct 2016 13:39:10 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Mon, Oct 3, 2016 at 3:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\n>> Can't you just use state->tapeRange, and remove the \"continue\"? I\n>> recommend referring to \"now-exhausted input tapes\" here, too.\n>\n>\n> Don't think so. result_tape == tapeRange only when the merge was done in a\n> single pass (or you're otherwise lucky).\n\nAh, yes. Logical tape assignment/physical tape number confusion on my part here.\n\n>> * I'm not completely prepared to give up on using\n>> MemoryContextAllocHuge() within logtape.c just yet. Maybe you're right\n>> that it couldn't possibly matter that we impose a MaxAllocSize cap\n>> within logtape.c (per tape), but I have slight reservations that I\n>> need to address. Maybe a better way of putting it would be that I have\n>> some reservations about possible regressions at the very high end,\n>> with very large workMem. Any thoughts on that?\n>\n>\n> Meh, I can't imagine that using more than 1 GB for a read-ahead buffer could\n> make any difference in practice. If you have a very large work_mem, you'll\n> surely get away with a single merge pass, and fragmentation won't become an\n> issue. And 1GB should be more than enough to trigger OS read-ahead.\n\nI had a non-specific concern, not an intuition of suspicion about\nthis. I think that I'll figure it out when I rebase the parallel\nCREATE INDEX patch on top of this and test that.\n\n> Committed with some final kibitzing. Thanks for the review!\n\nThanks for working on this!\n\n> PS. This patch didn't fix bug #14344, the premature reuse of memory with\n> tuplesort_gettupleslot. We'll still need to come up with 1. a backportable\n> fix for that, and 2. perhaps a different fix for master.\n\nAgreed. It seemed like you favor not changing memory ownership\nsemantics for 9.6. I'm not sure that that's the easiest approach for\n9.6, but let's discuss that over on the dedicated thread soon.\n\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 3 Oct 2016 04:51:54 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"Heikki Linnakangas <hlinnaka@iki.fi> writes:\n> I'm talking about the code that reads a bunch of from each tape, loading \n> them into the memtuples array. That code was added by Tom Lane, back in \n> 1999:\n\n> commit cf627ab41ab9f6038a29ddd04dd0ff0ccdca714e\n> Author: Tom Lane <tgl@sss.pgh.pa.us>\n> Date: Sat Oct 30 17:27:15 1999 +0000\n\n> Further performance improvements in sorting: reduce number of comparisons\n> during initial run formation by keeping both current run and next-run\n> tuples in the same heap (yup, Knuth is smarter than I am). And, during\n> merge passes, make use of available sort memory to load multiple tuples\n> from any one input 'tape' at a time, thereby improving locality of\n> access to the temp file.\n\n> So apparently there was a benefit back then, but is it still worthwhile? \n\nI'm fairly sure that the point was exactly what it said, ie improve\nlocality of access within the temp file by sequentially reading as many\ntuples in a row as we could, rather than grabbing one here and one there.\n\nIt may be that the work you and Peter G. have been doing have rendered\nthat question moot. But I'm a bit worried that the reason you're not\nseeing any effect is that you're only testing situations with zero seek\npenalty (ie your laptop's disk is an SSD). Back then I would certainly\nhave been testing with temp files on spinning rust, and I fear that this\nmay still be an issue in that sort of environment.\n\nThe relevant mailing list thread seems to be \"sort on huge table\" in\npgsql-hackers in October/November 1999. The archives don't seem to have\nthreaded that too successfully, but here's a message specifically\ndescribing the commit you mention:\n\nhttps://www.postgresql.org/message-id/2726.941493808%40sss.pgh.pa.us\n\nand you can find the rest by looking through the archive summary pages\nfor that interval.\n\nThe larger picture to be drawn from that thread is that we were seeing\nvery different performance characteristics on different platforms.\nThe specific issue that Tatsuo-san reported seemed like it might be\ndown to weird read-ahead behavior in a 90s-vintage Linux kernel ...\nbut the point that this stuff can be environment-dependent is still\nsomething to take to heart.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 14 Apr 2017 00:51:15 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"I wrote:\n> Heikki Linnakangas <hlinnaka@iki.fi> writes:\n>> I'm talking about the code that reads a bunch of from each tape, loading \n>> them into the memtuples array. That code was added by Tom Lane, back in \n>> 1999:\n>> So apparently there was a benefit back then, but is it still worthwhile? \n\n> I'm fairly sure that the point was exactly what it said, ie improve\n> locality of access within the temp file by sequentially reading as many\n> tuples in a row as we could, rather than grabbing one here and one there.\n\n[ blink... ] Somehow, my mail reader popped up a message from 2016\nas current, and I spent some time researching and answering it without\nnoticing the message date.\n\nNever mind, nothing to see here ...\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 14 Apr 2017 00:57:20 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Apr 13, 2017 at 9:51 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n> I'm fairly sure that the point was exactly what it said, ie improve\n> locality of access within the temp file by sequentially reading as many\n> tuples in a row as we could, rather than grabbing one here and one there.\n>\n> It may be that the work you and Peter G. have been doing have rendered\n> that question moot. But I'm a bit worried that the reason you're not\n> seeing any effect is that you're only testing situations with zero seek\n> penalty (ie your laptop's disk is an SSD). Back then I would certainly\n> have been testing with temp files on spinning rust, and I fear that this\n> may still be an issue in that sort of environment.\n\nI actually think Heikki's work here would particularly help on\nspinning rust, especially when less memory is available. He\nspecifically justified it on the basis of it resulting in a more\nsequential read pattern, particularly when multiple passes are\nrequired.\n\n> The larger picture to be drawn from that thread is that we were seeing\n> very different performance characteristics on different platforms.\n> The specific issue that Tatsuo-san reported seemed like it might be\n> down to weird read-ahead behavior in a 90s-vintage Linux kernel ...\n> but the point that this stuff can be environment-dependent is still\n> something to take to heart.\n\nBTW, I'm skeptical of the idea of Heikki's around killing polyphase\nmerge itself at this point. I think that keeping most tapes active per\npass is useful now that our memory accounting involves handing over an\neven share to each maybe-active tape for every merge pass, something\nestablished by Heikki's work on external sorting.\n\nInterestingly enough, I think that Knuth was pretty much spot on with\nhis \"sweet spot\" of 7 tapes, even if you have modern hardware. Commit\ndf700e6 (where the sweet spot of merge order 7 was no longer always\nused) was effective because it masked certain overheads that we\nexperience when doing multiple passes, overheads that Heikki and I\nmostly removed. This was confirmed by Robert's testing of my merge\norder cap work for commit fc19c18, where he found that using 7 tapes\nwas only slightly worse than using many hundreds of tapes. If we could\nsomehow be completely effective in making access to logical tapes\nperfectly sequential, then 7 tapes would probably be noticeably\n*faster*, due to CPU caching effects.\n\nKnuth was completely correct to say that it basically made no\ndifference once more than 7 tapes are used to merge, because he didn't\nhave logtape.c fragmentation to worry about.\n\n-- \nPeter Geoghegan\n\nVMware vCenter Server\nhttps://www.vmware.com/\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 13 Apr 2017 22:19:58 -0700","msg_from":"Peter Geoghegan <pg@bowt.ie>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Thu, Apr 13, 2017 at 10:19 PM, Peter Geoghegan <pg@bowt.ie> wrote:\n> I actually think Heikki's work here would particularly help on\n> spinning rust, especially when less memory is available. He\n> specifically justified it on the basis of it resulting in a more\n> sequential read pattern, particularly when multiple passes are\n> required.\n\nBTW, what you might have missed is that Heikki did end up using a\nsignificant amount of memory in the committed version. It just ended\nup being managed by logtape.c, which now does the prereading instead\nof tuplesort.c, but at a lower level. There is only one tuple in the\nmerge heap, but there is still up to 1GB of memory per tape,\ncontaining raw preread tuples mixed with integers that demarcate tape\ncontents.\n\n-- \nPeter Geoghegan\n\nVMware vCenter Server\nhttps://www.vmware.com/\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 13 Apr 2017 22:49:47 -0700","msg_from":"Peter Geoghegan <pg@bowt.ie>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Apr 14, 2017 at 1:19 AM, Peter Geoghegan <pg@bowt.ie> wrote:\n> Interestingly enough, I think that Knuth was pretty much spot on with\n> his \"sweet spot\" of 7 tapes, even if you have modern hardware. Commit\n> df700e6 (where the sweet spot of merge order 7 was no longer always\n> used) was effective because it masked certain overheads that we\n> experience when doing multiple passes, overheads that Heikki and I\n> mostly removed. This was confirmed by Robert's testing of my merge\n> order cap work for commit fc19c18, where he found that using 7 tapes\n> was only slightly worse than using many hundreds of tapes. If we could\n> somehow be completely effective in making access to logical tapes\n> perfectly sequential, then 7 tapes would probably be noticeably\n> *faster*, due to CPU caching effects.\n\nI don't think there's any one fixed answer, because increasing the\nnumber of tapes reduces I/O by adding CPU cost, and visca versa.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 14 Apr 2017 08:57:32 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On Fri, Apr 14, 2017 at 5:57 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n> I don't think there's any one fixed answer, because increasing the\n> number of tapes reduces I/O by adding CPU cost, and visca versa.\n\nSort of, but if you have to merge hundreds of runs (a situation that\nshould be quite rare), then you should be concerned about being CPU\nbound first, as Knuth was. Besides, on modern hardware, read-ahead can\nbe more effective if you have more merge passes, to a point, which\nmight also make it worth it -- using hundreds of tapes results in\nplenty of *random* I/O. Plus, most of the time you only do a second\npass over a subset of initial quicksorted runs -- not all of them.\n\nProbably the main complicating factor that Knuth doesn't care about is\ntime to return the first tuple -- startup cost. That was a big\nadvantage for commit df700e6 that I should have mentioned.\n\nI'm not seriously suggesting that we should prefer multiple passes in\nthe vast majority of real world cases, nor am I suggesting that we\nshould go out of our way to help cases that need to do that. I just\nfind all this interesting.\n\n-- \nPeter Geoghegan\n\nVMware vCenter Server\nhttps://www.vmware.com/\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 14 Apr 2017 11:10:12 -0700","msg_from":"Peter Geoghegan <pg@bowt.ie>","msg_from_op":false,"msg_subject":"Re: Tuplesort merge pre-reading"},{"msg_contents":"On 04/14/2017 08:19 AM, Peter Geoghegan wrote:\n> BTW, I'm skeptical of the idea of Heikki's around killing polyphase\n> merge itself at this point. I think that keeping most tapes active per\n> pass is useful now that our memory accounting involves handing over an\n> even share to each maybe-active tape for every merge pass, something\n> established by Heikki's work on external sorting.\n\nThe pre-read buffers are only needed for input tapes; the total number \nof tapes doesn't matter.\n\nFor comparison, imagine that you want to perform a merge, such that you \nalways merge 7 runs into one. With polyphase merge, you would need 8 \ntapes, so that you always read from 7 of them, and write onto one. With \nbalanced merge, you would need 14 tapes: you always read from 7 tapes, \nand you would need up to 7 output tapes, of which one would be active at \nany given time.\n\nThose extra idle output tapes are practically free in our \nimplementation. The \"pre-read buffers\" are only needed for input tapes, \nthe number of output tapes doesn't matter. Likewise, maintaining the \nheap is cheaper if you only merge a small number of tapes at a time, but \nthat's also dependent on the number of *input* tapes, not the total \nnumber of tapes.\n\n- Heikki\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 18 Apr 2017 11:05:40 +0300","msg_from":"Heikki Linnakangas <hlinnaka@iki.fi>","msg_from_op":true,"msg_subject":"Re: Tuplesort merge pre-reading"}],"string":"[\n {\n \"msg_contents\": \"While reviewing Peter's latest round of sorting patches, and trying to \\nunderstand the new \\\"batch allocation\\\" mechanism, I started to wonder how \\nuseful the pre-reading in the merge stage is in the first place.\\n\\nI'm talking about the code that reads a bunch of from each tape, loading \\nthem into the memtuples array. That code was added by Tom Lane, back in \\n1999:\\n\\ncommit cf627ab41ab9f6038a29ddd04dd0ff0ccdca714e\\nAuthor: Tom Lane <tgl@sss.pgh.pa.us>\\nDate: Sat Oct 30 17:27:15 1999 +0000\\n\\n Further performance improvements in sorting: reduce number of \\ncomparisons\\n during initial run formation by keeping both current run and next-run\\n tuples in the same heap (yup, Knuth is smarter than I am). And, during\\n merge passes, make use of available sort memory to load multiple tuples\\n from any one input 'tape' at a time, thereby improving locality of\\n access to the temp file.\\n\\nSo apparently there was a benefit back then, but is it still worthwhile? \\nThe LogicalTape buffers one block at a time, anyway, how much gain are \\nwe getting from parsing the tuples into SortTuple format in batches?\\n\\nI wrote a quick patch to test that, attached. It seems to improve \\nperformance, at least in this small test case:\\n\\ncreate table lotsofints(i integer);\\ninsert into lotsofints select random() * 1000000000.0 from \\ngenerate_series(1, 10000000);\\nvacuum freeze;\\n\\nselect count(*) FROM (select * from lotsofints order by i) t;\\n\\nOn my laptop, with default work_mem=4MB, that select takes 7.8 s on \\nunpatched master, and 6.2 s with the attached patch.\\n\\nSo, at least in some cases, the pre-loading hurts. I think we should get \\nrid of it. This patch probably needs some polishing: I replaced the \\nbatch allocations with a simpler scheme with a buffer to hold just a \\nsingle tuple for each tape, and that might need some more work to allow \\ndownsizing those buffers if you have a few very large tuples in an \\notherwise narrow table. And perhaps we should free and reallocate a \\nsmaller memtuples array for the merging, now that we're not making use \\nof the whole of it. And perhaps we should teach LogicalTape to use \\nlarger buffers, if we can't rely on the OS to do the buffering for us. \\nBut overall, this seems to make the code both simpler and faster.\\n\\nAm I missing something?\\n\\n- Heikki\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 6 Sep 2016 15:20:30 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 5:20 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> I wrote a quick patch to test that, attached. It seems to improve\\n> performance, at least in this small test case:\\n>\\n> create table lotsofints(i integer);\\n> insert into lotsofints select random() * 1000000000.0 from\\n> generate_series(1, 10000000);\\n> vacuum freeze;\\n>\\n> select count(*) FROM (select * from lotsofints order by i) t;\\n>\\n> On my laptop, with default work_mem=4MB, that select takes 7.8 s on\\n> unpatched master, and 6.2 s with the attached patch.\\n\\nThe benefits have a lot to do with OS read-ahead, and efficient use of\\nmemory bandwidth during the merge, where we want to access the caller\\ntuples sequentially per tape (i.e. that's what the batch memory stuff\\nadded -- it also made much better use of available memory). Note that\\nI've been benchmarking the parallel CREATE INDEX patch on a server\\nwith many HDDs, since sequential performance is mostly all that\\nmatters. I think that in 1999, the preloading had a lot more to do\\nwith logtape.c's ability to aggressively recycle blocks during merges,\\nsuch that the total storage overhead does not exceed the original size\\nof the caller tuples (plus what it calls \\\"trivial bookkeeping\\noverhead\\\" IIRC). That's less important these days, but still matters\\nsome (it's more of an issue when you can't complete the sort in one\\npass, which is rare these days).\\n\\nOffhand, I would think that taken together this is very important. I'd\\ncertainly want to see cases in the hundreds of megabytes or gigabytes\\nof work_mem alongside your 4MB case, even just to be able to talk\\ninformally about this. As you know, the default work_mem value is very\\nconservative.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 12:08:33 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n> Offhand, I would think that taken together this is very important. I'd\\n> certainly want to see cases in the hundreds of megabytes or gigabytes\\n> of work_mem alongside your 4MB case, even just to be able to talk\\n> informally about this. As you know, the default work_mem value is very\\n> conservative.\\n\\nIt looks like your benchmark relies on multiple passes, which can be\\nmisleading. I bet it suffers some amount of problems from palloc()\\nfragmentation. When very memory constrained, that can get really bad.\\n\\nNon-final merge passes (merges with more than one run -- real or dummy\\n-- on any given tape) can have uneven numbers of runs on each tape.\\nSo, tuplesort.c needs to be prepared to doll out memory among tapes\\n*unevenly* there (same applies to memtuples \\\"slots\\\"). This is why\\nbatch memory support is so hard for those cases (the fact that they're\\nso rare anyway also puts me off it). As you know, I wrote a patch that\\nadds batch memory support to cases that require randomAccess (final\\noutput on a materialized tape), for their final merge. These final\\nmerges happen to not be a final on-the-fly merge only due to this\\nrandomAccess requirement from caller. It's possible to support these\\ncases in the future, with that patch, only because I am safe to assume\\nthat each run/tape is the same size there (well, the assumption is\\nexactly as safe as it was for the 9.6 final on-the-fly merge, at\\nleast).\\n\\nMy point about non-final merges is that you have to be very careful\\nthat you're comparing apples to apples, memory accounting wise, when\\nlooking into something like this. I'm not saying that you didn't, but\\nit's worth considering.\\n\\nFWIW, I did try an increase in the buffer size in LogicalTape at one\\ntime several months back, and so no benefit there (at least, with no\\nother changes).\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 6 Sep 2016 12:26:54 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\\n> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>> Offhand, I would think that taken together this is very important. I'd\\n>> certainly want to see cases in the hundreds of megabytes or gigabytes\\n>> of work_mem alongside your 4MB case, even just to be able to talk\\n>> informally about this. As you know, the default work_mem value is very\\n>> conservative.\\n\\nI spent some more time polishing this up, and also added some code to \\nlogtape.c, to use larger read buffers, to compensate for the fact that \\nwe don't do pre-reading from tuplesort.c anymore. That should trigger \\nthe OS read-ahead, and make the I/O more sequential, like was the \\npurpose of the old pre-reading code. But simpler. I haven't tested that \\npart much yet, but I plan to run some tests on larger data sets that \\ndon't fit in RAM, to make the I/O effects visible.\\n\\nI wrote a little testing toolkit, see third patch. I'm not proposing to \\ncommit that, but that's what I used for testing. It creates four tables, \\nabout 1GB in size each (it also creates smaller and larger tables, but I \\nused the \\\"medium\\\" sized ones for these tests). Two of the tables contain \\nintegers, and two contain text strings. Two of the tables are completely \\nordered, two are in random order. To measure, it runs ORDER BY queries \\non the tables, with different work_mem settings.\\n\\nAttached are the full results. In summary, these patches improve \\nperformance in some of the tests, and are a wash on others. The patches \\nhelp in particular in the randomly ordered cases, with up to 512 MB of \\nwork_mem.\\n\\nFor example, with work_mem=256MB, which is enough to get a single merge \\npass:\\n\\nwith patches:\\n\\nordered_ints: 7078 ms, 6910 ms, 6849 ms\\nrandom_ints: 15639 ms, 15575 ms, 15625 ms\\nordered_text: 11121 ms, 12318 ms, 10824 ms\\nrandom_text: 53462 ms, 53420 ms, 52949 ms\\n\\nunpatched master:\\n\\nordered_ints: 6961 ms, 7040 ms, 7044 ms\\nrandom_ints: 19205 ms, 18797 ms, 18955 ms\\nordered_text: 11045 ms, 11377 ms, 11203 ms\\nrandom_text: 57117 ms, 54489 ms, 54806 ms\\n\\n(The same queries were run three times in a row, that's what the three \\nnumbers on each row mean. I.e. the differences between the numbers on \\nsame row are noise)\\n\\n> It looks like your benchmark relies on multiple passes, which can be\\n> misleading. I bet it suffers some amount of problems from palloc()\\n> fragmentation. When very memory constrained, that can get really bad.\\n>\\n> Non-final merge passes (merges with more than one run -- real or dummy\\n> -- on any given tape) can have uneven numbers of runs on each tape.\\n> So, tuplesort.c needs to be prepared to doll out memory among tapes\\n> *unevenly* there (same applies to memtuples \\\"slots\\\"). This is why\\n> batch memory support is so hard for those cases (the fact that they're\\n> so rare anyway also puts me off it). As you know, I wrote a patch that\\n> adds batch memory support to cases that require randomAccess (final\\n> output on a materialized tape), for their final merge. These final\\n> merges happen to not be a final on-the-fly merge only due to this\\n> randomAccess requirement from caller. It's possible to support these\\n> cases in the future, with that patch, only because I am safe to assume\\n> that each run/tape is the same size there (well, the assumption is\\n> exactly as safe as it was for the 9.6 final on-the-fly merge, at\\n> least).\\n>\\n> My point about non-final merges is that you have to be very careful\\n> that you're comparing apples to apples, memory accounting wise, when\\n> looking into something like this. I'm not saying that you didn't, but\\n> it's worth considering.\\n\\nI'm not 100% sure I'm accounting for all the memory correctly. But I \\ndidn't touch the way the initial quicksort works, nor the way the runs \\nare built. And the merge passes don't actually need or benefit from a \\nlot of memory, so I doubt it's very sensitive to that.\\n\\nIn this patch, the memory available for the read buffers is just divided \\nevenly across maxTapes. The buffers for the tapes that are not currently \\nactive are wasted. It could be made smarter, by freeing all the \\ncurrently-unused buffers for tapes that are not active at the moment. \\nMight do that later, but this is what I'm going to benchmark for now. I \\ndon't think adding buffers is helpful beyond a certain point, so this is \\nprobably good enough in practice. Although it would be nice to free the \\nmemory we don't need earlier, in case there are other processes that \\ncould make use of it.\\n\\n> FWIW, I did try an increase in the buffer size in LogicalTape at one\\n> time several months back, and so no benefit there (at least, with no\\n> other changes).\\n\\nYeah, unless you get rid of the pre-reading in tuplesort.c, you're just \\ndouble-buffering.\\n\\n- Heikki\\n\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 8 Sep 2016 21:59:41 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/08/2016 09:59 PM, Heikki Linnakangas wrote:\\n> On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\\n>> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>>> Offhand, I would think that taken together this is very important. I'd\\n>>> certainly want to see cases in the hundreds of megabytes or gigabytes\\n>>> of work_mem alongside your 4MB case, even just to be able to talk\\n>>> informally about this. As you know, the default work_mem value is very\\n>>> conservative.\\n>\\n> I spent some more time polishing this up, and also added some code to\\n> logtape.c, to use larger read buffers, to compensate for the fact that\\n> we don't do pre-reading from tuplesort.c anymore. That should trigger\\n> the OS read-ahead, and make the I/O more sequential, like was the\\n> purpose of the old pre-reading code. But simpler. I haven't tested that\\n> part much yet, but I plan to run some tests on larger data sets that\\n> don't fit in RAM, to make the I/O effects visible.\\n\\nOk, I ran a few tests with 20 GB tables. I thought this would show any \\ndifferences in I/O behaviour, but in fact it was still completely CPU \\nbound, like the tests on smaller tables I posted yesterday. I guess I \\nneed to point temp_tablespaces to a USB drive or something. But here we go.\\n\\nIt looks like there was a regression when sorting random text, with 256 \\nMB work_mem. I suspect that was a fluke - I only ran these tests once \\nbecause they took so long. But I don't know for sure.\\n\\nClaudio, if you could also repeat the tests you ran on Peter's patch set \\non the other thread, with these patches, that'd be nice. These patches \\nare effectively a replacement for \\n0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review \\nwould be much appreciated too, of course.\\n\\nAttached are new versions. Compared to last set, they contain a few \\ncomment fixes, and a change to the 2nd patch to not allocate tape \\nbuffers for tapes that were completely unused.\\n\\n- Heikki\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 9 Sep 2016 14:13:49 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/09/2016 02:13 PM, Heikki Linnakangas wrote:\\n> On 09/08/2016 09:59 PM, Heikki Linnakangas wrote:\\n>> On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\\n>>> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>>>> Offhand, I would think that taken together this is very important. I'd\\n>>>> certainly want to see cases in the hundreds of megabytes or gigabytes\\n>>>> of work_mem alongside your 4MB case, even just to be able to talk\\n>>>> informally about this. As you know, the default work_mem value is very\\n>>>> conservative.\\n>>\\n>> I spent some more time polishing this up, and also added some code to\\n>> logtape.c, to use larger read buffers, to compensate for the fact that\\n>> we don't do pre-reading from tuplesort.c anymore. That should trigger\\n>> the OS read-ahead, and make the I/O more sequential, like was the\\n>> purpose of the old pre-reading code. But simpler. I haven't tested that\\n>> part much yet, but I plan to run some tests on larger data sets that\\n>> don't fit in RAM, to make the I/O effects visible.\\n>\\n> Ok, I ran a few tests with 20 GB tables. I thought this would show any\\n> differences in I/O behaviour, but in fact it was still completely CPU\\n> bound, like the tests on smaller tables I posted yesterday. I guess I\\n> need to point temp_tablespaces to a USB drive or something. But here we go.\\n\\nI took a different tact at demonstrating the I/O pattern effects. I \\nadded some instrumentation code to logtape.c, that prints a line to a \\nfile whenever it reads a block, with the block number. I ran the same \\nquery with master and with these patches, and plotted the access pattern \\nwith gnuplot.\\n\\nI'm happy with what it looks like. We are in fact getting a more \\nsequential access pattern with these patches, because we're not \\nexpanding the pre-read tuples into SortTuples. Keeping densely-packed \\nblocks in memory, instead of SortTuples, allows caching more data overall.\\n\\nAttached is the patch I used to generate these traces, the gnuplot \\nscript, and traces from I got from sorting a 1 GB table of random \\nintegers, with work_mem=16MB.\\n\\nNote that in the big picture, what appear to be individual dots, are \\nactually clusters of a bunch of dots. So the access pattern is a lot \\nmore sequential than it looks like at first glance, with or without \\nthese patches. The zoomed-in pictures show that. If you want to inspect \\nthese in more detail, I recommend running gnuplot in interactive mode, \\nso that you can zoom in and out easily.\\n\\nI'm happy with the amount of testing I've done now, and the results. \\nDoes anyone want to throw out any more test cases where there might be a \\nregression? If not, let's get these reviewed and committed.\\n\\n- Heikki\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 9 Sep 2016 14:55:40 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"(Resending with compressed files, to get below the message size limit of \\nthe list)\\n\\nOn 09/09/2016 02:13 PM, Heikki Linnakangas wrote:\\n> On 09/08/2016 09:59 PM, Heikki Linnakangas wrote:\\n>> On 09/06/2016 10:26 PM, Peter Geoghegan wrote:\\n>>> On Tue, Sep 6, 2016 at 12:08 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>>>> Offhand, I would think that taken together this is very important. I'd\\n>>>> certainly want to see cases in the hundreds of megabytes or gigabytes\\n>>>> of work_mem alongside your 4MB case, even just to be able to talk\\n>>>> informally about this. As you know, the default work_mem value is very\\n>>>> conservative.\\n>>\\n>> I spent some more time polishing this up, and also added some code to\\n>> logtape.c, to use larger read buffers, to compensate for the fact that\\n>> we don't do pre-reading from tuplesort.c anymore. That should trigger\\n>> the OS read-ahead, and make the I/O more sequential, like was the\\n>> purpose of the old pre-reading code. But simpler. I haven't tested that\\n>> part much yet, but I plan to run some tests on larger data sets that\\n>> don't fit in RAM, to make the I/O effects visible.\\n>\\n> Ok, I ran a few tests with 20 GB tables. I thought this would show any\\n> differences in I/O behaviour, but in fact it was still completely CPU\\n> bound, like the tests on smaller tables I posted yesterday. I guess I\\n> need to point temp_tablespaces to a USB drive or something. But here we go.\\n\\nI took a different tact at demonstrating the I/O pattern effects. I \\nadded some instrumentation code to logtape.c, that prints a line to a \\nfile whenever it reads a block, with the block number. I ran the same \\nquery with master and with these patches, and plotted the access pattern \\nwith gnuplot.\\n\\nI'm happy with what it looks like. We are in fact getting a more \\nsequential access pattern with these patches, because we're not \\nexpanding the pre-read tuples into SortTuples. Keeping densely-packed \\nblocks in memory, instead of SortTuples, allows caching more data overall.\\n\\nAttached is the patch I used to generate these traces, the gnuplot \\nscript, and traces from I got from sorting a 1 GB table of random \\nintegers, with work_mem=16MB.\\n\\nNote that in the big picture, what appear to be individual dots, are \\nactually clusters of a bunch of dots. So the access pattern is a lot \\nmore sequential than it looks like at first glance, with or without \\nthese patches. The zoomed-in pictures show that. If you want to inspect \\nthese in more detail, I recommend running gnuplot in interactive mode, \\nso that you can zoom in and out easily.\\n\\nI'm happy with the amount of testing I've done now, and the results. \\nDoes anyone want to throw out any more test cases where there might be a \\nregression? If not, let's get these reviewed and committed.\\n\\n- Heikki\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 9 Sep 2016 15:01:06 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 1:01 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> I'm happy with what it looks like. We are in fact getting a more sequential\\n> access pattern with these patches, because we're not expanding the pre-read\\n> tuples into SortTuples. Keeping densely-packed blocks in memory, instead of\\n> SortTuples, allows caching more data overall.\\n\\n\\nWow, this is really cool. We should do something like this for query\\nexecution too.\\n\\nI still didn't follow exactly why removing the prefetching allows more\\nsequential i/o. I thought the whole point of prefetching was to reduce\\nthe random i/o from switching tapes.\\n\\n-- \\ngreg\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 9 Sep 2016 13:25:29 +0100\",\n \"msg_from\": \"Greg Stark <stark@mit.edu>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/09/2016 03:25 PM, Greg Stark wrote:\\n> On Fri, Sep 9, 2016 at 1:01 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> I'm happy with what it looks like. We are in fact getting a more sequential\\n>> access pattern with these patches, because we're not expanding the pre-read\\n>> tuples into SortTuples. Keeping densely-packed blocks in memory, instead of\\n>> SortTuples, allows caching more data overall.\\n>\\n>\\n> Wow, this is really cool. We should do something like this for query\\n> execution too.\\n>\\n> I still didn't follow exactly why removing the prefetching allows more\\n> sequential i/o. I thought the whole point of prefetching was to reduce\\n> the random i/o from switching tapes.\\n\\nThe first patch removed prefetching, but the second patch re-introduced \\nit, in a different form. The prefetching is now done in logtape.c, by \\nreading multiple pages at a time. The on-tape representation of tuples \\nis more compact than having them in memory as SortTuples, so you can fit \\nmore data in memory overall, which makes the access pattern more sequential.\\n\\nThere's one difference between these approaches that I didn't point out \\nearlier: We used to prefetch tuples from each *run*, and stopped \\npre-reading when we reached the end of the run. Now that we're doing the \\nprefetching as raw tape blocks, we don't stop at run boundaries. I don't \\nthink that makes any big difference one way or another, but I thought \\nI'd mention it.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 9 Sep 2016 15:48:46 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 4:55 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> I'm happy with the amount of testing I've done now, and the results. Does\\n> anyone want to throw out any more test cases where there might be a\\n> regression? If not, let's get these reviewed and committed.\\n\\nI'll try to look at this properly tomorrow. Currently still working\\naway at creating a new revision of my sorting patchset. Obviously this\\nis interesting, but it raises certain questions for the parallel\\nCREATE INDEX patch in particular that I'd like to get straight, aside\\nfrom everything else.\\n\\nI've been using an AWS d2.4xlarge instance for testing all my recent\\nsort patches, with 16 vCPUs, 122 GiB RAM, 12 x 2 TB disks. It worked\\nwell to emphasize I/O throughput and parallelism over latency. I'd\\nlike to investigate how this pre-reading stuff does there. I recall\\nthat for one very large case, it took a full minute to do just the\\nfirst round of preloading during the leader's final merge (this was\\nwith something like 50GB of maintenance_work_mem). So, it will be\\ninteresting.\\n\\nBTW, noticed a typo here:\\n\\n> + * track memory usage of indivitual tuples.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 9 Sep 2016 09:50:22 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 5:25 AM, Greg Stark <stark@mit.edu> wrote:\\n> Wow, this is really cool. We should do something like this for query\\n> execution too.\\n\\nWe should certainly do this for tuplestore.c, too. I've been meaning\\nto adopt it to use batch memory. I did look at it briefly, and recall\\nthat it was surprisingly awkward because a surprisingly large number\\nof callers want to have memory that they can manage independently of\\nthe lifetime of their tuplestore.\\n\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 9 Sep 2016 10:22:38 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>\\n> Claudio, if you could also repeat the tests you ran on Peter's patch set on\\n> the other thread, with these patches, that'd be nice. These patches are\\n> effectively a replacement for\\n> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\\n> would be much appreciated too, of course.\\n>\\n> Attached are new versions. Compared to last set, they contain a few comment\\n> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\\n> that were completely unused.\\n\\n\\nWill do so\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 9 Sep 2016 21:51:08 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>\\n>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\\n>> the other thread, with these patches, that'd be nice. These patches are\\n>> effectively a replacement for\\n>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\\n>> would be much appreciated too, of course.\\n>>\\n>> Attached are new versions. Compared to last set, they contain a few comment\\n>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\\n>> that were completely unused.\\n>\\n>\\n> Will do so\\n\\nIt seems both 1 and 1+2 break make check.\\n\\nDid I misunderstand something? I'm applying the first patch of Peter's\\nseries (cap number of tapes), then your first one (remove prefetch)\\nand second one (use larger read buffers).\\n\\nPeter's patch needs some rebasing on top of those but nothing major.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 9 Sep 2016 22:21:58 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/10/2016 04:21 AM, Claudio Freire wrote:\\n> On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>>\\n>>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\\n>>> the other thread, with these patches, that'd be nice. These patches are\\n>>> effectively a replacement for\\n>>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\\n>>> would be much appreciated too, of course.\\n>>>\\n>>> Attached are new versions. Compared to last set, they contain a few comment\\n>>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\\n>>> that were completely unused.\\n>>\\n>> Will do so\\n\\nThanks!\\n\\n> It seems both 1 and 1+2 break make check.\\n\\nOh. Works for me. What's the failure you're getting?\\n\\n> Did I misunderstand something? I'm applying the first patch of Peter's\\n> series (cap number of tapes), then your first one (remove prefetch)\\n> and second one (use larger read buffers).\\n\\nYes. I have been testing without Peter's first patch, with just the two \\npatches I posted. But it should work together (and does, I just tested) \\nwith that one as well.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 10 Sep 2016 10:04:02 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Sat, Sep 10, 2016 at 12:04 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Did I misunderstand something? I'm applying the first patch of Peter's\\n>> series (cap number of tapes), then your first one (remove prefetch)\\n>> and second one (use larger read buffers).\\n>\\n>\\n> Yes. I have been testing without Peter's first patch, with just the two\\n> patches I posted. But it should work together (and does, I just tested) with\\n> that one as well.\\n\\nYou're going to need to rebase, since the root displace patch is based\\non top of my patch 0002-*, not Heikki's alternative. But, that should\\nbe very straightforward.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 10 Sep 2016 12:09:41 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"Here's a new version of these patches, rebased over current master. I \\nsquashed the two patches into one, there's not much point to keep them \\nseparate.\\n\\n- Heikki\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sun, 11 Sep 2016 18:47:21 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 11, 2016 at 8:47 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Here's a new version of these patches, rebased over current master. I\\n> squashed the two patches into one, there's not much point to keep them\\n> separate.\\n\\nI think I have my head fully around this now. For some reason, I\\ninitially thought that this patch was a great deal more radical than\\nit actually is. (Like Greg, I somehow initially thought that you were\\nrejecting the idea of batch memory in general, and somehow (over)\\nleveraging the filesystem cache. I think I misunderstood your remarks\\nwhen we talked on IM about it early on.)\\n\\nI don't know what the difference is between accessing 10 pages\\nrandomly, and accessing a random set of 10 single pages sequentially,\\nin close succession. As Tom would say, that's above my pay grade. I\\nsuppose it comes down to how close \\\"close\\\" actually is (but in any\\ncase, it's all very fudged).\\n\\nI mention this because I think that cost_sort() should be updated to\\nconsider sequential I/O the norm, alongside this patch of yours (your\\npatch strengthens the argument [1] for that general idea). The reason\\nthat this new approach produces more sequential I/O, apart from the\\nsimple fact that you effectively have much more memory available and\\nso fewer rounds of preloading, is that the indirection block stuff can\\nmake I/O less sequential in order to support eager reclamation of\\nspace. For example, maybe there is interleaving of blocks as logtape.c\\nmanages to reclaim blocks in the event of multiple merge steps. I care\\nabout that second factor a lot more now than I would have a year ago,\\nwhen a final on-the-fly merge generally avoids multiple passes (and\\nassociated logtape.c block fragmentation), because parallel CREATE\\nINDEX is usually affected by that (workers will often want to do their\\nown merge ahead of the leader's final merge), and because I want to\\ncap the number of tapes used, which will make multiple passes a bit\\nmore common in practice.\\n\\nI was always suspicious of the fact that memtuples is so large during\\nmerging, and had a vague plan to fix that (although I was the one\\nresponsible for growing memtuples even more for the merge in 9.6, that\\nwas just because under the status quo of having many memtuples during\\nthe merge, the size of memtuples should at least be in balance with\\nremaining memory for caller tuples -- it wasn't an endorsement of the\\nstatus quo). However, it never occurred to me to do that by pushing\\nbatch memory into the head of logtape.c, which now seems like an\\nexcellent idea.\\n\\nTo summarize my understanding of this patch: If it wasn't for my work\\non parallel CREATE INDEX, I would consider this patch to give us only\\na moderate improvement to user-visible performance, since it doesn't\\nreally help memory rich cases very much (cases that are not likely to\\nhave much random I/O anyway). In that universe, I'd be more\\nappreciative of the patch as a simplifying exercise, since while\\nrefactoring. It's nice to get a boost for more memory constrained\\ncases, it's not a huge win. However, that's not the universe we live\\nin -- I *am* working on parallel CREATE INDEX, of course. And so, I\\nreally am very excited about this patch, because it really helps with\\nthe particular challenges I have there, even though it's fair to\\nassume that we have a reasonable amount of memory available when\\nparallelism is used. If workers are going to do their own merges, as\\nthey often will, then multiple merge pass cases become far more\\nimportant, and any additional I/O is a real concern, *especially*\\nadditional random I/O (say from logtape.c fragmentation). The patch\\ndirectly addresses that, which is great. Your patch, alongside my\\njust-committed patch concerning how we maintain the heap invariant,\\ntogether attack the merge bottleneck from two different directions:\\nthey address I/O costs, and CPU costs, respectively.\\n\\nOther things I noticed:\\n\\n* You should probably point out that typically, access to batch memory\\nwill still be sequential, despite your block-based scheme. The\\npreloading will now more or less make that the normal case. Any\\nfragmentation will now be essentially in memory, not on disk, which is\\na big win.\\n\\n* I think that logtape.c header comments are needed for this. Maybe\\nthat's where you should point out that memory access is largely\\nsequential. But it's surely true that logtape.c needs to take\\nresponsibility for being the place where the vast majority of memory\\nis allocated during merging.\\n\\n* i think you should move \\\"bool *mergeactive; /* active input run\\nsource? */\\\" within Tuplesortstate to be next to the other batch memory\\nstuff. No point in having separate merge and batch \\\"sections\\\" there\\nanymore.\\n\\n* You didn't carry over my 0002-* batch memory patch modifications to\\ncomments, even though you should have in a few cases. There remains\\nsome references in comments to batch memory, as a thing exclusively\\nusable by final on-the-fly merges. That's not true anymore -- it's\\nusable by final merges, too. For example, readtup_alloc() still\\nreferences the final on-the-fly merge.\\n\\n* You also fail to take credit in the commit message for making batch\\nmemory usable when returning caller tuples to callers that happen to\\nrequest \\\"randomAccess\\\" (So, I guess the aforementioned comments above\\nroutines like readtup_alloc() shouldn't even refer to merging, unless\\nit's to say that non-final merges are not supported due to their\\nunusual requirements). My patch didn't go that far (I only addressed\\nthe final merge itself, not the subsequent access to tuples when\\nreading from that materialized final output tape by TSS_SORTEDONTAPE\\ncase). But, that's actually really useful for randomAccess callers,\\nabove and beyond what I proposed (which in any case was mostly written\\nwith parallel workers in mind, which never do TSS_SORTEDONTAPE\\nprocessing).\\n\\n* Furthermore, readtup_alloc() will not just be called in WRITETUP()\\nroutines -- please update comments.\\n\\n* There is a very subtle issue here:\\n\\n> + /*\\n> + * We no longer need a large memtuples array, only one slot per tape. Shrink\\n> + * it, to make the memory available for other use. We only need one slot per\\n> + * tape.\\n> + */\\n> + pfree(state->memtuples);\\n> + FREEMEM(state, state->memtupsize * sizeof(SortTuple));\\n> + state->memtupsize = state->maxTapes;\\n> + state->memtuples = (SortTuple *) palloc(state->maxTapes * sizeof(SortTuple));\\n> + USEMEM(state, state->memtupsize * sizeof(SortTuple));\\n\\nThe FREEMEM() call needs to count the chunk overhead in both cases. In\\nshort, I think you need to copy the GetMemoryChunkSpace() stuff that\\nyou see within grow_memtuples().\\n\\n* Whitespace issue here:\\n\\n> @@ -2334,7 +2349,8 @@ inittapes(Tuplesortstate *state)\\n> #endif\\n>\\n> /*\\n> - * Decrease availMem to reflect the space needed for tape buffers; but\\n> + * Decrease availMem to reflect the space needed for tape buffers, when\\n> + * writing the initial runs; but\\n> * don't decrease it to the point that we have no room for tuples. (That\\n> * case is only likely to occur if sorting pass-by-value Datums; in all\\n> * other scenarios the memtuples[] array is unlikely to occupy more than\\n> @@ -2359,14 +2375,6 @@ inittapes(Tuplesortstate *state)\\n> state->tapeset = LogicalTapeSetCreate(maxTapes);\\n\\n* I think that you need to comment on why state->tuplecontext is not\\nused for batch memory now. It is still useful, for multiple merge\\npasses, but the situation has notably changed for it.\\n\\n* Doesn't this code need to call MemoryContextAllocHuge() rather than palloc()?:\\n\\n> @@ -709,18 +765,19 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)\\n> Assert(lt->frozen);\\n> datablocknum = ltsRewindFrozenIndirectBlock(lts, lt->indirect);\\n> }\\n> +\\n> + /* Allocate a read buffer */\\n> + if (lt->buffer)\\n> + pfree(lt->buffer);\\n> + lt->buffer = palloc(lt->read_buffer_size);\\n> + lt->buffer_size = lt->read_buffer_size;\\n\\n* Typo:\\n\\n> +\\n> + /*\\n> + * from this point on, we no longer use the usemem()/lackmem() mechanism to\\n> + * track memory usage of indivitual tuples.\\n> + */\\n> + state->batchused = true;\\n\\n* Please make this use the \\\".., + 1023\\\" natural rounding trick that is\\nused in the similar traces that are removed:\\n\\n> +#ifdef TRACE_SORT\\n> + if (trace_sort)\\n> + elog(LOG, \\\"using %d kB of memory for read buffers in %d tapes, %d kB per tape\\\",\\n> + (int) (state->availMem / 1024), maxTapes, (int) (per_tape * BLCKSZ) / 1024);\\n> +#endif\\n\\n* It couldn't hurt to make this code paranoid about LACKMEM() becoming\\ntrue, which will cause havoc (we saw this recently in 9.6; a patch of\\nmine to fix that just went in):\\n\\n> + /*\\n> + * Use all the spare memory we have available for read buffers. Divide it\\n> + * memory evenly among all the tapes.\\n> + */\\n> + avail_blocks = state->availMem / BLCKSZ;\\n> + per_tape = avail_blocks / maxTapes;\\n> + cutoff = avail_blocks % maxTapes;\\n> + if (per_tape == 0)\\n> + {\\n> + per_tape = 1;\\n> + cutoff = 0;\\n> + }\\n> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\\n> + {\\n> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\\n> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\\n> + }\\n\\nIn other words, we really don't want availMem to become < 0, since\\nit's int64, but a derived value is passed to\\nLogicalTapeAssignReadBufferSize() as an argument of type \\\"Size\\\". Now,\\nif LACKMEM() did happen it would be a bug anyway, but I recommend\\ndefensive code also be added. Per grow_memtuples(), \\\"We need to be\\nsure that we do not cause LACKMEM to become true, else the space\\nmanagement algorithm will go nuts\\\". Let's be sure that we get that\\nright, since, as we saw recently, especially since grow_memtuples()\\nwill not actually have the chance to save us here (if there is a bug\\nalong these lines, let's at least make the right \\\"can't happen error\\\"\\ncomplaint to user when it pops up).\\n\\n* It looks like your patch makes us less eager about freeing per-tape\\nbatch memory, now held as preload buffer space within logtape.c.\\n\\nISTM that there should be some way to have the \\\"tape exhausted\\\" code\\npath within tuplesort_gettuple_common() (as well as the similar spot\\nwithin mergeonerun()) instruct logtape.c that we're done with that\\ntape. In other words, when mergeprereadone() (now renamed to\\nmergereadnext()) detects the tape is exhausted, it should have\\nlogtape.c free its huge tape buffer immediately. Think about cases\\nwhere input is presorted, and earlier tapes can be freed quite early\\non. It's worth keeping that around, (you removed the old way that this\\nhappened, through mergebatchfreetape()).\\n\\nThat's all I have right now. I like the direction this is going in,\\nbut I think this needs more polishing.\\n\\n[1] https://www.postgresql.org/message-id/CAM3SWZQLP6e=1si1NcQjYft7R-VYpprrf_i59tZOZX5m7VFK-w@mail.gmail.com\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 11 Sep 2016 15:13:55 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n> * Please make this use the \\\".., + 1023\\\" natural rounding trick that is\\n> used in the similar traces that are removed:\\n>\\n>> +#ifdef TRACE_SORT\\n>> + if (trace_sort)\\n>> + elog(LOG, \\\"using %d kB of memory for read buffers in %d tapes, %d kB per tape\\\",\\n>> + (int) (state->availMem / 1024), maxTapes, (int) (per_tape * BLCKSZ) / 1024);\\n>> +#endif\\n\\nAlso, please remove the int cast, and use INT64_FORMAT. Again, this\\nshould match existing trace_sort traces concerning batch memory.\\n\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 11 Sep 2016 15:34:17 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n> * Doesn't this code need to call MemoryContextAllocHuge() rather than palloc()?:\\n>\\n>> @@ -709,18 +765,19 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)\\n>> Assert(lt->frozen);\\n>> datablocknum = ltsRewindFrozenIndirectBlock(lts, lt->indirect);\\n>> }\\n>> +\\n>> + /* Allocate a read buffer */\\n>> + if (lt->buffer)\\n>> + pfree(lt->buffer);\\n>> + lt->buffer = palloc(lt->read_buffer_size);\\n>> + lt->buffer_size = lt->read_buffer_size;\\n\\nOf course, when you do that you're going to have to make the new\\n\\\"buffer_size\\\" and \\\"read_buffer_size\\\" fields of type \\\"Size\\\" (or,\\npossibly, \\\"int64\\\", to match tuplesort.c's own buffer sizing variables\\never since Noah added MaxAllocSizeHuge). Ditto for the existing \\\"pos\\\"\\nand \\\"nbytes\\\" fields next to \\\"buffer_size\\\" within the struct\\nLogicalTape, I think. ISTM that logtape.c blocknums can remain of type\\n\\\"long\\\", though, since that reflects an existing hardly-relevant\\nlimitation that you're not making any worse.\\n\\nMore generally, I think you also need to explain in comments why there\\nis a \\\"read_buffer_size\\\" field in addition to the \\\"buffer_size\\\" field.\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 11 Sep 2016 15:59:18 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\\n>> + {\\n>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\\n>> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\\n>> + }\\n\\nSpotted another issue with this code just now. Shouldn't it be based\\non state->tapeRange? You don't want the destTape to get memory, since\\nyou don't use batch memory for tapes that are written to (and final\\non-the-fly merges don't use their destTape at all).\\n\\n(Looks again...)\\n\\nWait, you're using a local variable maxTapes here, which potentially\\ndiffers from state->maxTapes:\\n\\n> + /*\\n> + * If we had fewer runs than tapes, refund buffers for tapes that were never\\n> + * allocated.\\n> + */\\n> + maxTapes = state->maxTapes;\\n> + if (state->currentRun < maxTapes)\\n> + {\\n> + FREEMEM(state, (maxTapes - state->currentRun) * TAPE_BUFFER_OVERHEAD);\\n> + maxTapes = state->currentRun;\\n> + }\\n\\nI find this confusing, and think it's probably buggy. I don't think\\nyou should have a local variable called maxTapes that you modify at\\nall, since state->maxTapes is supposed to not change once established.\\nYou can't use state->currentRun like that, either, I think, because\\nit's the high watermark number of runs (quicksorted runs), not runs\\nafter any particular merge phase, where we end up with fewer runs as\\nthey're merged (we must also consider dummy runs to get this) -- we\\nwant something like activeTapes. cf. the code you removed for the\\nbeginmerge() finalMergeBatch case. Of course, activeTapes will vary if\\nthere are multiple merge passes, which suggests all this code really\\nhas no business being in mergeruns() (it should instead be in\\nbeginmerge(), or code that beginmerge() reliably calls).\\n\\nImmediately afterwards, you do this:\\n\\n> + /* Initialize the merge tuple buffer arena. */\\n> + state->batchMemoryBegin = palloc((maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\\n> + state->batchMemoryEnd = state->batchMemoryBegin + (maxTapes + 1) * MERGETUPLEBUFFER_SIZE;\\n> + state->freeBufferHead = (MergeTupleBuffer *) state->batchMemoryBegin;\\n> + USEMEM(state, (maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\\n\\nThe fact that you size the buffer based on \\\"maxTapes + 1\\\" also\\nsuggests a problem. I think that the code looks like this because it\\nmust instruct logtape.c that the destTape tape requires some buffer\\n(iff there is to be a non-final merge). Is that right? I hope that you\\ndon't give the typically unused destTape tape a full share of batch\\nmemory all the time (the same applies to any other\\ninactive-at-final-merge tapes).\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 11 Sep 2016 16:39:54 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 12/09/16 10:13, Peter Geoghegan wrote:\\n> On Sun, Sep 11, 2016 at 8:47 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n[...]\\n> I don't know what the difference is between accessing 10 pages\\n> randomly, and accessing a random set of 10 single pages sequentially,\\n> in close succession. As Tom would say, that's above my pay grade. I\\n> suppose it comes down to how close \\\"close\\\" actually is (but in any\\n> case, it's all very fudged).\\n\\nIf you select ten pages at random and sort them, then consecutive reads \\nof the sorted list are more likely to access pages in the same block or \\nclosely adjacent (is my understanding).\\n\\neg\\n\\nblocks: XXXX XXXX XXXX XXXX XXXX\\npages: 0 1 2 3 4 5 6 7 8 9\\n\\nif the ten 'random pages' were selected in the random order:\\n6 1 7 8 4 2 9 3 0\\nConsecutive reads would always read new blocks, but the sorted list \\nwould have blocks read sequentially.\\n\\nIn practice, it would be rarely this simple. However, if any of the \\nrandom pages where in the same block, then that block would only need to \\nbe fetched once - similarly if 2 of the random pages where in \\nconsecutive blocks, then the two blocks would be logically adjacent \\n(which means they are likely to be physically close together, but not \\nguaranteed!).\\n\\n[...]\\n\\n\\nCheers,\\nGavin\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 12 Sep 2016 12:16:23 +1200\",\n \"msg_from\": \"Gavin Flower <GavinFlower@archidevsys.co.nz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 12/09/16 12:16, Gavin Flower wrote:\\n[...]\\n> two blocks would be logically adjacent (which means they are likely \\n> to be physically close together, but not guaranteed!).\\n>\\n[...]\\n\\nActual disk layouts are quite complicated, the above is an over \\nsimplification, but the message is still valid.\\n\\nThere are various tricks of disc layout ( & low level handling) that can \\nbe used to minimise the time taken to read 2 blocks that are logically \\nadjacent. I had to know this stuff for discs that MainFrame computers \\nused in the 1980's - modern disk systems are way more complicated, but \\nthe conclusions are still valid.\\n\\nI am extremely glad that I no longer have to concern myself with \\nunderstanding the precise low stuff on discs these days - there is no \\nlonger a one-to-one correspondence of what the O/S thinks is a disk \\nblock, with how the data is physically recorded on the disc.\\n\\n\\nCheers,\\nGavin\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 12 Sep 2016 12:34:48 +1200\",\n \"msg_from\": \"Gavin Flower <GavinFlower@archidevsys.co.nz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 11, 2016 at 12:47 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Here's a new version of these patches, rebased over current master. I\\n> squashed the two patches into one, there's not much point to keep them\\n> separate.\\n\\n\\nI don't know what was up with the other ones, but this one works fine.\\n\\nBenchmarking now.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 12 Sep 2016 12:02:53 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 12, 2016 at 12:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Sun, Sep 11, 2016 at 12:47 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Here's a new version of these patches, rebased over current master. I\\n>> squashed the two patches into one, there's not much point to keep them\\n>> separate.\\n>\\n>\\n> I don't know what was up with the other ones, but this one works fine.\\n>\\n> Benchmarking now.\\n\\n\\nI spoke too soon, git AM had failed and I didn't notice.\\n\\nregression.diffs attached\\n\\nBuilt with\\n\\n./configure --enable-debug --enable-cassert && make clean && make -j7\\n&& make check\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 12 Sep 2016 12:47:28 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 12, 2016 at 8:47 AM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> I spoke too soon, git AM had failed and I didn't notice.\\n\\nI wrote the regression test that causes Postgres to crash with the\\npatch applied. It tests, among other things, that CLUSTER tuples are\\nfixed-up by a routine like the current MOVETUP(), which is removed in\\nHeikki's patch. (There was a 9.6 bug where CLUSTER was broken due to\\nthat.)\\n\\nIt shouldn't be too difficult for Heikki to fix this.\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 12 Sep 2016 08:51:59 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/12/2016 06:47 PM, Claudio Freire wrote:\\n> On Mon, Sep 12, 2016 at 12:02 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Sun, Sep 11, 2016 at 12:47 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>> Here's a new version of these patches, rebased over current master. I\\n>>> squashed the two patches into one, there's not much point to keep them\\n>>> separate.\\n>>\\n>> I don't know what was up with the other ones, but this one works fine.\\n>>\\n>> Benchmarking now.\\n>\\n> I spoke too soon, git AM had failed and I didn't notice.\\n>\\n> regression.diffs attached\\n>\\n> Built with\\n>\\n> ./configure --enable-debug --enable-cassert && make clean && make -j7\\n> && make check\\n\\nAh, of course! I had been building without assertions, as I was doing \\nperformance testing. With --enable-cassert, it failed for me as well \\n(and there was even a compiler warning pointing out one of the issues). \\nSorry about that.\\n\\nHere's a fixed version. I'll go through Peter's comments and address \\nthose, but I don't think there was anything there that should affect \\nperformance much, so I think you can proceed with your benchmarking with \\nthis version. (You'll also need to turn off assertions for that!)\\n\\n- Heikki\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 12 Sep 2016 22:07:40 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 12, 2016 at 12:07 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Here's a fixed version. I'll go through Peter's comments and address those,\\n> but I don't think there was anything there that should affect performance\\n> much, so I think you can proceed with your benchmarking with this version.\\n> (You'll also need to turn off assertions for that!)\\n\\nI agree that it's unlikely that addressing any of my feedback will\\nresult in any major change to performance.\\n\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 12 Sep 2016 12:09:22 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"Addressed all your comments one way or another, new patch attached. \\nComments on some specific points below:\\n\\nOn 09/12/2016 01:13 AM, Peter Geoghegan wrote:\\n> Other things I noticed:\\n>\\n> * You should probably point out that typically, access to batch memory\\n> will still be sequential, despite your block-based scheme. The\\n> preloading will now more or less make that the normal case. Any\\n> fragmentation will now be essentially in memory, not on disk, which is\\n> a big win.\\n\\nThat's not true, the \\\"buffers\\\" in batch memory are not accessed \\nsequentially. When we pull the next tuple from a tape, we store it in \\nthe next free buffer. Usually, that buffer was used to hold the previous \\ntuple that was returned from gettuple(), and was just added to the free \\nlist.\\n\\nIt's still quite cache-friendly, though, because we only need a small \\nnumber of slots (one for each tape).\\n\\n> * i think you should move \\\"bool *mergeactive; /* active input run\\n> source? */\\\" within Tuplesortstate to be next to the other batch memory\\n> stuff. No point in having separate merge and batch \\\"sections\\\" there\\n> anymore.\\n\\nHmm. I think I prefer to keep the memory management stuff in a separate \\nsection. While it's true that it's currently only used during merging, \\nit's not hard to imagine using it when building the initial runs, for \\nexample. Except for replacement selection, the pattern for building the \\nruns is: add a bunch of tuples, sort, flush them out. It would be \\nstraightforward to use one large chunk of memory to hold all the tuples. \\nI'm not going to do that now, but I think keeping the memory management \\nstuff separate from merge-related state makes sense.\\n\\n> * I think that you need to comment on why state->tuplecontext is not\\n> used for batch memory now. It is still useful, for multiple merge\\n> passes, but the situation has notably changed for it.\\n\\nHmm. We don't actually use it after the initial runs at all anymore. I \\nadded a call to destroy it in mergeruns().\\n\\nNow that we use the batch memory buffers for allocations < 1 kB (I \\npulled that number out of a hat, BTW), and we only need one allocation \\nper tape (plus one), there's not much risk of fragmentation.\\n\\n> On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>> * Doesn't this code need to call MemoryContextAllocHuge() rather than palloc()?:\\n>>\\n>>> @@ -709,18 +765,19 @@ LogicalTapeRewind(LogicalTapeSet *lts, int tapenum, bool forWrite)\\n>>> Assert(lt->frozen);\\n>>> datablocknum = ltsRewindFrozenIndirectBlock(lts, lt->indirect);\\n>>> }\\n>>> +\\n>>> + /* Allocate a read buffer */\\n>>> + if (lt->buffer)\\n>>> + pfree(lt->buffer);\\n>>> + lt->buffer = palloc(lt->read_buffer_size);\\n>>> + lt->buffer_size = lt->read_buffer_size;\\n>\\n> Of course, when you do that you're going to have to make the new\\n> \\\"buffer_size\\\" and \\\"read_buffer_size\\\" fields of type \\\"Size\\\" (or,\\n> possibly, \\\"int64\\\", to match tuplesort.c's own buffer sizing variables\\n> ever since Noah added MaxAllocSizeHuge). Ditto for the existing \\\"pos\\\"\\n> and \\\"nbytes\\\" fields next to \\\"buffer_size\\\" within the struct\\n> LogicalTape, I think. ISTM that logtape.c blocknums can remain of type\\n> \\\"long\\\", though, since that reflects an existing hardly-relevant\\n> limitation that you're not making any worse.\\n\\nTrue. I fixed that by putting a MaxAllocSize cap on the buffer size \\ninstead. I doubt that doing > 1 GB of read-ahead of a single tape will \\ndo any good.\\n\\nI wonder if we should actually have a smaller cap there. Even 1 GB seems \\nexcessive. Might be better to start the merging sooner, rather than wait \\nfor the read of 1 GB to complete. The point of the OS readahead is that \\nthe OS will do that for us, in the background. And other processes might \\nhave better use for the memory anyway.\\n\\n> * It couldn't hurt to make this code paranoid about LACKMEM() becoming\\n> true, which will cause havoc (we saw this recently in 9.6; a patch of\\n> mine to fix that just went in):\\n>\\n>> + /*\\n>> + * Use all the spare memory we have available for read buffers. Divide it\\n>> + * memory evenly among all the tapes.\\n>> + */\\n>> + avail_blocks = state->availMem / BLCKSZ;\\n>> + per_tape = avail_blocks / maxTapes;\\n>> + cutoff = avail_blocks % maxTapes;\\n>> + if (per_tape == 0)\\n>> + {\\n>> + per_tape = 1;\\n>> + cutoff = 0;\\n>> + }\\n>> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\\n>> + {\\n>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\\n>> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\\n>> + }\\n>\\n> In other words, we really don't want availMem to become < 0, since\\n> it's int64, but a derived value is passed to\\n> LogicalTapeAssignReadBufferSize() as an argument of type \\\"Size\\\". Now,\\n> if LACKMEM() did happen it would be a bug anyway, but I recommend\\n> defensive code also be added. Per grow_memtuples(), \\\"We need to be\\n> sure that we do not cause LACKMEM to become true, else the space\\n> management algorithm will go nuts\\\". Let's be sure that we get that\\n> right, since, as we saw recently, especially since grow_memtuples()\\n> will not actually have the chance to save us here (if there is a bug\\n> along these lines, let's at least make the right \\\"can't happen error\\\"\\n> complaint to user when it pops up).\\n\\nHmm. We don't really need the availMem accounting at all, after we have \\nstarted merging. There is nothing we can do to free memory if we run \\nout, and we use fairly little memory anyway. But yes, better safe than \\nsorry. I tried to clarify the comments on that.\\n\\n> * It looks like your patch makes us less eager about freeing per-tape\\n> batch memory, now held as preload buffer space within logtape.c.\\n>\\n> ISTM that there should be some way to have the \\\"tape exhausted\\\" code\\n> path within tuplesort_gettuple_common() (as well as the similar spot\\n> within mergeonerun()) instruct logtape.c that we're done with that\\n> tape. In other words, when mergeprereadone() (now renamed to\\n> mergereadnext()) detects the tape is exhausted, it should have\\n> logtape.c free its huge tape buffer immediately. Think about cases\\n> where input is presorted, and earlier tapes can be freed quite early\\n> on. It's worth keeping that around, (you removed the old way that this\\n> happened, through mergebatchfreetape()).\\n\\nOK. I solved that by calling LogicalTapeRewind(), when we're done \\nreading a tape. Rewinding a tape has the side-effect of freeing the \\nbuffer. I was going to put that into mergereadnext(), but it turns out \\nthat it's tricky to figure out if there are any more runs on the same \\ntape, because we have the \\\"actual\\\" tape number there, but the tp_runs is \\nindexed by \\\"logical\\\" tape number. So I put the rewind calls at the end \\nof mergeruns(), and in TSS_FINALMERGE processing, instead. It means that \\nwe don't free the buffers quite as early as we could, but I think this \\nis good enough.\\n\\n> On Sun, Sep 11, 2016 at 3:13 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>>> + for (tapenum = 0; tapenum < maxTapes; tapenum++)\\n>>> + {\\n>>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\\n>>> + (per_tape + (tapenum < cutoff ? 1 : 0)) * BLCKSZ);\\n>>> + }\\n>\\n> Spotted another issue with this code just now. Shouldn't it be based\\n> on state->tapeRange? You don't want the destTape to get memory, since\\n> you don't use batch memory for tapes that are written to (and final\\n> on-the-fly merges don't use their destTape at all).\\n\\nlogtape.c will only actually allocate the memory when reading.\\n\\n> (Looks again...)\\n>\\n> Wait, you're using a local variable maxTapes here, which potentially\\n> differs from state->maxTapes:\\n>\\n>> + /*\\n>> + * If we had fewer runs than tapes, refund buffers for tapes that were never\\n>> + * allocated.\\n>> + */\\n>> + maxTapes = state->maxTapes;\\n>> + if (state->currentRun < maxTapes)\\n>> + {\\n>> + FREEMEM(state, (maxTapes - state->currentRun) * TAPE_BUFFER_OVERHEAD);\\n>> + maxTapes = state->currentRun;\\n>> + }\\n>\\n> I find this confusing, and think it's probably buggy. I don't think\\n> you should have a local variable called maxTapes that you modify at\\n> all, since state->maxTapes is supposed to not change once established.\\n\\nI changed that so that it does actually change state->maxTapes. I \\nconsidered having a separate numTapes field, that can be smaller than \\nmaxTapes, but we don't need the original maxTapes value after that point \\nanymore, so it would've been just pro forma to track them separately. I \\nhope the comment now explains that better.\\n\\n> You can't use state->currentRun like that, either, I think, because\\n> it's the high watermark number of runs (quicksorted runs), not runs\\n> after any particular merge phase, where we end up with fewer runs as\\n> they're merged (we must also consider dummy runs to get this) -- we\\n> want something like activeTapes. cf. the code you removed for the\\n> beginmerge() finalMergeBatch case. Of course, activeTapes will vary if\\n> there are multiple merge passes, which suggests all this code really\\n> has no business being in mergeruns() (it should instead be in\\n> beginmerge(), or code that beginmerge() reliably calls).\\n\\nHmm, yes, using currentRun here is wrong. It needs to be \\\"currentRun + \\n1\\\", because we need one more tape than there are runs, to hold the output.\\n\\nNote that I'm not re-allocating the read buffers depending on which \\ntapes are used in the current merge pass. I'm just dividing up the \\nmemory among all tapes. Now that the pre-reading is done in logtape.c, \\nwhen we reach the end of a run on a tape, we will already have data from \\nthe next run on the same tape in the read buffer.\\n\\n> Immediately afterwards, you do this:\\n>\\n>> + /* Initialize the merge tuple buffer arena. */\\n>> + state->batchMemoryBegin = palloc((maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\\n>> + state->batchMemoryEnd = state->batchMemoryBegin + (maxTapes + 1) * MERGETUPLEBUFFER_SIZE;\\n>> + state->freeBufferHead = (MergeTupleBuffer *) state->batchMemoryBegin;\\n>> + USEMEM(state, (maxTapes + 1) * MERGETUPLEBUFFER_SIZE);\\n>\\n> The fact that you size the buffer based on \\\"maxTapes + 1\\\" also\\n> suggests a problem. I think that the code looks like this because it\\n> must instruct logtape.c that the destTape tape requires some buffer\\n> (iff there is to be a non-final merge). Is that right? I hope that you\\n> don't give the typically unused destTape tape a full share of batch\\n> memory all the time (the same applies to any other\\n> inactive-at-final-merge tapes).\\n\\nAh, no, the \\\"+ 1\\\" comes from the need to hold the tuple that we last \\nreturned to the caller in tuplesort_gettuple, until the next call. See \\nlastReturnedTuple. I tried to clarify the comments on that.\\n\\nThanks for the thorough review! Let me know how this looks now.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 14 Sep 2016 20:43:36 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Addressed all your comments one way or another, new patch attached. Comments\\n> on some specific points below:\\n\\nCool. My response here is written under time pressure, which is not\\nideal. I think it's still useful, though.\\n\\n>> * You should probably point out that typically, access to batch memory\\n>> will still be sequential, despite your block-based scheme.\\n\\n> That's not true, the \\\"buffers\\\" in batch memory are not accessed\\n> sequentially. When we pull the next tuple from a tape, we store it in the\\n> next free buffer. Usually, that buffer was used to hold the previous tuple\\n> that was returned from gettuple(), and was just added to the free list.\\n>\\n> It's still quite cache-friendly, though, because we only need a small number\\n> of slots (one for each tape).\\n\\nThat's kind of what I meant, I think -- it's more or less sequential.\\nEspecially in the common case where there is only one merge pass.\\n\\n> True. I fixed that by putting a MaxAllocSize cap on the buffer size instead.\\n> I doubt that doing > 1 GB of read-ahead of a single tape will do any good.\\n\\nYou may well be right about that, but ideally that could be verified.\\nI think that the tuplesort is entitled to have whatever memory the\\nuser makes available, unless that's almost certainly useless. It\\ndoesn't seem like our job to judge that it's always wrong to use extra\\nmemory with only a small expected benefit. If it's actually a\\nmicroscopic expected benefit, or just as often negative to the sort\\noperation's performance, then I'd say it's okay to cap it at\\nMaxAllocSize. But it's not obvious to me that this is true; not yet,\\nanyway.\\n\\n> Hmm. We don't really need the availMem accounting at all, after we have\\n> started merging. There is nothing we can do to free memory if we run out,\\n> and we use fairly little memory anyway. But yes, better safe than sorry. I\\n> tried to clarify the comments on that.\\n\\nIt is true that we don't really care about the accounting at all. But,\\nthe same applies to the existing grow_memtuples() case at the\\nbeginning of merging. The point is, we *do* care about availMem, this\\none last time. We must at least produce a sane (i.e. >= 0) number in\\nany calculation. (I think you understand this already -- just saying.)\\n\\n> OK. I solved that by calling LogicalTapeRewind(), when we're done reading a\\n> tape. Rewinding a tape has the side-effect of freeing the buffer. I was\\n> going to put that into mergereadnext(), but it turns out that it's tricky to\\n> figure out if there are any more runs on the same tape, because we have the\\n> \\\"actual\\\" tape number there, but the tp_runs is indexed by \\\"logical\\\" tape\\n> number. So I put the rewind calls at the end of mergeruns(), and in\\n> TSS_FINALMERGE processing, instead. It means that we don't free the buffers\\n> quite as early as we could, but I think this is good enough.\\n\\nThat seems adequate.\\n\\n>> Spotted another issue with this code just now. Shouldn't it be based\\n>> on state->tapeRange? You don't want the destTape to get memory, since\\n>> you don't use batch memory for tapes that are written to (and final\\n>> on-the-fly merges don't use their destTape at all).\\n\\n>> Wait, you're using a local variable maxTapes here, which potentially\\n>> differs from state->maxTapes:\\n\\n> I changed that so that it does actually change state->maxTapes. I considered\\n> having a separate numTapes field, that can be smaller than maxTapes, but we\\n> don't need the original maxTapes value after that point anymore, so it\\n> would've been just pro forma to track them separately. I hope the comment\\n> now explains that better.\\n\\nI still don't get why you're doing all of this within mergeruns() (the\\nbeginning of when we start merging -- we merge all quicksorted runs),\\nrather than within beginmerge() (the beginning of one particular merge\\npass, of which there are potentially more than one). As runs are\\nmerged in a non-final merge pass, fewer tapes will remain active for\\nthe next merge pass. It doesn't do to do all that up-front when we\\nhave multiple merge passes, which will happen from time to time.\\n\\nCorrect me if I'm wrong, but I think that you're more skeptical of the\\nneed for polyphase merge than I am. I at least see no reason to not\\nkeep it around. I also think it has some value. It doesn't make this\\noptimization any harder, really.\\n\\n> Hmm, yes, using currentRun here is wrong. It needs to be \\\"currentRun + 1\\\",\\n> because we need one more tape than there are runs, to hold the output.\\n\\nAs I said, I think it should be the number of active tapes, as you see\\ntoday within beginmerge() + mergebatch(). Why not do it that way? If\\nyou don't get the distinction, see my remarks below on final merges\\nalways using batch memory, even when there are to be multiple merge\\npasses (no reason to add that restriction here). More generally, I\\nreally don't want to mess with the long standing definition of\\nmaxTapes and things like that, because I see no advantage.\\n\\n> Ah, no, the \\\"+ 1\\\" comes from the need to hold the tuple that we last\\n> returned to the caller in tuplesort_gettuple, until the next call. See\\n> lastReturnedTuple. I tried to clarify the comments on that.\\n\\nI see. I don't think that you need to do any of that. Just have the\\nsizing be based on an even share among activeTapes on final merges\\n(not necessarily final on-the-fly merges, per my 0002-* patch --\\nyou've done that here, it looks like). However, It looks like you're\\ndoing the wrong thing by only having the check at the top of\\nbeginmerge() -- \\\"if (state->Level == 1)\\\". You're not going to use\\nbatch memory for the final merge just because there happened to be\\nmultiple merges, that way. Sure, you shouldn't be using batch memory\\nfor non-final merges (due to their need for an uneven amount of memory\\nper active tape), which you're not doing, but the mere fact that you\\nhad a non-final merge should not affect the final merge at all. Which\\nis the kind of thing I'm concerned about when I talk about\\nbeginmerge() being the right place for all that new code (not\\nmergeruns()). Even if you can make it work, it fits a lot better to\\nput it in beginmerge() -- that's the existing flow of things, which\\nshould be preserved. I don't think you need to examine \\\"state->Level\\\"\\nor \\\"state->currentRun\\\" at all.\\n\\nDid you do it this way to make the \\\"replacement selection best case\\\"\\nstuff within mergeruns() catch on, so it does the right thing during\\nits TSS_SORTEDONTAPE processing?\\n\\nThanks\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 12:12:43 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/15/2016 10:12 PM, Peter Geoghegan wrote:\\n> On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>> Spotted another issue with this code just now. Shouldn't it be based\\n>>> on state->tapeRange? You don't want the destTape to get memory, since\\n>>> you don't use batch memory for tapes that are written to (and final\\n>>> on-the-fly merges don't use their destTape at all).\\n>\\n>>> Wait, you're using a local variable maxTapes here, which potentially\\n>>> differs from state->maxTapes:\\n>\\n>> I changed that so that it does actually change state->maxTapes. I considered\\n>> having a separate numTapes field, that can be smaller than maxTapes, but we\\n>> don't need the original maxTapes value after that point anymore, so it\\n>> would've been just pro forma to track them separately. I hope the comment\\n>> now explains that better.\\n>\\n> I still don't get why you're doing all of this within mergeruns() (the\\n> beginning of when we start merging -- we merge all quicksorted runs),\\n> rather than within beginmerge() (the beginning of one particular merge\\n> pass, of which there are potentially more than one). As runs are\\n> merged in a non-final merge pass, fewer tapes will remain active for\\n> the next merge pass. It doesn't do to do all that up-front when we\\n> have multiple merge passes, which will happen from time to time.\\n\\nNow that the pre-reading is done in logtape.c, it doesn't stop at a run \\nboundary. For example, when we read the last 1 MB of the first run on a \\ntape, and we're using a 10 MB read buffer, we will merrily also read the \\nfirst 9 MB from the next run. You cannot un-read that data, even if the \\ntape is inactive in the next merge pass.\\n\\nI don't think it makes much difference in practice, because most merge \\npasses use all, or almost all, of the available tapes. BTW, I think the \\npolyphase algorithm prefers to do all the merges that don't use all \\ntapes upfront, so that the last final merge always uses all the tapes. \\nI'm not 100% sure about that, but that's my understanding of the \\nalgorithm, and that's what I've seen in my testing.\\n\\n> Correct me if I'm wrong, but I think that you're more skeptical of the\\n> need for polyphase merge than I am. I at least see no reason to not\\n> keep it around. I also think it has some value. It doesn't make this\\n> optimization any harder, really.\\n\\nWe certainly still need multi-pass merges.\\n\\nBTW, does a 1-way merge make any sense? I was surprised to see this in \\nthe log, even without this patch:\\n\\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \\nBY i) t;\\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \\nBY i) t;\\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \\nBY i) t;\\nLOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \\nBY i) t;\\nLOG: finished 3-way merge step: CPU 0.62s/7.23u sec elapsed 8.44 sec\\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \\nBY i) t;\\nLOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.44 sec\\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \\nBY i) t;\\nLOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.45 sec\\nSTATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER \\nBY i) t;\\n\\n- Heikki\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 23:51:19 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 1:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> I still don't get why you're doing all of this within mergeruns() (the\\n>> beginning of when we start merging -- we merge all quicksorted runs),\\n>> rather than within beginmerge() (the beginning of one particular merge\\n>> pass, of which there are potentially more than one). As runs are\\n>> merged in a non-final merge pass, fewer tapes will remain active for\\n>> the next merge pass. It doesn't do to do all that up-front when we\\n>> have multiple merge passes, which will happen from time to time.\\n>\\n>\\n> Now that the pre-reading is done in logtape.c, it doesn't stop at a run\\n> boundary. For example, when we read the last 1 MB of the first run on a\\n> tape, and we're using a 10 MB read buffer, we will merrily also read the\\n> first 9 MB from the next run. You cannot un-read that data, even if the tape\\n> is inactive in the next merge pass.\\n\\nI'm not sure that I like that approach. At the very least, it seems to\\nnot be a good fit with the existing structure of things. I need to\\nthink about it some more, and study how that plays out in practice.\\n\\n> BTW, does a 1-way merge make any sense?\\n\\nNot really, no, but it's something that I've seen plenty of times.\\n\\nThis is seen when runs are distributed such that mergeonerun() only\\nfinds one real run on all active tapes, with all other active tapes\\nhaving only dummy runs. In general, dummy runs are \\\"logically merged\\\"\\n(decremented) in preference to any real runs on the same tape (that's\\nthe reason why they exist), so you end up with what we call a \\\"1-way\\nmerge\\\" when you see one real one on one active tape only. You never\\nsee something like \\\"0-way merge\\\" within trace_sort output, though,\\nbecause that case is optimized to be almost a no-op.\\n\\nIt's almost a no-op because when it happens then mergeruns() knows to\\nitself directly decrement the number of dummy runs once for each\\nactive tape, making that \\\"logical merge\\\" completed with only that\\nsimple change in metadata (that is, the \\\"merge\\\" completes by just\\ndecrementing dummy run counts -- no actual call to mergeonerun()).\\n\\nWe could optimize away \\\"1-way merge\\\" cases, perhaps, so that tuples\\ndon't have to be spilt out one at a time (there could perhaps instead\\nbe just some localized change to metadata, a bit like the all-dummy\\ncase). That doesn't seem worth bothering with, especially with this\\nnew approach of yours. I prefer to avoid special cases like that.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 14:07:25 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 1:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> BTW, does a 1-way merge make any sense? I was surprised to see this in the\\n> log, even without this patch:\\n>\\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\\n> i) t;\\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\\n> i) t;\\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\\n> i) t;\\n> LOG: finished 1-way merge step: CPU 0.62s/7.22u sec elapsed 8.43 sec\\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\\n> i) t;\\n> LOG: finished 3-way merge step: CPU 0.62s/7.23u sec elapsed 8.44 sec\\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\\n> i) t;\\n> LOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.44 sec\\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\\n> i) t;\\n> LOG: finished 6-way merge step: CPU 0.62s/7.24u sec elapsed 8.45 sec\\n> STATEMENT: SELECT COUNT(*) FROM (SELECT * FROM medium.random_ints ORDER BY\\n> i) t;\\n\\nAnother thing that I think it worth pointing out here is that the\\nnumber of merge passes shown is excessive, practically speaking. I\\nsuggested that we have something like checkpoint_warning for this last\\nyear, which Greg Stark eventually got behind, but Robert Haas didn't\\nseem to like. Maybe this idea should be revisited. What do you think?\\n\\nThere is no neat explanation for why it's considered excessive to\\ncheckpoint every 10 seconds, but not every 2 minutes. But, we warn\\nabout the former case by default, and not the latter. It's hard to\\nknow exactly where to draw the line, but that isn't a great reason to\\nnot do it (maybe one extra merge pass is a good threshold -- that's\\nwhat I suggested once). I think that other database systems similarly\\nsurface multiple merge passes. It's just inefficient to ever do\\nmultiple merge passes, even if you're very frugal with memory.\\nCertainly, it's almost impossible to defend doing 3+ passes these\\ndays.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Sep 2016 14:26:01 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Addressed all your comments one way or another, new patch attached.\\n\\nSo, it's clear that this isn't ready today. As I mentioned, I'm going\\naway for a week now. I ask that you hold off on committing this until\\nI return, and have a better opportunity to review the performance\\ncharacteristics of this latest revision, for one thing.\\n\\nThanks\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 17 Sep 2016 09:27:44 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/17/2016 07:27 PM, Peter Geoghegan wrote:\\n> On Wed, Sep 14, 2016 at 10:43 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Addressed all your comments one way or another, new patch attached.\\n>\\n> So, it's clear that this isn't ready today. As I mentioned, I'm going\\n> away for a week now. I ask that you hold off on committing this until\\n> I return, and have a better opportunity to review the performance\\n> characteristics of this latest revision, for one thing.\\n\\nOk. I'll probably read through it myself once more some time next week, \\nand also have a first look at your actual parallel sorting patch. Have a \\ngood trip!\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 17 Sep 2016 19:41:22 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Sat, Sep 17, 2016 at 9:41 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Ok. I'll probably read through it myself once more some time next week, and\\n> also have a first look at your actual parallel sorting patch. Have a good\\n> trip!\\n\\nThanks! It will be good to get away for a while.\\n\\nI'd be delighted to recruit you to work on the parallel CREATE INDEX\\npatch. I've already explained how I think this preread patch of yours\\nworks well with parallel tuplesort (as proposed) in particular. To\\nreiterate: while what you've come up with here is technically an\\nindependent improvement to merging, it's much more valuable in the\\noverall context of parallel sort, where disproportionate wall clock\\ntime is spent merging, and where multiple passes are the norm (one\\npass in each worker, plus one big final pass in the leader process\\nalone -- logtape.c fragmentation becomes a real issue). The situation\\nis actually similar to the original batch memory preloading patch that\\nwent into 9.6 (which your new patch supersedes), and the subsequently\\ncommitted quicksort for external sort patch (which my new patch\\nextends to work in parallel).\\n\\nBecause I think of your preload patch as a part of the overall\\nparallel CREATE INDEX effort, if that was the limit of your\\ninvolvement then I'd still think it fair to credit you as my\\nco-author. I hope it isn't the limit of your involvement, though,\\nbecause it seems likely that the final result will be better still if\\nyou get involved with the big patch that formally introduces parallel\\nCREATE INDEX.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 17 Sep 2016 11:49:42 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>\\n>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\\n>> the other thread, with these patches, that'd be nice. These patches are\\n>> effectively a replacement for\\n>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\\n>> would be much appreciated too, of course.\\n>>\\n>> Attached are new versions. Compared to last set, they contain a few comment\\n>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\\n>> that were completely unused.\\n>\\n>\\n> Will do so\\n\\nWell, here they are, the results.\\n\\nODS format only (unless you've got issues opening the ODS).\\n\\nThe results seem all over the map. Some regressions seem significant\\n(both in the amount of performance lost and their significance, since\\nall 4 runs show a similar regression). The worst being \\\"CREATE INDEX\\nix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\\\" with 4GB\\nwork_mem, which should be an in-memory sort, which makes it odd.\\n\\nI will re-run it overnight just in case to confirm the outcome.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 20 Sep 2016 15:34:29 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 20, 2016 at 3:34 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Fri, Sep 9, 2016 at 9:51 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> On Fri, Sep 9, 2016 at 8:13 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>>\\n>>> Claudio, if you could also repeat the tests you ran on Peter's patch set on\\n>>> the other thread, with these patches, that'd be nice. These patches are\\n>>> effectively a replacement for\\n>>> 0002-Use-tuplesort-batch-memory-for-randomAccess-sorts.patch. And review\\n>>> would be much appreciated too, of course.\\n>>>\\n>>> Attached are new versions. Compared to last set, they contain a few comment\\n>>> fixes, and a change to the 2nd patch to not allocate tape buffers for tapes\\n>>> that were completely unused.\\n>>\\n>>\\n>> Will do so\\n>\\n> Well, here they are, the results.\\n>\\n> ODS format only (unless you've got issues opening the ODS).\\n>\\n> The results seem all over the map. Some regressions seem significant\\n> (both in the amount of performance lost and their significance, since\\n> all 4 runs show a similar regression). The worst being \\\"CREATE INDEX\\n> ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\\\" with 4GB\\n> work_mem, which should be an in-memory sort, which makes it odd.\\n>\\n> I will re-run it overnight just in case to confirm the outcome.\\n\\nA new run for \\\"patched\\\" gives better results, it seems it was some\\nkind of glitch in the run (maybe some cron decided to do something\\nwhile running those queries).\\n\\nAttached\\n\\nIn essence, it doesn't look like it's harmfully affecting CPU\\nefficiency. Results seem neutral on the CPU front.\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 21 Sep 2016 21:40:23 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/22/2016 03:40 AM, Claudio Freire wrote:\\n> On Tue, Sep 20, 2016 at 3:34 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> The results seem all over the map. Some regressions seem significant\\n>> (both in the amount of performance lost and their significance, since\\n>> all 4 runs show a similar regression). The worst being \\\"CREATE INDEX\\n>> ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\\\" with 4GB\\n>> work_mem, which should be an in-memory sort, which makes it odd.\\n>>\\n>> I will re-run it overnight just in case to confirm the outcome.\\n>\\n> A new run for \\\"patched\\\" gives better results, it seems it was some\\n> kind of glitch in the run (maybe some cron decided to do something\\n> while running those queries).\\n>\\n> Attached\\n>\\n> In essence, it doesn't look like it's harmfully affecting CPU\\n> efficiency. Results seem neutral on the CPU front.\\n\\nLooking at the spreadsheet, there is a 40% slowdown in the \\\"slow\\\" \\n\\\"CREATE INDEX ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\\\" \\ntest with 4GB of work_mem. I can't reproduce that on my laptop, though. \\nGot any clue what's going on there?\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 22 Sep 2016 10:17:06 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 22, 2016 at 4:17 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> On 09/22/2016 03:40 AM, Claudio Freire wrote:\\n>>\\n>> On Tue, Sep 20, 2016 at 3:34 PM, Claudio Freire <klaussfreire@gmail.com>\\n>> wrote:\\n>>>\\n>>> The results seem all over the map. Some regressions seem significant\\n>>> (both in the amount of performance lost and their significance, since\\n>>> all 4 runs show a similar regression). The worst being \\\"CREATE INDEX\\n>>> ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\\\" with 4GB\\n>>> work_mem, which should be an in-memory sort, which makes it odd.\\n>>>\\n>>> I will re-run it overnight just in case to confirm the outcome.\\n>>\\n>>\\n>> A new run for \\\"patched\\\" gives better results, it seems it was some\\n>> kind of glitch in the run (maybe some cron decided to do something\\n>> while running those queries).\\n>>\\n>> Attached\\n>>\\n>> In essence, it doesn't look like it's harmfully affecting CPU\\n>> efficiency. Results seem neutral on the CPU front.\\n>\\n>\\n> Looking at the spreadsheet, there is a 40% slowdown in the \\\"slow\\\" \\\"CREATE\\n> INDEX ix_lotsofitext_zz2ijw ON lotsofitext (z, z2, i, j, w);\\\" test with 4GB\\n> of work_mem. I can't reproduce that on my laptop, though. Got any clue\\n> what's going on there?\\n\\nIt's not present in other runs, so I think it's a fluke the\\nspreadsheet isn't filtering out. Especially considering that one\\nshould be a fully in-memory fast sort and thus unaffected by the\\ncurrent patch (z and z2 being integers, IIRC, most comparisons should\\nbe about comparing the first columns and thus rarely involve the big\\nstrings).\\n\\nI'll try to confirm that's the case though.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 22 Sep 2016 05:00:18 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 15, 2016 at 9:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> I still don't get why you're doing all of this within mergeruns() (the\\n>> beginning of when we start merging -- we merge all quicksorted runs),\\n>> rather than within beginmerge() (the beginning of one particular merge\\n>> pass, of which there are potentially more than one). As runs are\\n>> merged in a non-final merge pass, fewer tapes will remain active for\\n>> the next merge pass. It doesn't do to do all that up-front when we\\n>> have multiple merge passes, which will happen from time to time.\\n>\\n>\\n> Now that the pre-reading is done in logtape.c, it doesn't stop at a run\\n> boundary. For example, when we read the last 1 MB of the first run on a\\n> tape, and we're using a 10 MB read buffer, we will merrily also read the\\n> first 9 MB from the next run. You cannot un-read that data, even if the tape\\n> is inactive in the next merge pass.\\n\\nI've had a chance to think about this some more. I did a flying review\\nof the same revision that I talk about here, but realized some more\\nthings. First, I will do a recap.\\n\\n> I don't think it makes much difference in practice, because most merge\\n> passes use all, or almost all, of the available tapes. BTW, I think the\\n> polyphase algorithm prefers to do all the merges that don't use all tapes\\n> upfront, so that the last final merge always uses all the tapes. I'm not\\n> 100% sure about that, but that's my understanding of the algorithm, and\\n> that's what I've seen in my testing.\\n\\nNot sure that I understand. I agree that each merge pass tends to use\\nroughly the same number of tapes, but the distribution of real runs on\\ntapes is quite unbalanced in earlier merge passes (due to dummy runs).\\nIt looks like you're always using batch memory, even for non-final\\nmerges. Won't that fail to be in balance much of the time because of\\nthe lopsided distribution of runs? Tapes have an uneven amount of real\\ndata in earlier merge passes.\\n\\nFWIW, polyphase merge actually doesn't distribute runs based on the\\nFibonacci sequence (at least in Postgres). It uses a generalization of\\nthe Fibonacci numbers [1] -- *which* generalization varies according\\nto merge order/maxTapes. IIRC, with Knuth's P == 6 (i.e. merge order\\n== 6), it's the \\\"hexanacci\\\" sequence.\\n\\nThe following code is from your latest version, posted on 2016-09-14,\\nwithin the high-level mergeruns() function (the function that takes\\nquicksorted runs, and produces final output following 1 or more merge\\npasses):\\n\\n> + usedBlocks = 0;\\n> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\\n> + {\\n> + int64 numBlocks = blocksPerTape + (tapenum < remainder ? 1 : 0);\\n> +\\n> + if (numBlocks > MaxAllocSize / BLCKSZ)\\n> + numBlocks = MaxAllocSize / BLCKSZ;\\n> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\\n> + numBlocks * BLCKSZ);\\n> + usedBlocks += numBlocks;\\n> + }\\n> + USEMEM(state, usedBlocks * BLCKSZ);\\n\\nI'm basically repeating myself here, but: I think it's incorrect that\\nLogicalTapeAssignReadBufferSize() is called so indiscriminately (more\\ngenerally, it is questionable that it is called in such a high level\\nroutine, rather than the start of a specific merge pass -- I said so a\\ncouple of times already).\\n\\nIt's weird that you change the meaning of maxTapes by reassigning in\\nadvance of iterating through maxTapes like this. I should point out\\nagain that the master branch mergebatch() function does roughly the\\nsame thing as you're doing here as follows:\\n\\nstatic void\\nmergebatch(Tuplesortstate *state, int64 spacePerTape)\\n{\\n int srcTape;\\n\\n Assert(state->activeTapes > 0);\\n Assert(state->tuples);\\n\\n /*\\n * For the purposes of tuplesort's memory accounting, the batch allocation\\n * is special, and regular memory accounting through USEMEM() calls is\\n * abandoned (see mergeprereadone()).\\n */\\n for (srcTape = 0; srcTape < state->maxTapes; srcTape++)\\n {\\n char *mergetuples;\\n\\n if (!state->mergeactive[srcTape])\\n continue;\\n\\n /* Allocate buffer for each active tape */\\n mergetuples = MemoryContextAllocHuge(state->tuplecontext,\\n spacePerTape);\\n\\n /* Initialize state for tape */\\n state->mergetuples[srcTape] = mergetuples;\\n state->mergecurrent[srcTape] = mergetuples;\\n state->mergetail[srcTape] = mergetuples;\\n state->mergeoverflow[srcTape] = NULL;\\n }\\n\\n state->batchUsed = true;\\n state->spacePerTape = spacePerTape;\\n}\\n\\nNotably, this function:\\n\\n* Works without altering the meaning of maxTapes. state->maxTapes is\\nKnuth's T, which is established very early and doesn't change with\\npolyphase merge (same applies to state->tapeRange). What does change\\nacross merge passes is the number of *active* tapes. I don't think\\nit's necessary to change that in any way. I find it very confusing.\\n(Also, that you're using state->currentRun here at all seems bad, for\\nmore or less the same reason -- that's the number of quicksorted\\nruns.)\\n\\n* Does allocation for the final merge (that's the only point that it's\\ncalled), and so is not based on the number of active tapes that happen\\nto be in play when merging begins at a high level (i.e., when\\nmergeruns() is first called). Many tapes will be totally inactive by\\nthe final merge, so this seems completely necessary for multiple merge\\npass cases.\\n\\nEnd of recap. Here is some new information:\\n\\nI was previously confused on this last point, because I thought that\\nlogtape.c might be able to do something smart to recycle memory that\\nis bound per-tape by calls to LogicalTapeAssignReadBufferSize() in\\nyour patch. But it doesn't: all the recycling stuff only happens for\\nthe much smaller buffers that are juggled and reused to pass tuples\\nback to caller within tuplesort_gettuple_common(), etc -- not the\\nlogtape.c managed buffers. So, AFAICT there is no justification that I\\ncan see for not adopting these notable properties of mergebatch() for\\nsome analogous point in this patch. Actually, you should probably not\\nget rid of mergebatch(), but instead call\\nLogicalTapeAssignReadBufferSize() there. This change would mean that\\nthe big per-tape memory allocations would happen in the same place as\\nbefore -- you'd just be asking logtape.c to do it for you, instead of\\nallocating directly.\\n\\nPerhaps the practical consequences of not doing something closer to\\nmergebatch() are debatable, but I suspect that there is little point\\nin actually debating it. I think you might as well do it that way. No?\\n\\n[1] http://mathworld.wolfram.com/Fibonaccin-StepNumber.html\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 28 Sep 2016 16:05:41 +0100\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/28/2016 06:05 PM, Peter Geoghegan wrote:\\n> On Thu, Sep 15, 2016 at 9:51 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> I don't think it makes much difference in practice, because most merge\\n>> passes use all, or almost all, of the available tapes. BTW, I think the\\n>> polyphase algorithm prefers to do all the merges that don't use all tapes\\n>> upfront, so that the last final merge always uses all the tapes. I'm not\\n>> 100% sure about that, but that's my understanding of the algorithm, and\\n>> that's what I've seen in my testing.\\n>\\n> Not sure that I understand. I agree that each merge pass tends to use\\n> roughly the same number of tapes, but the distribution of real runs on\\n> tapes is quite unbalanced in earlier merge passes (due to dummy runs).\\n> It looks like you're always using batch memory, even for non-final\\n> merges. Won't that fail to be in balance much of the time because of\\n> the lopsided distribution of runs? Tapes have an uneven amount of real\\n> data in earlier merge passes.\\n\\nHow does the distribution of the runs on the tapes matter?\\n\\n>> + usedBlocks = 0;\\n>> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\\n>> + {\\n>> + int64 numBlocks = blocksPerTape + (tapenum < remainder ? 1 : 0);\\n>> +\\n>> + if (numBlocks > MaxAllocSize / BLCKSZ)\\n>> + numBlocks = MaxAllocSize / BLCKSZ;\\n>> + LogicalTapeAssignReadBufferSize(state->tapeset, tapenum,\\n>> + numBlocks * BLCKSZ);\\n>> + usedBlocks += numBlocks;\\n>> + }\\n>> + USEMEM(state, usedBlocks * BLCKSZ);\\n>\\n> I'm basically repeating myself here, but: I think it's incorrect that\\n> LogicalTapeAssignReadBufferSize() is called so indiscriminately (more\\n> generally, it is questionable that it is called in such a high level\\n> routine, rather than the start of a specific merge pass -- I said so a\\n> couple of times already).\\n\\nYou can't release the tape buffer at the end of a pass, because the \\nbuffer of a tape will already be filled with data from the next run on \\nthe same tape.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 28 Sep 2016 19:04:48 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 28, 2016 at 5:04 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Not sure that I understand. I agree that each merge pass tends to use\\n>> roughly the same number of tapes, but the distribution of real runs on\\n>> tapes is quite unbalanced in earlier merge passes (due to dummy runs).\\n>> It looks like you're always using batch memory, even for non-final\\n>> merges. Won't that fail to be in balance much of the time because of\\n>> the lopsided distribution of runs? Tapes have an uneven amount of real\\n>> data in earlier merge passes.\\n>\\n>\\n> How does the distribution of the runs on the tapes matter?\\n\\nThe exact details are not really relevant to this discussion (I think\\nit's confusing that we simply say \\\"Target Fibonacci run counts\\\",\\nFWIW), but the simple fact that it can be quite uneven is.\\n\\nThis is why I never pursued batch memory for non-final merges. Isn't\\nthat what you're doing here? You're pretty much always setting\\n\\\"state->batchUsed = true\\\".\\n\\n>> I'm basically repeating myself here, but: I think it's incorrect that\\n>> LogicalTapeAssignReadBufferSize() is called so indiscriminately (more\\n>> generally, it is questionable that it is called in such a high level\\n>> routine, rather than the start of a specific merge pass -- I said so a\\n>> couple of times already).\\n>\\n>\\n> You can't release the tape buffer at the end of a pass, because the buffer\\n> of a tape will already be filled with data from the next run on the same\\n> tape.\\n\\nOkay, but can't you just not use batch memory for non-final merges,\\nper my initial approach? That seems far cleaner.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 28 Sep 2016 17:11:52 +0100\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 28, 2016 at 5:11 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n> This is why I never pursued batch memory for non-final merges. Isn't\\n> that what you're doing here? You're pretty much always setting\\n> \\\"state->batchUsed = true\\\".\\n\\nWait. I guess you feel you have to, since it wouldn't be okay to use\\nalmost no memory per tape on non-final merges.\\n\\nYou're able to throw out so much code here in large part because you\\ngive almost all memory over to logtape.c (e.g., you don't manage each\\ntape's share of \\\"slots\\\" anymore -- better to give everything to\\nlogtape.c). So, with your patch, you would actually only have one\\ncaller tuple in memory at once per tape for a merge that doesn't use\\nbatch memory (if you made it so that a merge *could* avoid the use of\\nbatch memory, as I suggest).\\n\\nIn summary, under your scheme, the \\\"batchUsed\\\" variable contains a\\ntautological value, since you cannot sensibly not use batch memory.\\n(This is even true with !state->tuples callers).\\n\\nDo I have that right? If so, this seems rather awkward. Hmm.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 28 Sep 2016 17:20:23 +0100\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/28/2016 07:11 PM, Peter Geoghegan wrote:\\n> On Wed, Sep 28, 2016 at 5:04 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>>> Not sure that I understand. I agree that each merge pass tends to use\\n>>> roughly the same number of tapes, but the distribution of real runs on\\n>>> tapes is quite unbalanced in earlier merge passes (due to dummy runs).\\n>>> It looks like you're always using batch memory, even for non-final\\n>>> merges. Won't that fail to be in balance much of the time because of\\n>>> the lopsided distribution of runs? Tapes have an uneven amount of real\\n>>> data in earlier merge passes.\\n>>\\n>>\\n>> How does the distribution of the runs on the tapes matter?\\n>\\n> The exact details are not really relevant to this discussion (I think\\n> it's confusing that we simply say \\\"Target Fibonacci run counts\\\",\\n> FWIW), but the simple fact that it can be quite uneven is.\\n\\nWell, I claim that the fact that the distribution of runs is uneven, \\ndoes not matter. Can you explain why you think it does?\\n\\n> This is why I never pursued batch memory for non-final merges. Isn't\\n> that what you're doing here? You're pretty much always setting\\n> \\\"state->batchUsed = true\\\".\\n\\nYep. As the patch stands, we wouldn't really need batchUsed, as we know \\nthat it's always true when merging, and false otherwise. But I kept it, \\nas it seems like that might not always be true - we might use batch \\nmemory when building the initial runs, for example - and because it \\nseems nice to have an explicit flag for it, for readability and \\ndebugging purposes.\\n\\n>>> I'm basically repeating myself here, but: I think it's incorrect that\\n>>> LogicalTapeAssignReadBufferSize() is called so indiscriminately (more\\n>>> generally, it is questionable that it is called in such a high level\\n>>> routine, rather than the start of a specific merge pass -- I said so a\\n>>> couple of times already).\\n>>\\n>>\\n>> You can't release the tape buffer at the end of a pass, because the buffer\\n>> of a tape will already be filled with data from the next run on the same\\n>> tape.\\n>\\n> Okay, but can't you just not use batch memory for non-final merges,\\n> per my initial approach? That seems far cleaner.\\n\\nWhy? I don't see why the final merge should behave differently from the \\nnon-final ones.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 28 Sep 2016 21:12:26 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/28/2016 07:20 PM, Peter Geoghegan wrote:\\n> On Wed, Sep 28, 2016 at 5:11 PM, Peter Geoghegan <pg@heroku.com> wrote:\\n>> This is why I never pursued batch memory for non-final merges. Isn't\\n>> that what you're doing here? You're pretty much always setting\\n>> \\\"state->batchUsed = true\\\".\\n>\\n> Wait. I guess you feel you have to, since it wouldn't be okay to use\\n> almost no memory per tape on non-final merges.\\n>\\n> You're able to throw out so much code here in large part because you\\n> give almost all memory over to logtape.c (e.g., you don't manage each\\n> tape's share of \\\"slots\\\" anymore -- better to give everything to\\n> logtape.c). So, with your patch, you would actually only have one\\n> caller tuple in memory at once per tape for a merge that doesn't use\\n> batch memory (if you made it so that a merge *could* avoid the use of\\n> batch memory, as I suggest).\\n\\nCorrect.\\n\\n> In summary, under your scheme, the \\\"batchUsed\\\" variable contains a\\n> tautological value, since you cannot sensibly not use batch memory.\\n> (This is even true with !state->tuples callers).\\n\\nI suppose.\\n\\n> Do I have that right? If so, this seems rather awkward. Hmm.\\n\\nHow is it awkward?\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 29 Sep 2016 12:49:27 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 29, 2016 at 10:49 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Do I have that right? If so, this seems rather awkward. Hmm.\\n>\\n>\\n> How is it awkward?\\n\\nMaybe that was the wrong choice of words. What I mean is that it seems\\nsomewhat unprincipled to give over an equal share of memory to each\\nactive-at-least-once tape, regardless of how much that matters in\\npractice. One tape could have several runs in memory at once, while\\nanother only has a fraction of a single much larger run. Maybe this is\\njust the first time that I find myself on the *other* side of a\\ndiscussion about an algorithm that seems brute-force compared to what\\nit might replace, but is actually better overall. :-)\\n\\nNow, that could be something that I just need to get over. In any\\ncase, I still think:\\n\\n* Variables like maxTapes have a meaning that is directly traceable\\nback to Knuth's description of polyphase merge. I don't think that you\\nshould do anything to them, on general principle.\\n\\n* Everything or almost everything that you've added to mergeruns()\\nshould probably be in its own dedicated function. This function can\\nhave a comment where you acknowledge that it's not perfectly okay that\\nyou claim memory per-tape, but it's simpler and faster overall.\\n\\n* I think you should be looking at the number of active tapes, and not\\nstate->Level or state->currentRun in this new function. Actually,\\nmaybe this wouldn't be the exact definition of an active tape that we\\nestablish at the beginning of beginmerge() (this considers tapes with\\ndummy runs to be inactive for that merge), but it would look similar.\\nThe general concern I have here is that you shouldn't rely on\\nstate->Level or state->currentRun from a distance for the purposes of\\ndetermining which tapes need some batch memory. This is also where you\\nmight say something like: \\\"we don't bother with shifting memory around\\ntapes for each merge step, even though that would be fairer. That's\\nwhy we don't use the beginmerge() definition of activeTapes --\\ninstead, we use our own broader definition of the number of active\\ntapes that doesn't exclude dummy-run-tapes with real runs, making the\\nallocation reasonably sensible for every merge pass\\\".\\n\\n* The \\\"batchUsed\\\" terminology really isn't working here, AFAICT. For\\none thing, you have two separate areas where caller tuples might\\nreside: The small per-tape buffers (sized MERGETUPLEBUFFER_SIZE per\\ntape), and the logtape.c controlled preread buffers (sized up to\\nMaxAllocSize per tape). Which of these two things is batch memory? I\\nthink it might just be the first one, but KiBs of memory do not\\nsuggest \\\"batch\\\" to me. Isn't that really more like what you might call\\ndouble buffer memory, used not to save overhead from palloc (having\\nmany palloc headers in memory), but rather to recycle memory\\nefficiently? So, these two things should have two new names of their\\nown, I think, and neither should be called \\\"batch memory\\\" IMV. I see\\nseveral assertions remain here and there that were written with my\\noriginal definition of batch memory in mind -- assertions like:\\n\\n case TSS_SORTEDONTAPE:\\n Assert(forward || state->randomAccess);\\n Assert(!state->batchUsed);\\n\\n(Isn't state->batchUsed always true now?)\\n\\nAnd:\\n\\n case TSS_FINALMERGE:\\n Assert(forward);\\n Assert(state->batchUsed || !state->tuples);\\n\\n(Isn't state->tuples only really of interest to datum-tuple-case\\nroutines, now that you've made everything use large logtape.c preread\\nbuffers?)\\n\\n* Is is really necessary for !state->tuples cases to do that\\nMERGETUPLEBUFFER_SIZE-based allocation? In other words, what need is\\nthere for pass-by-value datum cases to have this scratch/double buffer\\nmemory at all, since the value is returned to caller by-value, not\\nby-reference? This is related to the problem of it not being entirely\\nclear what batch memory now is, I think.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 29 Sep 2016 11:52:40 +0100\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 29, 2016 at 6:52 AM, Peter Geoghegan <pg@heroku.com> wrote:\\n>> How is it awkward?\\n>\\n> Maybe that was the wrong choice of words. What I mean is that it seems\\n> somewhat unprincipled to give over an equal share of memory to each\\n> active-at-least-once tape, ...\\n\\nI don't get it. If the memory is being used for prereading, then the\\npoint is just to avoid doing many small I/Os instead of one big I/O,\\nand that goal will be accomplished whether the memory is equally\\ndistributed or not; indeed, it's likely to be accomplished BETTER if\\nthe memory is equally distributed than if it isn't.\\n\\nI can imagine that there might be a situation in which it makes sense\\nto give a bigger tape more resources than a smaller one; for example,\\nif one were going to divide N tapes across K worker processess and\\nmake individual workers or groups of workers responsible for sorting\\nparticular tapes, one would of course want to divide up the data\\nacross the available processes relatively evenly, rather than having\\nsome workers responsible for only a small amount of data and others\\nfor a very large amount of data. But such considerations are\\nirrelevant here.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 29 Sep 2016 09:59:53 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/29/2016 01:52 PM, Peter Geoghegan wrote:\\n> * Variables like maxTapes have a meaning that is directly traceable\\n> back to Knuth's description of polyphase merge. I don't think that you\\n> should do anything to them, on general principle.\\n\\nOk. I still think that changing maxTapes would make sense, when there \\nare fewer runs than tapes, but that is actually orthogonal to the rest \\nof the patch, so let's discuss that separately. I've changed the patch \\nto not do that.\\n\\n> * Everything or almost everything that you've added to mergeruns()\\n> should probably be in its own dedicated function. This function can\\n> have a comment where you acknowledge that it's not perfectly okay that\\n> you claim memory per-tape, but it's simpler and faster overall.\\n\\nOk.\\n\\n> * I think you should be looking at the number of active tapes, and not\\n> state->Level or state->currentRun in this new function. Actually,\\n> maybe this wouldn't be the exact definition of an active tape that we\\n> establish at the beginning of beginmerge() (this considers tapes with\\n> dummy runs to be inactive for that merge), but it would look similar.\\n> The general concern I have here is that you shouldn't rely on\\n> state->Level or state->currentRun from a distance for the purposes of\\n> determining which tapes need some batch memory. This is also where you\\n> might say something like: \\\"we don't bother with shifting memory around\\n> tapes for each merge step, even though that would be fairer. That's\\n> why we don't use the beginmerge() definition of activeTapes --\\n> instead, we use our own broader definition of the number of active\\n> tapes that doesn't exclude dummy-run-tapes with real runs, making the\\n> allocation reasonably sensible for every merge pass\\\".\\n\\nI'm not sure I understood what your concern was, but please have a look \\nat this new version, if the comments in initTapeBuffers() explain that \\nwell enough.\\n\\n> * The \\\"batchUsed\\\" terminology really isn't working here, AFAICT. For\\n> one thing, you have two separate areas where caller tuples might\\n> reside: The small per-tape buffers (sized MERGETUPLEBUFFER_SIZE per\\n> tape), and the logtape.c controlled preread buffers (sized up to\\n> MaxAllocSize per tape). Which of these two things is batch memory? I\\n> think it might just be the first one, but KiBs of memory do not\\n> suggest \\\"batch\\\" to me. Isn't that really more like what you might call\\n> double buffer memory, used not to save overhead from palloc (having\\n> many palloc headers in memory), but rather to recycle memory\\n> efficiently? So, these two things should have two new names of their\\n> own, I think, and neither should be called \\\"batch memory\\\" IMV. I see\\n> several assertions remain here and there that were written with my\\n> original definition of batch memory in mind -- assertions like:\\n\\nOk. I replaced \\\"batch\\\" terminology with \\\"slab allocator\\\" and \\\"slab \\nslots\\\", I hope this is less confusing. This isn't exactly like e.g. the \\nslab allocator in the Linux kernel, as it has a fixed number of slots, \\nso perhaps an \\\"object pool\\\" might be more accurate. But I like \\\"slab\\\" \\nbecause it's not used elsewhere in the system. I also didn't use the \\nterm \\\"cache\\\" for the \\\"slots\\\", as might be typical for slab allocators, \\nbecause \\\"cache\\\" is such an overloaded term.\\n\\n> case TSS_SORTEDONTAPE:\\n> Assert(forward || state->randomAccess);\\n> Assert(!state->batchUsed);\\n>\\n> (Isn't state->batchUsed always true now?)\\n\\nGood catch. It wasn't, because mergeruns() set batchUsed only after \\nchecking for the TSS_SORTEDONTAPE case, even though it set up the batch \\nmemory arena before it. So if replacement selection was able to produce \\na single run batchUsed was false. Fixed, the slab allocator (as it's now \\ncalled) is now always used in TSS_SORTEDONTAPE case.\\n\\n> And:\\n>\\n> case TSS_FINALMERGE:\\n> Assert(forward);\\n> Assert(state->batchUsed || !state->tuples);\\n>\\n> (Isn't state->tuples only really of interest to datum-tuple-case\\n> routines, now that you've made everything use large logtape.c preread\\n> buffers?)\\n\\nYeah, fixed.\\n\\n> * Is is really necessary for !state->tuples cases to do that\\n> MERGETUPLEBUFFER_SIZE-based allocation? In other words, what need is\\n> there for pass-by-value datum cases to have this scratch/double buffer\\n> memory at all, since the value is returned to caller by-value, not\\n> by-reference? This is related to the problem of it not being entirely\\n> clear what batch memory now is, I think.\\n\\nTrue, fixed. I still set slabAllocatorUsed (was batchUsed), but it's \\ninitialized as a dummy 0-slot arena when !state->tuples.\\n\\nHere's a new patch version, addressing the points you made. Please have \\na look!\\n\\n- Heikki\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 29 Sep 2016 17:41:25 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/29/2016 05:41 PM, Heikki Linnakangas wrote:\\n> Here's a new patch version, addressing the points you made. Please have\\n> a look!\\n\\nBah, I fumbled the initSlabAllocator() function, attached is a fixed \\nversion.\\n\\n- Heikki\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 29 Sep 2016 18:10:03 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 29, 2016 at 2:59 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> Maybe that was the wrong choice of words. What I mean is that it seems\\n>> somewhat unprincipled to give over an equal share of memory to each\\n>> active-at-least-once tape, ...\\n>\\n> I don't get it. If the memory is being used for prereading, then the\\n> point is just to avoid doing many small I/Os instead of one big I/O,\\n> and that goal will be accomplished whether the memory is equally\\n> distributed or not; indeed, it's likely to be accomplished BETTER if\\n> the memory is equally distributed than if it isn't.\\n\\nI think it could hurt performance if preloading loads runs on a tape\\nthat won't be needed until some subsequent merge pass, in preference\\nto using that memory proportionately, giving more to larger input runs\\nfor *each* merge pass (giving memory proportionate to the size of each\\nrun to be merged from each tape). For tapes with a dummy run, the\\nappropriate amount of memory for there next merge pass is zero.\\n\\nI'm not arguing that it would be worth it to do that, but I do think\\nthat that's the sensible way of framing the idea of using a uniform\\namount of memory to every maybe-active tape up front. I'm not too\\nconcerned about this because I'm never too concerned about multiple\\nmerge pass cases, which are relatively rare and relatively\\nunimportant. Let's just get our story straight.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 29 Sep 2016 16:38:57 +0100\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 29, 2016 at 11:38 AM, Peter Geoghegan <pg@heroku.com> wrote:\\n> On Thu, Sep 29, 2016 at 2:59 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>> Maybe that was the wrong choice of words. What I mean is that it seems\\n>>> somewhat unprincipled to give over an equal share of memory to each\\n>>> active-at-least-once tape, ...\\n>>\\n>> I don't get it. If the memory is being used for prereading, then the\\n>> point is just to avoid doing many small I/Os instead of one big I/O,\\n>> and that goal will be accomplished whether the memory is equally\\n>> distributed or not; indeed, it's likely to be accomplished BETTER if\\n>> the memory is equally distributed than if it isn't.\\n>\\n> I think it could hurt performance if preloading loads runs on a tape\\n> that won't be needed until some subsequent merge pass, in preference\\n> to using that memory proportionately, giving more to larger input runs\\n> for *each* merge pass (giving memory proportionate to the size of each\\n> run to be merged from each tape). For tapes with a dummy run, the\\n> appropriate amount of memory for there next merge pass is zero.\\n\\nOK, true. But I still suspect that unless the amount of data you need\\nto read from a tape is zero or very small, the size of the buffer\\ndoesn't matter. For example, if you have a 1GB tape and a 10GB tape,\\nI doubt there's any benefit in making the buffer for the 10GB tape 10x\\nlarger. They can probably be the same.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 29 Sep 2016 12:56:21 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 29, 2016 at 4:10 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n> Bah, I fumbled the initSlabAllocator() function, attached is a fixed\\n> version.\\n\\nThis looks much better. It's definitely getting close. Thanks for\\nbeing considerate of my more marginal concerns. More feedback:\\n\\n* Should say \\\"fixed number of...\\\":\\n\\n> + * we start merging. Merging only needs to keep a small, fixed number tuples\\n\\n* Minor concern about these new macros:\\n\\n> +#define IS_SLAB_SLOT(state, tuple) \\\\\\n> + ((char *) tuple >= state->slabMemoryBegin && \\\\\\n> + (char *) tuple < state->slabMemoryEnd)\\n> +\\n> +/*\\n> + * Return the given tuple to the slab memory free list, or free it\\n> + * if it was palloc'd.\\n> + */\\n> +#define RELEASE_SLAB_SLOT(state, tuple) \\\\\\n> + do { \\\\\\n> + SlabSlot *buf = (SlabSlot *) tuple; \\\\\\n> + \\\\\\n> + if (IS_SLAB_SLOT(state, tuple)) \\\\\\n> + { \\\\\\n> + buf->nextfree = state->slabFreeHead; \\\\\\n> + state->slabFreeHead = buf; \\\\\\n> + } else \\\\\\n> + pfree(tuple); \\\\\\n> + } while(0)\\n\\nI suggest duplicating the paranoia seen elsewhere around what \\\"state\\\"\\nmacro argument could expand to. You know, by surrounding \\\"state\\\" with\\nparenthesis each time it is used. This is what we see with existing,\\nsimilar macros.\\n\\n* Should cast to int64 here (for the benefit of win64):\\n\\n> + elog(LOG, \\\"using \\\" INT64_FORMAT \\\" KB of memory for read buffers among %d input tapes\\\",\\n> + (long) (availBlocks * BLCKSZ) / 1024, numInputTapes);\\n\\n* FWIW, I still don't love this bit:\\n\\n> + * numTapes and numInputTapes reflect the actual number of tapes we will\\n> + * use. Note that the output tape's tape number is maxTapes - 1, so the\\n> + * tape numbers of the used tapes are not consecutive, so you cannot\\n> + * just loop from 0 to numTapes to visit all used tapes!\\n> + */\\n> + if (state->Level == 1)\\n> + {\\n> + numInputTapes = state->currentRun;\\n> + numTapes = numInputTapes + 1;\\n> + FREEMEM(state, (state->maxTapes - numTapes) * TAPE_BUFFER_OVERHEAD);\\n> + }\\n\\nBut I can see how the verbosity of almost-duplicating the activeTapes\\nstuff seems unappealing. That said, I think that you should point out\\nin comments that you're calculating the number of\\nmaybe-active-in-some-merge tapes. They're maybe-active in that they\\nhave some number of real tapes. Not going to insist on that, but\\nsomething to think about.\\n\\n* Shouldn't this use state->tapeRange?:\\n\\n> + else\\n> + {\\n> + numInputTapes = state->maxTapes - 1;\\n> + numTapes = state->maxTapes;\\n> + }\\n\\n* Doesn't it also set numTapes without it being used? Maybe that\\nvariable can be declared within \\\"if (state->Level == 1)\\\" block.\\n\\n* Minor issues with initSlabAllocator():\\n\\nYou call the new function initSlabAllocator() as follows:\\n\\n> + if (state->tuples)\\n> + initSlabAllocator(state, numInputTapes + 1);\\n> + else\\n> + initSlabAllocator(state, 0);\\n\\nIsn't the number of slots (the second argument to initSlabAllocator())\\nactually just numInputTapes when we're \\\"state->tuples\\\"? And so,\\nshouldn't the \\\"+ 1\\\" bit happen within initSlabAllocator() itself? It\\ncan just inspect \\\"state->tuples\\\" itself. In short, maybe push a bit\\nmore into initSlabAllocator(). Making the arguments match those passed\\nto initTapeBuffers() a bit later would be nice, perhaps.\\n\\n* This could be simpler, I think:\\n\\n> + /* Release the read buffers on all the other tapes, by rewinding them. */\\n> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\\n> + {\\n> + if (tapenum == state->result_tape)\\n> + continue;\\n> + LogicalTapeRewind(state->tapeset, tapenum, true);\\n> + }\\n\\nCan't you just use state->tapeRange, and remove the \\\"continue\\\"? I\\nrecommend referring to \\\"now-exhausted input tapes\\\" here, too.\\n\\n* I'm not completely prepared to give up on using\\nMemoryContextAllocHuge() within logtape.c just yet. Maybe you're right\\nthat it couldn't possibly matter that we impose a MaxAllocSize cap\\nwithin logtape.c (per tape), but I have slight reservations that I\\nneed to address. Maybe a better way of putting it would be that I have\\nsome reservations about possible regressions at the very high end,\\nwith very large workMem. Any thoughts on that?\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 30 Sep 2016 14:08:44 +0100\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 09/30/2016 04:08 PM, Peter Geoghegan wrote:\\n> On Thu, Sep 29, 2016 at 4:10 PM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Bah, I fumbled the initSlabAllocator() function, attached is a fixed\\n>> version.\\n>\\n> This looks much better. It's definitely getting close. Thanks for\\n> being considerate of my more marginal concerns. More feedback:\\n\\nFixed most of the things you pointed out, thanks.\\n\\n> * Minor issues with initSlabAllocator():\\n>\\n> You call the new function initSlabAllocator() as follows:\\n>\\n>> + if (state->tuples)\\n>> + initSlabAllocator(state, numInputTapes + 1);\\n>> + else\\n>> + initSlabAllocator(state, 0);\\n>\\n> Isn't the number of slots (the second argument to initSlabAllocator())\\n> actually just numInputTapes when we're \\\"state->tuples\\\"? And so,\\n> shouldn't the \\\"+ 1\\\" bit happen within initSlabAllocator() itself? It\\n> can just inspect \\\"state->tuples\\\" itself. In short, maybe push a bit\\n> more into initSlabAllocator(). Making the arguments match those passed\\n> to initTapeBuffers() a bit later would be nice, perhaps.\\n\\nThe comment above that explains the \\\"+ 1\\\". init_slab_allocator allocates \\nthe number of slots that was requested, and the caller is responsible \\nfor deciding how many slots are needed. Yeah, we could remove the \\nargument and move the logic altogether into init_slab_allocator(), but I \\nthink it's clearer this way. Matter of taste, I guess.\\n\\n> * This could be simpler, I think:\\n>\\n>> + /* Release the read buffers on all the other tapes, by rewinding them. */\\n>> + for (tapenum = 0; tapenum < state->maxTapes; tapenum++)\\n>> + {\\n>> + if (tapenum == state->result_tape)\\n>> + continue;\\n>> + LogicalTapeRewind(state->tapeset, tapenum, true);\\n>> + }\\n>\\n> Can't you just use state->tapeRange, and remove the \\\"continue\\\"? I\\n> recommend referring to \\\"now-exhausted input tapes\\\" here, too.\\n\\nDon't think so. result_tape == tapeRange only when the merge was done in \\na single pass (or you're otherwise lucky).\\n\\n> * I'm not completely prepared to give up on using\\n> MemoryContextAllocHuge() within logtape.c just yet. Maybe you're right\\n> that it couldn't possibly matter that we impose a MaxAllocSize cap\\n> within logtape.c (per tape), but I have slight reservations that I\\n> need to address. Maybe a better way of putting it would be that I have\\n> some reservations about possible regressions at the very high end,\\n> with very large workMem. Any thoughts on that?\\n\\nMeh, I can't imagine that using more than 1 GB for a read-ahead buffer \\ncould make any difference in practice. If you have a very large \\nwork_mem, you'll surely get away with a single merge pass, and \\nfragmentation won't become an issue. And 1GB should be more than enough \\nto trigger OS read-ahead.\\n\\nCommitted with some final kibitzing. Thanks for the review!\\n\\nPS. This patch didn't fix bug #14344, the premature reuse of memory with \\ntuplesort_gettupleslot. We'll still need to come up with 1. a \\nbackportable fix for that, and 2. perhaps a different fix for master.\\n\\n- Heikki\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 3 Oct 2016 13:39:10 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Mon, Oct 3, 2016 at 3:39 AM, Heikki Linnakangas <hlinnaka@iki.fi> wrote:\\n>> Can't you just use state->tapeRange, and remove the \\\"continue\\\"? I\\n>> recommend referring to \\\"now-exhausted input tapes\\\" here, too.\\n>\\n>\\n> Don't think so. result_tape == tapeRange only when the merge was done in a\\n> single pass (or you're otherwise lucky).\\n\\nAh, yes. Logical tape assignment/physical tape number confusion on my part here.\\n\\n>> * I'm not completely prepared to give up on using\\n>> MemoryContextAllocHuge() within logtape.c just yet. Maybe you're right\\n>> that it couldn't possibly matter that we impose a MaxAllocSize cap\\n>> within logtape.c (per tape), but I have slight reservations that I\\n>> need to address. Maybe a better way of putting it would be that I have\\n>> some reservations about possible regressions at the very high end,\\n>> with very large workMem. Any thoughts on that?\\n>\\n>\\n> Meh, I can't imagine that using more than 1 GB for a read-ahead buffer could\\n> make any difference in practice. If you have a very large work_mem, you'll\\n> surely get away with a single merge pass, and fragmentation won't become an\\n> issue. And 1GB should be more than enough to trigger OS read-ahead.\\n\\nI had a non-specific concern, not an intuition of suspicion about\\nthis. I think that I'll figure it out when I rebase the parallel\\nCREATE INDEX patch on top of this and test that.\\n\\n> Committed with some final kibitzing. Thanks for the review!\\n\\nThanks for working on this!\\n\\n> PS. This patch didn't fix bug #14344, the premature reuse of memory with\\n> tuplesort_gettupleslot. We'll still need to come up with 1. a backportable\\n> fix for that, and 2. perhaps a different fix for master.\\n\\nAgreed. It seemed like you favor not changing memory ownership\\nsemantics for 9.6. I'm not sure that that's the easiest approach for\\n9.6, but let's discuss that over on the dedicated thread soon.\\n\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 3 Oct 2016 04:51:54 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"Heikki Linnakangas <hlinnaka@iki.fi> writes:\\n> I'm talking about the code that reads a bunch of from each tape, loading \\n> them into the memtuples array. That code was added by Tom Lane, back in \\n> 1999:\\n\\n> commit cf627ab41ab9f6038a29ddd04dd0ff0ccdca714e\\n> Author: Tom Lane <tgl@sss.pgh.pa.us>\\n> Date: Sat Oct 30 17:27:15 1999 +0000\\n\\n> Further performance improvements in sorting: reduce number of comparisons\\n> during initial run formation by keeping both current run and next-run\\n> tuples in the same heap (yup, Knuth is smarter than I am). And, during\\n> merge passes, make use of available sort memory to load multiple tuples\\n> from any one input 'tape' at a time, thereby improving locality of\\n> access to the temp file.\\n\\n> So apparently there was a benefit back then, but is it still worthwhile? \\n\\nI'm fairly sure that the point was exactly what it said, ie improve\\nlocality of access within the temp file by sequentially reading as many\\ntuples in a row as we could, rather than grabbing one here and one there.\\n\\nIt may be that the work you and Peter G. have been doing have rendered\\nthat question moot. But I'm a bit worried that the reason you're not\\nseeing any effect is that you're only testing situations with zero seek\\npenalty (ie your laptop's disk is an SSD). Back then I would certainly\\nhave been testing with temp files on spinning rust, and I fear that this\\nmay still be an issue in that sort of environment.\\n\\nThe relevant mailing list thread seems to be \\\"sort on huge table\\\" in\\npgsql-hackers in October/November 1999. The archives don't seem to have\\nthreaded that too successfully, but here's a message specifically\\ndescribing the commit you mention:\\n\\nhttps://www.postgresql.org/message-id/2726.941493808%40sss.pgh.pa.us\\n\\nand you can find the rest by looking through the archive summary pages\\nfor that interval.\\n\\nThe larger picture to be drawn from that thread is that we were seeing\\nvery different performance characteristics on different platforms.\\nThe specific issue that Tatsuo-san reported seemed like it might be\\ndown to weird read-ahead behavior in a 90s-vintage Linux kernel ...\\nbut the point that this stuff can be environment-dependent is still\\nsomething to take to heart.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 14 Apr 2017 00:51:15 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"I wrote:\\n> Heikki Linnakangas <hlinnaka@iki.fi> writes:\\n>> I'm talking about the code that reads a bunch of from each tape, loading \\n>> them into the memtuples array. That code was added by Tom Lane, back in \\n>> 1999:\\n>> So apparently there was a benefit back then, but is it still worthwhile? \\n\\n> I'm fairly sure that the point was exactly what it said, ie improve\\n> locality of access within the temp file by sequentially reading as many\\n> tuples in a row as we could, rather than grabbing one here and one there.\\n\\n[ blink... ] Somehow, my mail reader popped up a message from 2016\\nas current, and I spent some time researching and answering it without\\nnoticing the message date.\\n\\nNever mind, nothing to see here ...\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 14 Apr 2017 00:57:20 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Apr 13, 2017 at 9:51 PM, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n> I'm fairly sure that the point was exactly what it said, ie improve\\n> locality of access within the temp file by sequentially reading as many\\n> tuples in a row as we could, rather than grabbing one here and one there.\\n>\\n> It may be that the work you and Peter G. have been doing have rendered\\n> that question moot. But I'm a bit worried that the reason you're not\\n> seeing any effect is that you're only testing situations with zero seek\\n> penalty (ie your laptop's disk is an SSD). Back then I would certainly\\n> have been testing with temp files on spinning rust, and I fear that this\\n> may still be an issue in that sort of environment.\\n\\nI actually think Heikki's work here would particularly help on\\nspinning rust, especially when less memory is available. He\\nspecifically justified it on the basis of it resulting in a more\\nsequential read pattern, particularly when multiple passes are\\nrequired.\\n\\n> The larger picture to be drawn from that thread is that we were seeing\\n> very different performance characteristics on different platforms.\\n> The specific issue that Tatsuo-san reported seemed like it might be\\n> down to weird read-ahead behavior in a 90s-vintage Linux kernel ...\\n> but the point that this stuff can be environment-dependent is still\\n> something to take to heart.\\n\\nBTW, I'm skeptical of the idea of Heikki's around killing polyphase\\nmerge itself at this point. I think that keeping most tapes active per\\npass is useful now that our memory accounting involves handing over an\\neven share to each maybe-active tape for every merge pass, something\\nestablished by Heikki's work on external sorting.\\n\\nInterestingly enough, I think that Knuth was pretty much spot on with\\nhis \\\"sweet spot\\\" of 7 tapes, even if you have modern hardware. Commit\\ndf700e6 (where the sweet spot of merge order 7 was no longer always\\nused) was effective because it masked certain overheads that we\\nexperience when doing multiple passes, overheads that Heikki and I\\nmostly removed. This was confirmed by Robert's testing of my merge\\norder cap work for commit fc19c18, where he found that using 7 tapes\\nwas only slightly worse than using many hundreds of tapes. If we could\\nsomehow be completely effective in making access to logical tapes\\nperfectly sequential, then 7 tapes would probably be noticeably\\n*faster*, due to CPU caching effects.\\n\\nKnuth was completely correct to say that it basically made no\\ndifference once more than 7 tapes are used to merge, because he didn't\\nhave logtape.c fragmentation to worry about.\\n\\n-- \\nPeter Geoghegan\\n\\nVMware vCenter Server\\nhttps://www.vmware.com/\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 13 Apr 2017 22:19:58 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@bowt.ie>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Thu, Apr 13, 2017 at 10:19 PM, Peter Geoghegan <pg@bowt.ie> wrote:\\n> I actually think Heikki's work here would particularly help on\\n> spinning rust, especially when less memory is available. He\\n> specifically justified it on the basis of it resulting in a more\\n> sequential read pattern, particularly when multiple passes are\\n> required.\\n\\nBTW, what you might have missed is that Heikki did end up using a\\nsignificant amount of memory in the committed version. It just ended\\nup being managed by logtape.c, which now does the prereading instead\\nof tuplesort.c, but at a lower level. There is only one tuple in the\\nmerge heap, but there is still up to 1GB of memory per tape,\\ncontaining raw preread tuples mixed with integers that demarcate tape\\ncontents.\\n\\n-- \\nPeter Geoghegan\\n\\nVMware vCenter Server\\nhttps://www.vmware.com/\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 13 Apr 2017 22:49:47 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@bowt.ie>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 14, 2017 at 1:19 AM, Peter Geoghegan <pg@bowt.ie> wrote:\\n> Interestingly enough, I think that Knuth was pretty much spot on with\\n> his \\\"sweet spot\\\" of 7 tapes, even if you have modern hardware. Commit\\n> df700e6 (where the sweet spot of merge order 7 was no longer always\\n> used) was effective because it masked certain overheads that we\\n> experience when doing multiple passes, overheads that Heikki and I\\n> mostly removed. This was confirmed by Robert's testing of my merge\\n> order cap work for commit fc19c18, where he found that using 7 tapes\\n> was only slightly worse than using many hundreds of tapes. If we could\\n> somehow be completely effective in making access to logical tapes\\n> perfectly sequential, then 7 tapes would probably be noticeably\\n> *faster*, due to CPU caching effects.\\n\\nI don't think there's any one fixed answer, because increasing the\\nnumber of tapes reduces I/O by adding CPU cost, and visca versa.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 14 Apr 2017 08:57:32 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On Fri, Apr 14, 2017 at 5:57 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> I don't think there's any one fixed answer, because increasing the\\n> number of tapes reduces I/O by adding CPU cost, and visca versa.\\n\\nSort of, but if you have to merge hundreds of runs (a situation that\\nshould be quite rare), then you should be concerned about being CPU\\nbound first, as Knuth was. Besides, on modern hardware, read-ahead can\\nbe more effective if you have more merge passes, to a point, which\\nmight also make it worth it -- using hundreds of tapes results in\\nplenty of *random* I/O. Plus, most of the time you only do a second\\npass over a subset of initial quicksorted runs -- not all of them.\\n\\nProbably the main complicating factor that Knuth doesn't care about is\\ntime to return the first tuple -- startup cost. That was a big\\nadvantage for commit df700e6 that I should have mentioned.\\n\\nI'm not seriously suggesting that we should prefer multiple passes in\\nthe vast majority of real world cases, nor am I suggesting that we\\nshould go out of our way to help cases that need to do that. I just\\nfind all this interesting.\\n\\n-- \\nPeter Geoghegan\\n\\nVMware vCenter Server\\nhttps://www.vmware.com/\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 14 Apr 2017 11:10:12 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@bowt.ie>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n },\n {\n \"msg_contents\": \"On 04/14/2017 08:19 AM, Peter Geoghegan wrote:\\n> BTW, I'm skeptical of the idea of Heikki's around killing polyphase\\n> merge itself at this point. I think that keeping most tapes active per\\n> pass is useful now that our memory accounting involves handing over an\\n> even share to each maybe-active tape for every merge pass, something\\n> established by Heikki's work on external sorting.\\n\\nThe pre-read buffers are only needed for input tapes; the total number \\nof tapes doesn't matter.\\n\\nFor comparison, imagine that you want to perform a merge, such that you \\nalways merge 7 runs into one. With polyphase merge, you would need 8 \\ntapes, so that you always read from 7 of them, and write onto one. With \\nbalanced merge, you would need 14 tapes: you always read from 7 tapes, \\nand you would need up to 7 output tapes, of which one would be active at \\nany given time.\\n\\nThose extra idle output tapes are practically free in our \\nimplementation. The \\\"pre-read buffers\\\" are only needed for input tapes, \\nthe number of output tapes doesn't matter. Likewise, maintaining the \\nheap is cheaper if you only merge a small number of tapes at a time, but \\nthat's also dependent on the number of *input* tapes, not the total \\nnumber of tapes.\\n\\n- Heikki\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 18 Apr 2017 11:05:40 +0300\",\n \"msg_from\": \"Heikki Linnakangas <hlinnaka@iki.fi>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Tuplesort merge pre-reading\"\n }\n]","isConversational":false}}},{"rowIdx":43098,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi,\n\nAttached is a WIP patch extending the postgres_fdw DML pushdown in 9.6 \nso that it can perform an update/delete on a join remotely. An example \nis shown below:\n\n* without the patch:\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\n \n QUERY PLAN\n\n--------------------------------------------------------------------------------------------------------------------------------------------------------\n---------------------------\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n Remote SQL: DELETE FROM public.t1 WHERE ctid = $1\n -> Foreign Scan (cost=100.00..102.04 rows=1 width=38)\n Output: ft1.ctid, ft2.*\n Relations: (public.ft1) INNER JOIN (public.ft2)\n Remote SQL: SELECT r1.ctid, CASE WHEN (r2.*)::text IS NOT NULL \nTHEN ROW(r2.a, r2.b) END FROM (public.t1 r1 INNER JOIN public.t2 r2 ON \n(((r1.a =\n r2.a)))) FOR UPDATE OF r1\n -> Nested Loop (cost=200.00..202.07 rows=1 width=38)\n Output: ft1.ctid, ft2.*\n Join Filter: (ft1.a = ft2.a)\n -> Foreign Scan on public.ft1 (cost=100.00..101.03 \nrows=1 width=10)\n Output: ft1.ctid, ft1.a\n Remote SQL: SELECT a, ctid FROM public.t1 FOR UPDATE\n -> Foreign Scan on public.ft2 (cost=100.00..101.03 \nrows=1 width=36)\n Output: ft2.*, ft2.a\n Remote SQL: SELECT a, b FROM public.t2\n(15 rows)\n\n* with the patch:\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\n QUERY PLAN\n-----------------------------------------------------------------------------------------------------------------------------\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\n Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a, b), \na FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\n(3 rows)\n\nThe WIP patch has been created on top of the join pushdown patch [1]. \nSo, for testing, please apply the patch in [1] first.\n\nI'll add this to the the November commitfest.\n\nBest regards,\nEtsuro Fujita\n\n[1] \nhttps://www.postgresql.org/message-id/1688885b-5fb1-8bfa-b1b8-c2758dbe0b38@lab.ntt.co.jp\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 6 Sep 2016 21:45:34 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"Thanks Fujita-san for working on this.\n\n\n> * with the patch:\n> postgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\n> QUERY PLAN\n> ------------------------------------------------------------\n> -----------------------------------------------------------------\n> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\n> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a, b), a\n> FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\n> (3 rows)\n>\n> The WIP patch has been created on top of the join pushdown patch [1]. So,\n> for testing, please apply the patch in [1] first.\n>\n>\nThe underlying scan on t2 requires ROW(a,b) for locking the row for\nupdate/share. But clearly it's not required if the full query is being\npushed down. Is there a way we can detect that ROW(a,b) is useless column\n(not used anywhere in the other parts of the query like RETURNING, DELETE\nclause etc.) and eliminate it? Similarly for a, it's part of the targetlist\nof the underlying scan so that the WHERE clause can be applied on it. But\nit's not needed if we are pushing down the query. If we eliminate the\ntargetlist of the query, we could construct a remote query without having\nsubquery in it, making it more readable.\n\n-- \nBest Wishes,\nAshutosh Bapat\nEnterpriseDB Corporation\nThe Postgres Database Company\n\nThanks Fujita-san for working on this.\n\n* with the patch:\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\n QUERY PLAN\n-----------------------------------------------------------------------------------------------------------------------------\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\n Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a, b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\n(3 rows)\n\nThe WIP patch has been created on top of the join pushdown patch [1]. So, for testing, please apply the patch in [1] first.\nThe underlying scan on t2 requires ROW(a,b) for locking the row for update/share. But clearly it's not required if the full query is being pushed down. Is there a way we can detect that ROW(a,b) is useless column (not used anywhere in the other parts of the query like RETURNING, DELETE clause etc.) and eliminate it? Similarly for a, it's part of the targetlist of the underlying scan so that the WHERE clause can be applied on it. But it's not needed if we are pushing down the query. If we eliminate the targetlist of the query, we could construct a remote query without having subquery in it, making it more readable.-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company","msg_date":"Wed, 7 Sep 2016 09:51:12 +0530","msg_from":"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2016/09/07 13:21, Ashutosh Bapat wrote:\n> * with the patch:\n> postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\n> ft2.a;\n> QUERY PLAN\n> -----------------------------------------------------------------------------------------------------------------------------\n> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\n> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\n> b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\n> (3 rows)\n\n> The underlying scan on t2 requires ROW(a,b) for locking the row for\n> update/share. But clearly it's not required if the full query is being\n> pushed down.\n\nExactly.\n\n> Is there a way we can detect that ROW(a,b) is useless\n> column (not used anywhere in the other parts of the query like\n> RETURNING, DELETE clause etc.) and eliminate it?\n\nI don't have a clear solution for that yet, but I'll try to remove that \nin the next version.\n\n> Similarly for a, it's\n> part of the targetlist of the underlying scan so that the WHERE clause\n> can be applied on it. But it's not needed if we are pushing down the\n> query. If we eliminate the targetlist of the query, we could construct a\n> remote query without having subquery in it, making it more readable.\n\nWill try to do so also.\n\nThanks for the comments!\n\nBest regards,\nEtsuro Fujita\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 19:55:03 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2016/09/08 19:55, Etsuro Fujita wrote:\n> On 2016/09/07 13:21, Ashutosh Bapat wrote:\n>> * with the patch:\n>> postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\n>> ft2.a;\n>> QUERY PLAN\n>>\n>> -----------------------------------------------------------------------------------------------------------------------------\n>>\n>> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n>> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\n>> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\n>> b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\n>> (3 rows)\n>\n>> The underlying scan on t2 requires ROW(a,b) for locking the row for\n>> update/share. But clearly it's not required if the full query is being\n>> pushed down.\n\n>> Is there a way we can detect that ROW(a,b) is useless\n>> column (not used anywhere in the other parts of the query like\n>> RETURNING, DELETE clause etc.) and eliminate it?\n\n> I don't have a clear solution for that yet, but I'll try to remove that\n> in the next version.\n\n>> Similarly for a, it's\n>> part of the targetlist of the underlying scan so that the WHERE clause\n>> can be applied on it. But it's not needed if we are pushing down the\n>> query. If we eliminate the targetlist of the query, we could construct a\n>> remote query without having subquery in it, making it more readable.\n\n> Will try to do so also.\n\nI addressed this by improving the deparse logic so that a remote query \nfor performing an UPDATE/DELETE on a join directly on the remote can be \ncreated as proposed if possible. Attached is an updated version of the \npatch, which is created on top of the patch set [1]. The patch is still \nWIP (ie, needs more comments and regression tests, at least), but any \ncomments would be gratefully appreciated.\n\nBest regards,\nEtsuro Fujita\n\n[1] \nhttps://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b642-b0e65037c76b%40lab.ntt.co.jp\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 11 Nov 2016 20:30:39 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"Thanks Fujita-san for working on this. I've signed up to review this patch.\n\nYour latest patch doesn't not get apply cleanly apply on master branch.\n\npatching file contrib/postgres_fdw/deparse.c\n6 out of 17 hunks FAILED -- saving rejects to file\ncontrib/postgres_fdw/deparse.c.rej\npatching file contrib/postgres_fdw/expected/postgres_fdw.out\n2 out of 2 hunks FAILED -- saving rejects to file\ncontrib/postgres_fdw/expected/postgres_fdw.out.rej\npatching file contrib/postgres_fdw/postgres_fdw.c\n2 out of 22 hunks FAILED -- saving rejects to file\ncontrib/postgres_fdw/postgres_fdw.c.rej\npatching file contrib/postgres_fdw/postgres_fdw.h\n1 out of 3 hunks FAILED -- saving rejects to file\ncontrib/postgres_fdw/postgres_fdw.h.rej\n\nPlease share the patch which get apply clean on master branch.\n\n\n\nOn Fri, Nov 11, 2016 at 5:00 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\nwrote:\n\n> On 2016/09/08 19:55, Etsuro Fujita wrote:\n>\n>> On 2016/09/07 13:21, Ashutosh Bapat wrote:\n>>\n>>> * with the patch:\n>>> postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\n>>> ft2.a;\n>>> QUERY PLAN\n>>>\n>>> ------------------------------------------------------------\n>>> -----------------------------------------------------------------\n>>>\n>>> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n>>> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\n>>> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\n>>> b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\n>>> (3 rows)\n>>>\n>>\n>> The underlying scan on t2 requires ROW(a,b) for locking the row for\n>>> update/share. But clearly it's not required if the full query is being\n>>> pushed down.\n>>>\n>>\n> Is there a way we can detect that ROW(a,b) is useless\n>>> column (not used anywhere in the other parts of the query like\n>>> RETURNING, DELETE clause etc.) and eliminate it?\n>>>\n>>\n> I don't have a clear solution for that yet, but I'll try to remove that\n>> in the next version.\n>>\n>\n> Similarly for a, it's\n>>> part of the targetlist of the underlying scan so that the WHERE clause\n>>> can be applied on it. But it's not needed if we are pushing down the\n>>> query. If we eliminate the targetlist of the query, we could construct a\n>>> remote query without having subquery in it, making it more readable.\n>>>\n>>\n> Will try to do so also.\n>>\n>\n> I addressed this by improving the deparse logic so that a remote query for\n> performing an UPDATE/DELETE on a join directly on the remote can be created\n> as proposed if possible. Attached is an updated version of the patch,\n> which is created on top of the patch set [1]. The patch is still WIP (ie,\n> needs more comments and regression tests, at least), but any comments would\n> be gratefully appreciated.\n>\n> Best regards,\n> Etsuro Fujita\n>\n> [1] https://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b64\n> 2-b0e65037c76b%40lab.ntt.co.jp\n>\n>\n> --\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\n> To make changes to your subscription:\n> http://www.postgresql.org/mailpref/pgsql-hackers\n>\n>\n\n\n-- \nRushabh Lathia\n\nThanks Fujita-san for working on this. I've signed up to review this patch.Your latest patch doesn't not get apply cleanly apply on master branch.patching file contrib/postgres_fdw/deparse.c6 out of 17 hunks FAILED -- saving rejects to file contrib/postgres_fdw/deparse.c.rejpatching file contrib/postgres_fdw/expected/postgres_fdw.out2 out of 2 hunks FAILED -- saving rejects to file contrib/postgres_fdw/expected/postgres_fdw.out.rejpatching file contrib/postgres_fdw/postgres_fdw.c2 out of 22 hunks FAILED -- saving rejects to file contrib/postgres_fdw/postgres_fdw.c.rejpatching file contrib/postgres_fdw/postgres_fdw.h1 out of 3 hunks FAILED -- saving rejects to file contrib/postgres_fdw/postgres_fdw.h.rejPlease share the patch which get apply clean on master branch.On Fri, Nov 11, 2016 at 5:00 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2016/09/08 19:55, Etsuro Fujita wrote:\n\nOn 2016/09/07 13:21, Ashutosh Bapat wrote:\n\n * with the patch:\n postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\n ft2.a;\n QUERY PLAN\n\n-----------------------------------------------------------------------------------------------------------------------------\n\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\n -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\n Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\n b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\n (3 rows)\n\n\n\nThe underlying scan on t2 requires ROW(a,b) for locking the row for\nupdate/share. But clearly it's not required if the full query is being\npushed down.\n\n\n\nIs there a way we can detect that ROW(a,b) is useless\ncolumn (not used anywhere in the other parts of the query like\nRETURNING, DELETE clause etc.) and eliminate it?\n\n\n\nI don't have a clear solution for that yet, but I'll try to remove that\nin the next version.\n\n\n\nSimilarly for a, it's\npart of the targetlist of the underlying scan so that the WHERE clause\ncan be applied on it. But it's not needed if we are pushing down the\nquery. If we eliminate the targetlist of the query, we could construct a\nremote query without having subquery in it, making it more readable.\n\n\n\nWill try to do so also.\n\n\nI addressed this by improving the deparse logic so that a remote query for performing an UPDATE/DELETE on a join directly on the remote can be created as proposed if possible. Attached is an updated version of the patch, which is created on top of the patch set [1]. The patch is still WIP (ie, needs more comments and regression tests, at least), but any comments would be gratefully appreciated.\n\nBest regards,\nEtsuro Fujita\n\n[1] https://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b642-b0e65037c76b%40lab.ntt.co.jp\n\n--\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n-- Rushabh Lathia","msg_date":"Tue, 15 Nov 2016 15:34:22 +0530","msg_from":"Rushabh Lathia <rushabh.lathia@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2016/11/15 19:04, Rushabh Lathia wrote:\n> Thanks Fujita-san for working on this. I've signed up to review this patch.\n\nThank you for reviewing the patch!\n\n> Your latest patch doesn't not get apply cleanly apply on master branch.\n\nDid you apply the patch set in [1] \n(postgres-fdw-subquery-support-v4.patch and \npostgres-fdw-phv-pushdown-v4.patch in this order) before applying the \nlatest patch?\n\nBest regards,\nEtsuro Fujita\n\n[1] \nhttps://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b642-b0e65037c76b%40lab.ntt.co.jp\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 16 Nov 2016 11:55:03 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On Wed, Nov 16, 2016 at 8:25 AM, Etsuro Fujita\n<fujita.etsuro@lab.ntt.co.jp> wrote:\n> On 2016/11/15 19:04, Rushabh Lathia wrote:\n>>\n>> Thanks Fujita-san for working on this. I've signed up to review this\n>> patch.\n>\n>\n> Thank you for reviewing the patch!\n>\n>> Your latest patch doesn't not get apply cleanly apply on master branch.\n>\n>\n> Did you apply the patch set in [1] (postgres-fdw-subquery-support-v4.patch\n> and postgres-fdw-phv-pushdown-v4.patch in this order) before applying the\n> latest patch?\n>\n\nI don't see any reason why DML/UPDATE pushdown should depend upon\nsubquery deparsing or least PHV patch. Combined together they can help\nin more cases, but without those patches, we will be able to push-down\nmore stuff. Probably, we should just restrict push-down only for the\ncases when above patches are not needed. That makes reviews easy. Once\nthose patches get committed, we may add more functionality depending\nupon the status of this patch. Does that make sense?\n\n-- \nBest Wishes,\nAshutosh Bapat\nEnterpriseDB Corporation\nThe Postgres Database Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 16 Nov 2016 09:40:10 +0530","msg_from":"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2016/11/16 13:10, Ashutosh Bapat wrote:\n> On Wed, Nov 16, 2016 at 8:25 AM, Etsuro Fujita\n> <fujita.etsuro@lab.ntt.co.jp> wrote:\n>> On 2016/11/15 19:04, Rushabh Lathia wrote:\n>>> Your latest patch doesn't not get apply cleanly apply on master branch.\n\n>> Did you apply the patch set in [1] (postgres-fdw-subquery-support-v4.patch\n>> and postgres-fdw-phv-pushdown-v4.patch in this order) before applying the\n>> latest patch?\n\n> I don't see any reason why DML/UPDATE pushdown should depend upon\n> subquery deparsing or least PHV patch. Combined together they can help\n> in more cases, but without those patches, we will be able to push-down\n> more stuff. Probably, we should just restrict push-down only for the\n> cases when above patches are not needed. That makes reviews easy. Once\n> those patches get committed, we may add more functionality depending\n> upon the status of this patch. Does that make sense?\n\nOK, I'll extract from the patch the minimal part that wouldn't depend on \nthe two patches.\n\nBest regards,\nEtsuro Fujita\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 16 Nov 2016 16:38:44 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2016/11/16 16:38, Etsuro Fujita wrote:\n> On 2016/11/16 13:10, Ashutosh Bapat wrote:\n>> I don't see any reason why DML/UPDATE pushdown should depend upon\n>> subquery deparsing or least PHV patch. Combined together they can help\n>> in more cases, but without those patches, we will be able to push-down\n>> more stuff. Probably, we should just restrict push-down only for the\n>> cases when above patches are not needed. That makes reviews easy. Once\n>> those patches get committed, we may add more functionality depending\n>> upon the status of this patch. Does that make sense?\n\n> OK, I'll extract from the patch the minimal part that wouldn't depend on\n> the two patches.\n\nHere is a patch for that. Todo items are: (1) add more comments and (2) \nadd more regression tests. I'll do that in the next version.\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Fri, 18 Nov 2016 12:26:06 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"I started reviewing the patch and here are few initial review points and\nquestions for you.\n\n1)\n-static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\n+static void deparseExplicitTargetList(bool is_returning,\n+ List *tlist,\n+ List **retrieved_attrs,\n deparse_expr_cxt *context);\n\nAny particular reason of inserting new argument as 1st argunment? In general\nwe add new flags at the end or before the out param for the existing\nfunction.\n\n2)\n-static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\n- RelOptInfo *joinrel, bool use_alias, List\n**params_list);\n+static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\nRelOptInfo *foreignrel,\n+ bool use_alias, Index target_rel, List\n**params_list);\n\n\nGoing beyond 80 character length\n\n3)\n static void\n-deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\n+deparseExplicitTargetList(bool is_returning,\n+ List *tlist,\n+ List **retrieved_attrs,\n deparse_expr_cxt *context)\n\nThis looks bit wired to me - as comment for the deparseExplicitTargetList()\nfunction name and comments says different then what its trying to do when\nis_returning flag is passed. Either function comment need to be change or\nmay be separate function fo deparse returning list for join relation?\n\nIs it possible to teach deparseReturningList() to deparse the returning\nlist for the joinrel?\n\n4)\n\n+ if (foreignrel->reloptkind == RELOPT_JOINREL)\n+ {\n+ List *rlist = NIL;\n+\n+ /* Create a RETURNING list */\n+ rlist = make_explicit_returning_list(rtindex, rel,\n+ returningList,\n+ fdw_scan_tlist);\n+\n+ deparseExplicitReturningList(rlist, retrieved_attrs, &context);\n+ }\n+ else\n+ deparseReturningList(buf, root, rtindex, rel, false,\n+ returningList, retrieved_attrs);\n\nThe code will be more centralized if we add the logic of extracting\nreturninglist\nfor JOINREL inside deparseReturningList() only, isn't it?\n\n5) make_explicit_returning_list() pull the var list from the returningList\nand\nbuild the targetentry for the returning list and at the end rewrites the\nfdw_scan_tlist.\n\nAFAIK, in case of DML - which is going to pushdown to the remote server\nideally fdw_scan_tlist should be same as returning list, as final output\nfor the query is query will be RETUNING list only. isn't that true?\n\nIf yes, then why can't we directly replace the fdw_scan_tlist with the\nreturning\nlist, rather then make_explicit_returning_list()?\n\nAlso I think rewriting the fdw_scan_tlist should happen into postgres_fdw.c\n-\nrather then deparse.c.\n\n6) Test coverage for the returning list is missing.\n\n\n\nOn Fri, Nov 18, 2016 at 8:56 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\nwrote:\n\n> On 2016/11/16 16:38, Etsuro Fujita wrote:\n>\n>> On 2016/11/16 13:10, Ashutosh Bapat wrote:\n>>\n>>> I don't see any reason why DML/UPDATE pushdown should depend upon\n>>> subquery deparsing or least PHV patch. Combined together they can help\n>>> in more cases, but without those patches, we will be able to push-down\n>>> more stuff. Probably, we should just restrict push-down only for the\n>>> cases when above patches are not needed. That makes reviews easy. Once\n>>> those patches get committed, we may add more functionality depending\n>>> upon the status of this patch. Does that make sense?\n>>>\n>>\n> OK, I'll extract from the patch the minimal part that wouldn't depend on\n>> the two patches.\n>>\n>\n> Here is a patch for that. Todo items are: (1) add more comments and (2)\n> add more regression tests. I'll do that in the next version.\n>\n> Best regards,\n> Etsuro Fujita\n>\n\n\n\n-- \nRushabh Lathia\n\nI started reviewing the patch and here are few initial review points and questions for you.1)-static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,+static void deparseExplicitTargetList(bool is_returning,+ List *tlist,+ List **retrieved_attrs, deparse_expr_cxt *context);Any particular reason of inserting new argument as 1st argunment? In generalwe add new flags at the end or before the out param for the existing function.2) -static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,- RelOptInfo *joinrel, bool use_alias, List **params_list);+static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root, RelOptInfo *foreignrel,+ bool use_alias, Index target_rel, List **params_list);Going beyond 80 character length3) static void-deparseExplicitTargetList(List *tlist, List **retrieved_attrs,+deparseExplicitTargetList(bool is_returning,+ List *tlist,+ List **retrieved_attrs, deparse_expr_cxt *context)This looks bit wired to me - as comment for the deparseExplicitTargetList()function name and comments says different then what its trying to do whenis_returning flag is passed. Either function comment need to be change ormay be separate function fo deparse returning list for join relation?Is it possible to teach deparseReturningList() to deparse the returninglist for the joinrel?4)+ if (foreignrel->reloptkind == RELOPT_JOINREL)+ {+ List *rlist = NIL;++ /* Create a RETURNING list */+ rlist = make_explicit_returning_list(rtindex, rel,+ returningList,+ fdw_scan_tlist);++ deparseExplicitReturningList(rlist, retrieved_attrs, &context);+ }+ else+ deparseReturningList(buf, root, rtindex, rel, false,+ returningList, retrieved_attrs);The code will be more centralized if we add the logic of extracting returninglistfor JOINREL inside deparseReturningList() only, isn't it?5) make_explicit_returning_list() pull the var list from the returningList andbuild the targetentry for the returning list and at the end rewrites thefdw_scan_tlist. AFAIK, in case of DML - which is going to pushdown to the remote server ideally fdw_scan_tlist should be same as returning list, as final outputfor the query is query will be RETUNING list only. isn't that true?If yes, then why can't we directly replace the fdw_scan_tlist with the returninglist, rather then make_explicit_returning_list()?Also I think rewriting the fdw_scan_tlist should happen into postgres_fdw.c -rather then deparse.c.6) Test coverage for the returning list is missing.On Fri, Nov 18, 2016 at 8:56 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2016/11/16 16:38, Etsuro Fujita wrote:\n\nOn 2016/11/16 13:10, Ashutosh Bapat wrote:\n\nI don't see any reason why DML/UPDATE pushdown should depend upon\nsubquery deparsing or least PHV patch. Combined together they can help\nin more cases, but without those patches, we will be able to push-down\nmore stuff. Probably, we should just restrict push-down only for the\ncases when above patches are not needed. That makes reviews easy. Once\nthose patches get committed, we may add more functionality depending\nupon the status of this patch. Does that make sense?\n\n\n\nOK, I'll extract from the patch the minimal part that wouldn't depend on\nthe two patches.\n\n\nHere is a patch for that. Todo items are: (1) add more comments and (2) add more regression tests. I'll do that in the next version.\n\nBest regards,\nEtsuro Fujita\n-- Rushabh Lathia","msg_date":"Tue, 22 Nov 2016 15:35:42 +0530","msg_from":"Rushabh Lathia <rushabh.lathia@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"Hi Rushabh,\n\nOn 2016/11/22 19:05, Rushabh Lathia wrote:\n> I started reviewing the patch and here are few initial review points and\n> questions for you.\n\nThanks for the review!\n\n> 1)\n> -static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\n> +static void deparseExplicitTargetList(bool is_returning,\n> + List *tlist,\n> + List **retrieved_attrs,\n> deparse_expr_cxt *context);\n>\n> Any particular reason of inserting new argument as 1st argunment? In general\n> we add new flags at the end or before the out param for the existing\n> function.\n\nNo, I don't. I think the *context should be the last argument as in \nother functions in deparse.c. How about inserting that before the out \nparam **retrieved_attrs, like this?\n\nstatic void\ndeparseExplicitTargetList(List *tlist,\n bool is_returning,\n List **retrieved_attrs,\n deparse_expr_cxt *context);\n\n> 2)\n> -static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\n> - RelOptInfo *joinrel, bool use_alias, List\n> **params_list);\n> +static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\n> RelOptInfo *foreignrel,\n> + bool use_alias, Index target_rel, List\n> **params_list);\n\n> Going beyond 80 character length\n\nWill fix.\n\n> 3)\n> static void\n> -deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\n> +deparseExplicitTargetList(bool is_returning,\n> + List *tlist,\n> + List **retrieved_attrs,\n> deparse_expr_cxt *context)\n>\n> This looks bit wired to me - as comment for the deparseExplicitTargetList()\n> function name and comments says different then what its trying to do when\n> is_returning flag is passed. Either function comment need to be change or\n> may be separate function fo deparse returning list for join relation?\n>\n> Is it possible to teach deparseReturningList() to deparse the returning\n> list for the joinrel?\n\nI don't think it's possible to do that because deparseReturningList uses \ndeparseTargetList internally, which only allows us to emit a target list \nfor a baserel. For example, deparseReturningList can't handle a \nreturning list that contains join outputs like this:\n\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a \nreturning ft1.*, ft2.*;\n QUERY PLAN\n------------------------------------------------------------------------------------------------------------------------\n Delete on public.ft1 (cost=100.00..102.06 rows=1 width=46)\n Output: ft1.a, ft1.b, ft2.a, ft2.b\n -> Foreign Delete (cost=100.00..102.06 rows=1 width=46)\n Remote SQL: DELETE FROM public.t1 r1 USING public.t2 r2 WHERE \n((r1.a = r2.a)) RETURNING r1.a, r1.b, r2.a, r2.b\n(4 rows)\n\nI'd like to change the comment for deparseExplicitTargetList.\n\n> 4)\n>\n> + if (foreignrel->reloptkind == RELOPT_JOINREL)\n> + {\n> + List *rlist = NIL;\n> +\n> + /* Create a RETURNING list */\n> + rlist = make_explicit_returning_list(rtindex, rel,\n> + returningList,\n> + fdw_scan_tlist);\n> +\n> + deparseExplicitReturningList(rlist, retrieved_attrs, &context);\n> + }\n> + else\n> + deparseReturningList(buf, root, rtindex, rel, false,\n> + returningList, retrieved_attrs);\n>\n> The code will be more centralized if we add the logic of extracting\n> returninglist\n> for JOINREL inside deparseReturningList() only, isn't it?\n\nYou are right. Will do.\n\n> 5) make_explicit_returning_list() pull the var list from the\n> returningList and\n> build the targetentry for the returning list and at the end rewrites the\n> fdw_scan_tlist.\n>\n> AFAIK, in case of DML - which is going to pushdown to the remote server\n> ideally fdw_scan_tlist should be same as returning list, as final output\n> for the query is query will be RETUNING list only. isn't that true?\n\nThat would be true. But the fdw_scan_tlist passed from the core would \ncontain junk columns inserted by the rewriter and planner work, such as \nCTID for the target table and whole-row Vars for other tables specified \nin the FROM clause of an UPDATE or the USING clause of a DELETE. So, I \ncreated the patch so that the pushed-down UPDATE/DELETE retrieves only \nthe data needed for the RETURNING calculation from the remote server, \nnot the whole fdw_scan_tlist data.\n\n> If yes, then why can't we directly replace the fdw_scan_tlist with the\n> returning\n> list, rather then make_explicit_returning_list()?\n\nI think we could do that if we modified the core (maybe the executor \npart). I'm not sure that's a good idea, though.\n\n> Also I think rewriting the fdw_scan_tlist should happen into\n> postgres_fdw.c -\n> rather then deparse.c.\n\nWill try.\n\n> 6) Test coverage for the returning list is missing.\n\nWill add.\n\nBest regards,\nEtsuro Fujita\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 22 Nov 2016 21:54:55 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On Tue, Nov 22, 2016 at 6:24 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\nwrote:\n\n> Hi Rushabh,\n>\n> On 2016/11/22 19:05, Rushabh Lathia wrote:\n>\n>> I started reviewing the patch and here are few initial review points and\n>> questions for you.\n>>\n>\n> Thanks for the review!\n>\n> 1)\n>> -static void deparseExplicitTargetList(List *tlist, List\n>> **retrieved_attrs,\n>> +static void deparseExplicitTargetList(bool is_returning,\n>> + List *tlist,\n>> + List **retrieved_attrs,\n>> deparse_expr_cxt *context);\n>>\n>> Any particular reason of inserting new argument as 1st argunment? In\n>> general\n>> we add new flags at the end or before the out param for the existing\n>> function.\n>>\n>\n> No, I don't. I think the *context should be the last argument as in other\n> functions in deparse.c. How about inserting that before the out param\n> **retrieved_attrs, like this?\n>\n> static void\n> deparseExplicitTargetList(List *tlist,\n> bool is_returning,\n> List **retrieved_attrs,\n> deparse_expr_cxt *context);\n>\n>\nYes, adding it before retrieved_attrs would be good.\n\n\n> 2)\n>> -static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\n>> - RelOptInfo *joinrel, bool use_alias, List\n>> **params_list);\n>> +static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\n>> RelOptInfo *foreignrel,\n>> + bool use_alias, Index target_rel, List\n>> **params_list);\n>>\n>\n> Going beyond 80 character length\n>>\n>\n> Will fix.\n>\n> 3)\n>> static void\n>> -deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\n>> +deparseExplicitTargetList(bool is_returning,\n>> + List *tlist,\n>> + List **retrieved_attrs,\n>> deparse_expr_cxt *context)\n>>\n>> This looks bit wired to me - as comment for the\n>> deparseExplicitTargetList()\n>> function name and comments says different then what its trying to do when\n>> is_returning flag is passed. Either function comment need to be change or\n>> may be separate function fo deparse returning list for join relation?\n>>\n>> Is it possible to teach deparseReturningList() to deparse the returning\n>> list for the joinrel?\n>>\n>\n> I don't think it's possible to do that because deparseReturningList uses\n> deparseTargetList internally, which only allows us to emit a target list\n> for a baserel. For example, deparseReturningList can't handle a returning\n> list that contains join outputs like this:\n>\n> postgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a\n> returning ft1.*, ft2.*;\n> QUERY PLAN\n> ------------------------------------------------------------\n> ------------------------------------------------------------\n> Delete on public.ft1 (cost=100.00..102.06 rows=1 width=46)\n> Output: ft1.a, ft1.b, ft2.a, ft2.b\n> -> Foreign Delete (cost=100.00..102.06 rows=1 width=46)\n> Remote SQL: DELETE FROM public.t1 r1 USING public.t2 r2 WHERE\n> ((r1.a = r2.a)) RETURNING r1.a, r1.b, r2.a, r2.b\n> (4 rows)\n>\n> I'd like to change the comment for deparseExplicitTargetList.\n>\n> 4)\n>>\n>> + if (foreignrel->reloptkind == RELOPT_JOINREL)\n>> + {\n>> + List *rlist = NIL;\n>> +\n>> + /* Create a RETURNING list */\n>> + rlist = make_explicit_returning_list(rtindex, rel,\n>> + returningList,\n>> + fdw_scan_tlist);\n>> +\n>> + deparseExplicitReturningList(rlist, retrieved_attrs, &context);\n>> + }\n>> + else\n>> + deparseReturningList(buf, root, rtindex, rel, false,\n>> + returningList, retrieved_attrs);\n>>\n>> The code will be more centralized if we add the logic of extracting\n>> returninglist\n>> for JOINREL inside deparseReturningList() only, isn't it?\n>>\n>\n> You are right. Will do.\n>\n> 5) make_explicit_returning_list() pull the var list from the\n>> returningList and\n>> build the targetentry for the returning list and at the end rewrites the\n>> fdw_scan_tlist.\n>>\n>> AFAIK, in case of DML - which is going to pushdown to the remote server\n>> ideally fdw_scan_tlist should be same as returning list, as final output\n>> for the query is query will be RETUNING list only. isn't that true?\n>>\n>\n> That would be true. But the fdw_scan_tlist passed from the core would\n> contain junk columns inserted by the rewriter and planner work, such as\n> CTID for the target table and whole-row Vars for other tables specified in\n> the FROM clause of an UPDATE or the USING clause of a DELETE. So, I\n> created the patch so that the pushed-down UPDATE/DELETE retrieves only the\n> data needed for the RETURNING calculation from the remote server, not the\n> whole fdw_scan_tlist data.\n\n\nYes, I noticed that fdw_scan_tlist have CTID for the target table and\nwhole-raw vars for\nother tables specified in the FROM clause of the DML. But I was thinking\nisn't it possible\nto create new fdw_scan_tlist once we found that DML is direct pushable to\nforeign server?\nI tried quickly doing that - but later its was throwing \"variable not found\nin subplan target list\"\nfrom set_foreignscan_references().\n\n\n>\n> If yes, then why can't we directly replace the fdw_scan_tlist with the\n>> returning\n>> list, rather then make_explicit_returning_list()?\n>>\n>\n> I think we could do that if we modified the core (maybe the executor\n> part). I'm not sure that's a good idea, though.\n\n\nYes modifying core is not good idea. But just want to understand why you\nthink that this need need to modify core?\n\n\n>\n>\n> Also I think rewriting the fdw_scan_tlist should happen into\n>> postgres_fdw.c -\n>> rather then deparse.c.\n>>\n>\n> Will try.\n\n\nThat would be good.\n\n\n>\n>\n> 6) Test coverage for the returning list is missing.\n>>\n>\n> Will add.\n>\n>\nThanks.\n\n\n> Best regards,\n> Etsuro Fujita\n>\n>\n>\n\n\n-- \nRushabh Lathia\n\nOn Tue, Nov 22, 2016 at 6:24 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:Hi Rushabh,\n\nOn 2016/11/22 19:05, Rushabh Lathia wrote:\n\nI started reviewing the patch and here are few initial review points and\nquestions for you.\n\n\nThanks for the review!\n\n\n1)\n-static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\n+static void deparseExplicitTargetList(bool is_returning,\n+ List *tlist,\n+ List **retrieved_attrs,\n deparse_expr_cxt *context);\n\nAny particular reason of inserting new argument as 1st argunment? In general\nwe add new flags at the end or before the out param for the existing\nfunction.\n\n\nNo, I don't. I think the *context should be the last argument as in other functions in deparse.c. How about inserting that before the out param **retrieved_attrs, like this?\n\nstatic void\ndeparseExplicitTargetList(List *tlist,\n bool is_returning,\n List **retrieved_attrs,\n deparse_expr_cxt *context);\nYes, adding it before retrieved_attrs would be good. \n\n2)\n-static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\n- RelOptInfo *joinrel, bool use_alias, List\n**params_list);\n+static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\nRelOptInfo *foreignrel,\n+ bool use_alias, Index target_rel, List\n**params_list);\n\n\n\nGoing beyond 80 character length\n\n\nWill fix.\n\n\n3)\n static void\n-deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\n+deparseExplicitTargetList(bool is_returning,\n+ List *tlist,\n+ List **retrieved_attrs,\n deparse_expr_cxt *context)\n\nThis looks bit wired to me - as comment for the deparseExplicitTargetList()\nfunction name and comments says different then what its trying to do when\nis_returning flag is passed. Either function comment need to be change or\nmay be separate function fo deparse returning list for join relation?\n\nIs it possible to teach deparseReturningList() to deparse the returning\nlist for the joinrel?\n\n\nI don't think it's possible to do that because deparseReturningList uses deparseTargetList internally, which only allows us to emit a target list for a baserel. For example, deparseReturningList can't handle a returning list that contains join outputs like this:\n\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a returning ft1.*, ft2.*;\n QUERY PLAN\n------------------------------------------------------------------------------------------------------------------------\n Delete on public.ft1 (cost=100.00..102.06 rows=1 width=46)\n Output: ft1.a, ft1.b, ft2.a, ft2.b\n -> Foreign Delete (cost=100.00..102.06 rows=1 width=46)\n Remote SQL: DELETE FROM public.t1 r1 USING public.t2 r2 WHERE ((r1.a = r2.a)) RETURNING r1.a, r1.b, r2.a, r2.b\n(4 rows)\n\nI'd like to change the comment for deparseExplicitTargetList.\n\n\n4)\n\n+ if (foreignrel->reloptkind == RELOPT_JOINREL)\n+ {\n+ List *rlist = NIL;\n+\n+ /* Create a RETURNING list */\n+ rlist = make_explicit_returning_list(rtindex, rel,\n+ returningList,\n+ fdw_scan_tlist);\n+\n+ deparseExplicitReturningList(rlist, retrieved_attrs, &context);\n+ }\n+ else\n+ deparseReturningList(buf, root, rtindex, rel, false,\n+ returningList, retrieved_attrs);\n\nThe code will be more centralized if we add the logic of extracting\nreturninglist\nfor JOINREL inside deparseReturningList() only, isn't it?\n\n\nYou are right. Will do.\n\n\n5) make_explicit_returning_list() pull the var list from the\nreturningList and\nbuild the targetentry for the returning list and at the end rewrites the\nfdw_scan_tlist.\n\nAFAIK, in case of DML - which is going to pushdown to the remote server\nideally fdw_scan_tlist should be same as returning list, as final output\nfor the query is query will be RETUNING list only. isn't that true?\n\n\nThat would be true. But the fdw_scan_tlist passed from the core would contain junk columns inserted by the rewriter and planner work, such as CTID for the target table and whole-row Vars for other tables specified in the FROM clause of an UPDATE or the USING clause of a DELETE. So, I created the patch so that the pushed-down UPDATE/DELETE retrieves only the data needed for the RETURNING calculation from the remote server, not the whole fdw_scan_tlist data.Yes, I noticed that fdw_scan_tlist have CTID for the target table and whole-raw vars forother tables specified in the FROM clause of the DML. But I was thinking isn't it possibleto create new fdw_scan_tlist once we found that DML is direct pushable to foreign server?I tried quickly doing that - but later its was throwing \"variable not found in subplan target list\"from set_foreignscan_references(). \n\n\nIf yes, then why can't we directly replace the fdw_scan_tlist with the\nreturning\nlist, rather then make_explicit_returning_list()?\n\n\nI think we could do that if we modified the core (maybe the executor part). I'm not sure that's a good idea, though.Yes modifying core is not good idea. But just want to understand why youthink that this need need to modify core? \n\n\nAlso I think rewriting the fdw_scan_tlist should happen into\npostgres_fdw.c -\nrather then deparse.c.\n\n\nWill try.That would be good. \n\n\n6) Test coverage for the returning list is missing.\n\n\nWill add.\nThanks. \nBest regards,\nEtsuro Fujita\n\n\n-- Rushabh Lathia","msg_date":"Wed, 23 Nov 2016 16:58:19 +0530","msg_from":"Rushabh Lathia <rushabh.lathia@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2016/11/23 20:28, Rushabh Lathia wrote:\n> On Tue, Nov 22, 2016 at 6:24 PM, Etsuro Fujita\n> <fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\n\n> 1)\n> -static void deparseExplicitTargetList(List *tlist, List\n> **retrieved_attrs,\n> +static void deparseExplicitTargetList(bool is_returning,\n> + List *tlist,\n> + List **retrieved_attrs,\n> deparse_expr_cxt *context);\n>\n> Any particular reason of inserting new argument as 1st\n> argunment? In general\n> we add new flags at the end or before the out param for the existing\n> function.\n\n> No, I don't. I think the *context should be the last argument as in\n> other functions in deparse.c. How about inserting that before the\n> out param **retrieved_attrs, like this?\n>\n> static void\n> deparseExplicitTargetList(List *tlist,\n> bool is_returning,\n> List **retrieved_attrs,\n> deparse_expr_cxt *context);\n\n> Yes, adding it before retrieved_attrs would be good.\n\nOK, will do.\n\n> 5) make_explicit_returning_list() pull the var list from the\n> returningList and\n> build the targetentry for the returning list and at the end\n> rewrites the\n> fdw_scan_tlist.\n>\n> AFAIK, in case of DML - which is going to pushdown to the remote\n> server\n> ideally fdw_scan_tlist should be same as returning list, as\n> final output\n> for the query is query will be RETUNING list only. isn't that true?\n\n> That would be true. But the fdw_scan_tlist passed from the core\n> would contain junk columns inserted by the rewriter and planner\n> work, such as CTID for the target table and whole-row Vars for other\n> tables specified in the FROM clause of an UPDATE or the USING clause\n> of a DELETE. So, I created the patch so that the pushed-down\n> UPDATE/DELETE retrieves only the data needed for the RETURNING\n> calculation from the remote server, not the whole fdw_scan_tlist data.\n\n> Yes, I noticed that fdw_scan_tlist have CTID for the target table and\n> whole-raw vars for\n> other tables specified in the FROM clause of the DML. But I was thinking\n> isn't it possible\n> to create new fdw_scan_tlist once we found that DML is direct pushable\n> to foreign server?\n> I tried quickly doing that - but later its was throwing \"variable not\n> found in subplan target list\"\n> from set_foreignscan_references().\n\n> If yes, then why can't we directly replace the fdw_scan_tlist\n> with the\n> returning\n> list, rather then make_explicit_returning_list()?\n\n> I think we could do that if we modified the core (maybe the executor\n> part). I'm not sure that's a good idea, though.\n\n> Yes modifying core is not good idea. But just want to understand why you\n> think that this need need to modify core?\n\nSorry, I don't remember that. Will check.\n\nI'd like to move this to the next CF.\n\nThank you for the comments!\n\nBest regards,\nEtsuro Fujita\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 30 Nov 2016 17:29:47 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2016/11/30 17:29, Etsuro Fujita wrote:\n> On 2016/11/23 20:28, Rushabh Lathia wrote:\n\nI wrote:\n>> How about inserting that before the\n>> out param **retrieved_attrs, like this?\n>>\n>> static void\n>> deparseExplicitTargetList(List *tlist,\n>> bool is_returning,\n>> List **retrieved_attrs,\n>> deparse_expr_cxt *context);\n\n>> Yes, adding it before retrieved_attrs would be good.\n\n> OK, will do.\n\nDone.\n\nYou wrote:\n>> 5) make_explicit_returning_list() pull the var list from the\n>> returningList and\n>> build the targetentry for the returning list and at the end\n>> rewrites the\n>> fdw_scan_tlist.\n>>\n>> AFAIK, in case of DML - which is going to pushdown to the remote\n>> server\n>> ideally fdw_scan_tlist should be same as returning list, as\n>> final output\n>> for the query is query will be RETUNING list only. isn't that\n>> true?\n\nI wrote:\n>> That would be true. But the fdw_scan_tlist passed from the core\n>> would contain junk columns inserted by the rewriter and planner\n>> work, such as CTID for the target table and whole-row Vars for other\n>> tables specified in the FROM clause of an UPDATE or the USING clause\n>> of a DELETE. So, I created the patch so that the pushed-down\n>> UPDATE/DELETE retrieves only the data needed for the RETURNING\n>> calculation from the remote server, not the whole fdw_scan_tlist\n>> data.\n\n>> Yes, I noticed that fdw_scan_tlist have CTID for the target table and\n>> whole-raw vars for\n>> other tables specified in the FROM clause of the DML. But I was thinking\n>> isn't it possible\n>> to create new fdw_scan_tlist once we found that DML is direct pushable\n>> to foreign server?\n>> I tried quickly doing that - but later its was throwing \"variable not\n>> found in subplan target list\"\n>> from set_foreignscan_references().\n\nWe could probably avoid that error by replacing the targetlist of the \nsubplan with fdw_scan_tlist, but that wouldn't be enough ...\n\nYou wrote:\n>> If yes, then why can't we directly replace the fdw_scan_tlist\n>> with the\n>> returning\n>> list, rather then make_explicit_returning_list()?\n\nI wrote:\n>> I think we could do that if we modified the core (maybe the executor\n>> part). I'm not sure that's a good idea, though.\n\n>> Yes modifying core is not good idea. But just want to understand why you\n>> think that this need need to modify core?\n\n> Sorry, I don't remember that. Will check.\n\nThe reason why I think so is that the ModifyTable node on top of the \nForeignScan node requires that the targetlist of the ForeignScan has (1) \njunk whole-row Vars for secondary relations in UPDATE/DELETE and (2) all \nattributes of the target relation to produce the new tuple for UPDATE. \n(So, it wouldn't be enough to just replace the ForeignScan's targetlist \nwith fdw_scan_tlist!) For #1, see this (and the following code) in \nExecInitModifyTable:\n\n /*\n * If we have any secondary relations in an UPDATE or DELETE, they \nneed to\n * be treated like non-locked relations in SELECT FOR UPDATE, ie, the\n * EvalPlanQual mechanism needs to be told about them. Locate the\n * relevant ExecRowMarks.\n */\n\nAnd for #2, see this (and the following code, especially where calling \nExecCheckPlanOutput) in the same function:\n\n * This section of code is also a convenient place to verify that the\n * output of an INSERT or UPDATE matches the target table(s).\n\nWhat you proposed would be a good idea because the FDW could calculate \nthe user-query RETURNING list more efficiently in some cases, but I'd \nlike to leave that for future work.\n\nAttached is the new version of the patch. I also addressed other \ncomments from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c, \nadded/revised comments, and added regression tests for the case where a \npushed down UPDATE/DELETE on a join has RETURNING.\n\nMy apologies for having been late to work on this.\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 25 Jan 2017 19:20:22 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On Wed, Jan 25, 2017 at 7:20 PM, Etsuro Fujita\n<fujita.etsuro@lab.ntt.co.jp> wrote:\n> Attached is the new version of the patch. I also addressed other comments\n> from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c,\n> added/revised comments, and added regression tests for the case where a\n> pushed down UPDATE/DELETE on a join has RETURNING.\n>\n> My apologies for having been late to work on this.\n\nMoved to CF 2017-03.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 1 Feb 2017 15:20:54 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"Sorry for delay in the review.\n\nI started reviewing the patch again. Patch applied cleanly on latest source\nas well as regression pass through with the patch. I also performed\nfew manual testing and haven't found any regression. Patch look\nmuch cleaner the earlier version, and don't have any major concern as\nsuch. Here are few comments:\n\n1)\n\n@@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\n PGresult *result; /* result for query */\n int num_tuples; /* # of result tuples */\n int next_tuple; /* index of next one to return */\n+ Relation resultRel; /* relcache entry for the target table */\n\n\nWhy we need resultRel? Can't we directly use dmstate->rel ?\n\n\n2) In the patch somewhere scanrelid condition being used as\nfscan->scan.scanrelid == 0 where as some place its been used as\nfsplan->scan.scanrelid > 0. Infact in the same function its been used\ndifferently example postgresBeginDirectModify. Can make this consistent.\n\n3)\n\n+ * If UPDATE/DELETE on a join, create a RETURINING list used in the\nremote\n+ * query.\n+ */\n+ if (fscan->scan.scanrelid == 0)\n+ returningList = make_explicit_returning_list(resultRelation, rel,\n+ returningList);\n+\n\nAbove block can be moved inside the if (plan->returningLists) condition\nabove\nthe block. Like this:\n\n /*\n * Extract the relevant RETURNING list if any.\n */\n if (plan->returningLists)\n {\n returningList = (List *) list_nth(plan->returningLists,\nsubplan_index);\n\n /*\n * If UPDATE/DELETE on a join, create a RETURINING list used in the\nremote\n * query.\n */\n if (fscan->scan.scanrelid == 0)\n returningList = make_explicit_returning_list(resultRelation,\n rel,\n returningList);\n }\n\n\nI am still doing few more testing with the patch, if I will found anything\napart from\nthis I will raise that into another mail.\n\nThanks,\n\n\n\nOn Wed, Feb 1, 2017 at 11:50 AM, Michael Paquier <michael.paquier@gmail.com>\nwrote:\n\n> On Wed, Jan 25, 2017 at 7:20 PM, Etsuro Fujita\n> <fujita.etsuro@lab.ntt.co.jp> wrote:\n> > Attached is the new version of the patch. I also addressed other\n> comments\n> > from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c,\n> > added/revised comments, and added regression tests for the case where a\n> > pushed down UPDATE/DELETE on a join has RETURNING.\n> >\n> > My apologies for having been late to work on this.\n>\n> Moved to CF 2017-03.\n> --\n> Michael\n>\n\n\n\n-- \nRushabh Lathia\n\nSorry for delay in the review.I started reviewing the patch again. Patch applied cleanly on latest sourceas well as regression pass through with the patch. I also performedfew manual testing and haven't found any regression. Patch lookmuch cleaner the earlier version, and don't have any major concern as such. Here are few comments:1) @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState PGresult *result; /* result for query */ int num_tuples; /* # of result tuples */ int next_tuple; /* index of next one to return */+ Relation resultRel; /* relcache entry for the target table */Why we need resultRel? Can't we directly use dmstate->rel ?2) In the patch somewhere scanrelid condition being used asfscan->scan.scanrelid == 0 where as some place its been used asfsplan->scan.scanrelid > 0. Infact in the same function its been useddifferently example postgresBeginDirectModify. Can make this consistent.3)+ * If UPDATE/DELETE on a join, create a RETURINING list used in the remote+ * query.+ */+ if (fscan->scan.scanrelid == 0)+ returningList = make_explicit_returning_list(resultRelation, rel,+ returningList);+Above block can be moved inside the if (plan->returningLists) condition abovethe block. Like this: /* * Extract the relevant RETURNING list if any. */ if (plan->returningLists) { returningList = (List *) list_nth(plan->returningLists, subplan_index); /* * If UPDATE/DELETE on a join, create a RETURINING list used in the remote * query. */ if (fscan->scan.scanrelid == 0) returningList = make_explicit_returning_list(resultRelation, rel, returningList); }I am still doing few more testing with the patch, if I will found anything apart fromthis I will raise that into another mail.Thanks,On Wed, Feb 1, 2017 at 11:50 AM, Michael Paquier <michael.paquier@gmail.com> wrote:On Wed, Jan 25, 2017 at 7:20 PM, Etsuro Fujita\n<fujita.etsuro@lab.ntt.co.jp> wrote:\n> Attached is the new version of the patch. I also addressed other comments\n> from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c,\n> added/revised comments, and added regression tests for the case where a\n> pushed down UPDATE/DELETE on a join has RETURNING.\n>\n> My apologies for having been late to work on this.\n\nMoved to CF 2017-03.\n--\nMichael\n-- Rushabh Lathia","msg_date":"Mon, 13 Feb 2017 14:54:24 +0530","msg_from":"Rushabh Lathia <rushabh.lathia@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2017/02/13 18:24, Rushabh Lathia wrote:\n> I started reviewing the patch again. Patch applied cleanly on latest source\n> as well as regression pass through with the patch. I also performed\n> few manual testing and haven't found any regression. Patch look\n> much cleaner the earlier version, and don't have any major concern as\n> such.\n\nThanks for the review!\n\n> Here are few comments:\n>\n> 1)\n>\n> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\n> PGresult *result; /* result for query */\n> int num_tuples; /* # of result tuples */\n> int next_tuple; /* index of next one to return */\n> + Relation resultRel; /* relcache entry for the target table */\n\n> Why we need resultRel? Can't we directly use dmstate->rel ?\n\nThe reason why we need that is because in get_returning_data, we pass \ndmstate->rel to make_tuple_from_result_row, which requires that \ndmstate->rel be NULL when the scan tuple is described by fdw_scan_tlist. \n So in that case we set dmstate->rel to NULL and have \ndmstate->resultRel that is the relcache entry for the target relation in \npostgresBeginDirectModify.\n\n> 2) In the patch somewhere scanrelid condition being used as\n> fscan->scan.scanrelid == 0 where as some place its been used as\n> fsplan->scan.scanrelid > 0. Infact in the same function its been used\n> differently example postgresBeginDirectModify. Can make this consistent.\n\nOk, done.\n\n> 3)\n>\n> + * If UPDATE/DELETE on a join, create a RETURINING list used in the\n> remote\n> + * query.\n> + */\n> + if (fscan->scan.scanrelid == 0)\n> + returningList = make_explicit_returning_list(resultRelation, rel,\n> + returningList);\n> +\n>\n> Above block can be moved inside the if (plan->returningLists) condition\n> above\n> the block. Like this:\n>\n> /*\n> * Extract the relevant RETURNING list if any.\n> */\n> if (plan->returningLists)\n> {\n> returningList = (List *) list_nth(plan->returningLists,\n> subplan_index);\n>\n> /*\n> * If UPDATE/DELETE on a join, create a RETURINING list used in\n> the remote\n> * query.\n> */\n> if (fscan->scan.scanrelid == 0)\n> returningList = make_explicit_returning_list(resultRelation,\n> rel,\n> returningList);\n> }\n\nDone that way.\n\nAnother thing I noticed is duplicate work in apply_returning_filter; it \ninitializes tableoid of an updated/deleted tuple if needed, but the core \nwill do that (see ExecProcessReturning). I removed that work from \napply_returning_filter.\n\n> I am still doing few more testing with the patch, if I will found\n> anything apart from\n> this I will raise that into another mail.\n\nThanks again!\n\nAttached is an updated version of the patch.\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 20 Feb 2017 17:11:15 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\nwrote:\n\n> On 2017/02/13 18:24, Rushabh Lathia wrote:\n>\n>> I started reviewing the patch again. Patch applied cleanly on latest\n>> source\n>> as well as regression pass through with the patch. I also performed\n>> few manual testing and haven't found any regression. Patch look\n>> much cleaner the earlier version, and don't have any major concern as\n>> such.\n>>\n>\n> Thanks for the review!\n>\n> Here are few comments:\n>>\n>> 1)\n>>\n>> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\n>> PGresult *result; /* result for query */\n>> int num_tuples; /* # of result tuples */\n>> int next_tuple; /* index of next one to return */\n>> + Relation resultRel; /* relcache entry for the target table\n>> */\n>>\n>\n> Why we need resultRel? Can't we directly use dmstate->rel ?\n>>\n>\n> The reason why we need that is because in get_returning_data, we pass\n> dmstate->rel to make_tuple_from_result_row, which requires that\n> dmstate->rel be NULL when the scan tuple is described by fdw_scan_tlist.\n> So in that case we set dmstate->rel to NULL and have dmstate->resultRel\n> that is the relcache entry for the target relation in\n> postgresBeginDirectModify.\n>\n>\nThanks for the explanation. We might do something here by using\nfdw_scan_tlist or changing the assumption of make_tuple_from_result_row(),\nand that way we can avoid two similar variable pointer in the\nPgFdwDirectModifyState.\n\nI am okay with currently also, but it adding a note somewhere about this\nwould be great. Also let keep this point open for the committer, if\ncommitter feel this is good then lets go ahead with this.\n\nHere are few other cosmetic changes:\n\n1)\n\n+ *\n+ * 'target_rel' is either zero or the rangetable index of a target\nrelation.\n+ * In the latter case this construncts FROM clause of UPDATE or USING\nclause\n+ * of DELETE by simply ignoring the target relation while deparsing the\ngiven\n\nSpell correction: - construncts\n\n2)\n\n+ /*\n+ * If either input is the target relation, get all the joinclauses.\n+ * Otherwise extract conditions mentioning the target relation from\n+ * the joinclauses.\n+ */\n\n\nspace between joinclauses needed.\n\n3)\n\n+ /*\n+ * If UPDATE/DELETE on a join, create a RETURINING list used in the\n+ * remote query.\n+ */\n+ if (fscan->scan.scanrelid == 0)\n+ returningList = make_explicit_returning_list(resultRelation,\n+ rel,\n+ returningList);\n\n\nSpell correction: RETURINING\n\nI did above changes in the attached patch. Please have a look once and\nthen I feel like this patch is ready for committer.\n\nThanks,\nRushabh Lathia\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Tue, 21 Feb 2017 16:01:54 +0530","msg_from":"Rushabh Lathia <rushabh.lathia@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2017/02/21 19:31, Rushabh Lathia wrote:\n> On Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita\n> <fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\n\n> On 2017/02/13 18:24, Rushabh Lathia wrote:\n> Here are few comments:\n>\n> 1)\n>\n> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\n> PGresult *result; /* result for query */\n> int num_tuples; /* # of result tuples */\n> int next_tuple; /* index of next one to\n> return */\n> + Relation resultRel; /* relcache entry for the\n> target table */\n>\n>\n> Why we need resultRel? Can't we directly use dmstate->rel ?\n>\n>\n> The reason why we need that is because in get_returning_data, we\n> pass dmstate->rel to make_tuple_from_result_row, which requires that\n> dmstate->rel be NULL when the scan tuple is described by\n> fdw_scan_tlist. So in that case we set dmstate->rel to NULL and\n> have dmstate->resultRel that is the relcache entry for the target\n> relation in postgresBeginDirectModify.\n\n> Thanks for the explanation. We might do something here by using\n> fdw_scan_tlist or changing the assumption of\n> make_tuple_from_result_row(), and that way we can avoid two similar\n> variable pointer in the PgFdwDirectModifyState.\n\nI agree that the two similar variables are annoying, to some extent, but \nISTM that is not that bad because that makes the handling of \ndmstate->rel consistent with that of PgFdwScanState's rel. As you know, \nPgFdwDirectModifyState is defined in a similar way as PgFdwScanState, in \nwhich the rel is a relcache entry for the foreign table for a simple \nforeign table scan and NULL for a foreign join scan (see comments for \nthe definition of PgFdwScanState).\n\n> I am okay with currently also, but it adding a note somewhere about this\n> would be great. Also let keep this point open for the committer, if\n> committer feel this is good then lets go ahead with this.\n\nAgreed.\n\n> Here are few other cosmetic changes:\n>\n> 1)\n>\n> + *\n> + * 'target_rel' is either zero or the rangetable index of a target\n> relation.\n> + * In the latter case this construncts FROM clause of UPDATE or USING\n> clause\n> + * of DELETE by simply ignoring the target relation while deparsing the\n> given\n>\n> Spell correction: - construncts\n>\n> 2)\n>\n> + /*\n> + * If either input is the target relation, get all the joinclauses.\n> + * Otherwise extract conditions mentioning the target relation from\n> + * the joinclauses.\n> + */\n>\n>\n> space between joinclauses needed.\n>\n> 3)\n>\n> + /*\n> + * If UPDATE/DELETE on a join, create a RETURINING list used in the\n> + * remote query.\n> + */\n> + if (fscan->scan.scanrelid == 0)\n> + returningList = make_explicit_returning_list(resultRelation,\n> + rel,\n> + returningList);\n>\n>\n> Spell correction: RETURINING\n\nGood catch!\n\n> I did above changes in the attached patch. Please have a look once and\n\nI'm fine with that. Thanks for the patch!\n\n> then I feel like this patch is ready for committer.\n\nThanks for reviewing!\n\nBest regards,\nEtsuro Fujita\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 22 Feb 2017 15:45:50 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On Wed, Feb 22, 2017 at 12:15 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp\n> wrote:\n\n> On 2017/02/21 19:31, Rushabh Lathia wrote:\n>\n>> On Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita\n>> <fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\n>>\n>\n> On 2017/02/13 18:24, Rushabh Lathia wrote:\n>> Here are few comments:\n>>\n>> 1)\n>>\n>> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\n>> PGresult *result; /* result for query */\n>> int num_tuples; /* # of result tuples */\n>> int next_tuple; /* index of next one to\n>> return */\n>> + Relation resultRel; /* relcache entry for the\n>> target table */\n>>\n>>\n>> Why we need resultRel? Can't we directly use dmstate->rel ?\n>>\n>>\n>> The reason why we need that is because in get_returning_data, we\n>> pass dmstate->rel to make_tuple_from_result_row, which requires that\n>> dmstate->rel be NULL when the scan tuple is described by\n>> fdw_scan_tlist. So in that case we set dmstate->rel to NULL and\n>> have dmstate->resultRel that is the relcache entry for the target\n>> relation in postgresBeginDirectModify.\n>>\n>\n> Thanks for the explanation. We might do something here by using\n>> fdw_scan_tlist or changing the assumption of\n>> make_tuple_from_result_row(), and that way we can avoid two similar\n>> variable pointer in the PgFdwDirectModifyState.\n>>\n>\n> I agree that the two similar variables are annoying, to some extent, but\n> ISTM that is not that bad because that makes the handling of dmstate->rel\n> consistent with that of PgFdwScanState's rel. As you know,\n> PgFdwDirectModifyState is defined in a similar way as PgFdwScanState, in\n> which the rel is a relcache entry for the foreign table for a simple\n> foreign table scan and NULL for a foreign join scan (see comments for the\n> definition of PgFdwScanState).\n>\n> I am okay with currently also, but it adding a note somewhere about this\n>> would be great. Also let keep this point open for the committer, if\n>> committer feel this is good then lets go ahead with this.\n>>\n>\n> Agreed.\n>\n>\nThanks.\n\nMarked this as Ready for Committer.\n\n\n> Here are few other cosmetic changes:\n>>\n>> 1)\n>>\n>> + *\n>> + * 'target_rel' is either zero or the rangetable index of a target\n>> relation.\n>> + * In the latter case this construncts FROM clause of UPDATE or USING\n>> clause\n>> + * of DELETE by simply ignoring the target relation while deparsing the\n>> given\n>>\n>> Spell correction: - construncts\n>>\n>> 2)\n>>\n>> + /*\n>> + * If either input is the target relation, get all the\n>> joinclauses.\n>> + * Otherwise extract conditions mentioning the target relation\n>> from\n>> + * the joinclauses.\n>> + */\n>>\n>>\n>> space between joinclauses needed.\n>>\n>> 3)\n>>\n>> + /*\n>> + * If UPDATE/DELETE on a join, create a RETURINING list used in\n>> the\n>> + * remote query.\n>> + */\n>> + if (fscan->scan.scanrelid == 0)\n>> + returningList = make_explicit_returning_list(resultRelation,\n>> + rel,\n>> + returningList);\n>>\n>>\n>> Spell correction: RETURINING\n>>\n>\n> Good catch!\n>\n> I did above changes in the attached patch. Please have a look once and\n>>\n>\n> I'm fine with that. Thanks for the patch!\n>\n> then I feel like this patch is ready for committer.\n>>\n>\n> Thanks for reviewing!\n>\n> Best regards,\n> Etsuro Fujita\n>\n>\n>\n\n\n-- \nRushabh Lathia\n\nOn Wed, Feb 22, 2017 at 12:15 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2017/02/21 19:31, Rushabh Lathia wrote:\n\nOn Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita\n<fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\n\n\n\n On 2017/02/13 18:24, Rushabh Lathia wrote:\n Here are few comments:\n\n 1)\n\n @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\n PGresult *result; /* result for query */\n int num_tuples; /* # of result tuples */\n int next_tuple; /* index of next one to\n return */\n + Relation resultRel; /* relcache entry for the\n target table */\n\n\n Why we need resultRel? Can't we directly use dmstate->rel ?\n\n\n The reason why we need that is because in get_returning_data, we\n pass dmstate->rel to make_tuple_from_result_row, which requires that\n dmstate->rel be NULL when the scan tuple is described by\n fdw_scan_tlist. So in that case we set dmstate->rel to NULL and\n have dmstate->resultRel that is the relcache entry for the target\n relation in postgresBeginDirectModify.\n\n\n\nThanks for the explanation. We might do something here by using\nfdw_scan_tlist or changing the assumption of\nmake_tuple_from_result_row(), and that way we can avoid two similar\nvariable pointer in the PgFdwDirectModifyState.\n\n\nI agree that the two similar variables are annoying, to some extent, but ISTM that is not that bad because that makes the handling of dmstate->rel consistent with that of PgFdwScanState's rel. As you know, PgFdwDirectModifyState is defined in a similar way as PgFdwScanState, in which the rel is a relcache entry for the foreign table for a simple foreign table scan and NULL for a foreign join scan (see comments for the definition of PgFdwScanState).\n\n\nI am okay with currently also, but it adding a note somewhere about this\nwould be great. Also let keep this point open for the committer, if\ncommitter feel this is good then lets go ahead with this.\n\n\nAgreed.Thanks.Marked this as Ready for Committer.\n\n\nHere are few other cosmetic changes:\n\n1)\n\n+ *\n+ * 'target_rel' is either zero or the rangetable index of a target\nrelation.\n+ * In the latter case this construncts FROM clause of UPDATE or USING\nclause\n+ * of DELETE by simply ignoring the target relation while deparsing the\ngiven\n\nSpell correction: - construncts\n\n2)\n\n+ /*\n+ * If either input is the target relation, get all the joinclauses.\n+ * Otherwise extract conditions mentioning the target relation from\n+ * the joinclauses.\n+ */\n\n\nspace between joinclauses needed.\n\n3)\n\n+ /*\n+ * If UPDATE/DELETE on a join, create a RETURINING list used in the\n+ * remote query.\n+ */\n+ if (fscan->scan.scanrelid == 0)\n+ returningList = make_explicit_returning_list(resultRelation,\n+ rel,\n+ returningList);\n\n\nSpell correction: RETURINING\n\n\nGood catch!\n\n\nI did above changes in the attached patch. Please have a look once and\n\n\nI'm fine with that. Thanks for the patch!\n\n\nthen I feel like this patch is ready for committer.\n\n\nThanks for reviewing!\n\nBest regards,\nEtsuro Fujita\n\n\n-- Rushabh Lathia","msg_date":"Wed, 22 Feb 2017 16:27:55 +0530","msg_from":"Rushabh Lathia <rushabh.lathia@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 2017/02/22 19:57, Rushabh Lathia wrote:\n> Marked this as Ready for Committer.\n\nI noticed that this item in the CF app was incorrectly marked as \nCommitted. This patch isn't committed, so I returned it to the previous \nstatus. I also rebased the patch. Attached is a new version of the patch.\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Wed, 22 Mar 2017 19:20:52 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":true,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On Wed, Mar 22, 2017 at 6:20 AM, Etsuro Fujita\n<fujita.etsuro@lab.ntt.co.jp> wrote:\n> On 2017/02/22 19:57, Rushabh Lathia wrote:\n>> Marked this as Ready for Committer.\n>\n> I noticed that this item in the CF app was incorrectly marked as Committed.\n> This patch isn't committed, so I returned it to the previous status. I also\n> rebased the patch. Attached is a new version of the patch.\n\nSorry, I marked the wrong patch as committed. Apologies for that.\n\nThis doesn't apply any more because of recent changes.\n\ngit diff --check complains:\ncontrib/postgres_fdw/postgres_fdw.c:3653: space before tab in indent.\n\n+ /* Shouldn't contain the target relation. */\n+ Assert(target_rel == 0);\n\nThis comment should give a reason.\n\n void\n deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,\n Index rtindex, Relation rel,\n+ RelOptInfo *foreignrel,\n List *targetlist,\n List *targetAttrs,\n List *remote_conds,\n\nCould you add a comment explaining the meaning of these various\narguments? It takes rtindex, rel, and foreignrel, which apparently\nare all different things, but the meaning is not explained.\n\n /*\n+ * Add a RETURNING clause, if needed, to an UPDATE/DELETE on a join.\n+ */\n+static void\n+deparseExplicitReturningList(List *rlist,\n+ List **retrieved_attrs,\n+ deparse_expr_cxt *context)\n+{\n+ deparseExplicitTargetList(rlist, true, retrieved_attrs, context);\n+}\n\nDo we really want to add a function for one line of code?\n\n+/*\n+ * Look for conditions mentioning the target relation in the given join tree,\n+ * which will be pulled up into the WHERE clause. Note that this is safe due\n+ * to the same reason stated in comments in deparseFromExprForRel.\n+ */\n\nThe comments for deparseFromExprForRel do not seem to address the\ntopic of why this is safe. Also, the answer to the question \"safe\nfrom what?\" is not clear.\n\n- deparseReturningList(buf, root, rtindex, rel, false,\n- returningList, retrieved_attrs);\n+ if (foreignrel->reloptkind == RELOPT_JOINREL)\n+ deparseExplicitReturningList(returningList, retrieved_attrs, &context);\n+ else\n+ deparseReturningList(buf, root, rtindex, rel, false,\n+ returningList, retrieved_attrs);\n\nWhy do these cases need to be handled differently? Maybe add a brief comment?\n\n+ if ((outerrel->reloptkind == RELOPT_BASEREL &&\n+ outerrel->relid == target_rel) ||\n+ (innerrel->reloptkind == RELOPT_BASEREL &&\n+ innerrel->relid == target_rel))\n\n1. Surely it's redundant to check the RelOptKind if the RTI matches?\n\n2. Generally, the tests in this patch against various RelOptKind\nvalues should be adapted to use the new macros introduced in\n7a39b5e4d11229ece930a51fd7cb29e535db4494.\n\nThe regression tests remove every remaining case where an update or\ndelete gets fails to get pushed to the remote side. I think we should\nstill test that path, because we've still got that code. Maybe use a\nnon-pushable function in the join clause, or something.\n\nThe new test cases could use some brief comments explaining their purpose.\n\n if (plan->returningLists)\n+ {\n returningList = (List *) list_nth(plan->returningLists, subplan_index);\n\n+ /*\n+ * If UPDATE/DELETE on a join, create a RETURNING list used in the\n+ * remote query.\n+ */\n+ if (fscan->scan.scanrelid == 0)\n+ returningList = make_explicit_returning_list(resultRelation,\n+ rel,\n+ returningList);\n+ }\n\nAgain, the comment doesn't really explain why we're doing this. And\ninitializing returningList twice in a row seems strange, too.\n\nI am unfortunately too tired to finish properly reviewing this tonight. :-(\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 7 Apr 2017 21:28:34 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On 3/22/17 6:20 AM, Etsuro Fujita wrote:\n> On 2017/02/22 19:57, Rushabh Lathia wrote:\n>> Marked this as Ready for Committer.\n> \n> I noticed that this item in the CF app was incorrectly marked as\n> Committed. This patch isn't committed, so I returned it to the previous\n> status. I also rebased the patch. Attached is a new version of the patch.\n\nThis submission has been moved to CF 2017-07.\n\n-- \n-David\ndavid@pgmasters.net\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 8 Apr 2017 10:14:24 -0400","msg_from":"David Steele <david@pgmasters.net>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"> On 08 Apr 2017, at 16:14, David Steele <david@pgmasters.net> wrote:\n> \n> On 3/22/17 6:20 AM, Etsuro Fujita wrote:\n>> On 2017/02/22 19:57, Rushabh Lathia wrote:\n>>> Marked this as Ready for Committer.\n>> \n>> I noticed that this item in the CF app was incorrectly marked as\n>> Committed. This patch isn't committed, so I returned it to the previous\n>> status. I also rebased the patch. Attached is a new version of the patch.\n> \n> This submission has been moved to CF 2017-07.\n\nThis patch has been marked Ready for Committer in the current commitfest\nwithout being committed or rejected. Moving to the next commitfest, but since\nit has bitrotted I’m moving it to Waiting for author.\n\ncheers ./daniel\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 2 Oct 2017 02:08:02 +0200","msg_from":"Daniel Gustafsson <daniel@yesql.se>","msg_from_op":false,"msg_subject":"Re: Push down more UPDATEs/DELETEs in postgres_fdw"},{"msg_contents":"On Mon, Oct 2, 2017 at 9:08 AM, Daniel Gustafsson <daniel@yesql.se> wrote:\n> This patch has been marked Ready for Committer in the current commitfest\n> without being committed or rejected. Moving to the next commitfest, but since\n> it has bitrotted I’m moving it to Waiting for author.\n\nNo updates have showed up since, so returned with feedback. Please\nfeel free to send a new version if you can hack it.\n-- \nMichael\n\n","msg_date":"Wed, 29 Nov 2017 13:51:58 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: [HACKERS] Push down more UPDATEs/DELETEs in postgres_fdw"}],"string":"[\n {\n \"msg_contents\": \"Hi,\\n\\nAttached is a WIP patch extending the postgres_fdw DML pushdown in 9.6 \\nso that it can perform an update/delete on a join remotely. An example \\nis shown below:\\n\\n* without the patch:\\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\\n \\n QUERY PLAN\\n\\n--------------------------------------------------------------------------------------------------------------------------------------------------------\\n---------------------------\\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n Remote SQL: DELETE FROM public.t1 WHERE ctid = $1\\n -> Foreign Scan (cost=100.00..102.04 rows=1 width=38)\\n Output: ft1.ctid, ft2.*\\n Relations: (public.ft1) INNER JOIN (public.ft2)\\n Remote SQL: SELECT r1.ctid, CASE WHEN (r2.*)::text IS NOT NULL \\nTHEN ROW(r2.a, r2.b) END FROM (public.t1 r1 INNER JOIN public.t2 r2 ON \\n(((r1.a =\\n r2.a)))) FOR UPDATE OF r1\\n -> Nested Loop (cost=200.00..202.07 rows=1 width=38)\\n Output: ft1.ctid, ft2.*\\n Join Filter: (ft1.a = ft2.a)\\n -> Foreign Scan on public.ft1 (cost=100.00..101.03 \\nrows=1 width=10)\\n Output: ft1.ctid, ft1.a\\n Remote SQL: SELECT a, ctid FROM public.t1 FOR UPDATE\\n -> Foreign Scan on public.ft2 (cost=100.00..101.03 \\nrows=1 width=36)\\n Output: ft2.*, ft2.a\\n Remote SQL: SELECT a, b FROM public.t2\\n(15 rows)\\n\\n* with the patch:\\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\\n QUERY PLAN\\n-----------------------------------------------------------------------------------------------------------------------------\\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\\n Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a, b), \\na FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\\n(3 rows)\\n\\nThe WIP patch has been created on top of the join pushdown patch [1]. \\nSo, for testing, please apply the patch in [1] first.\\n\\nI'll add this to the the November commitfest.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n[1] \\nhttps://www.postgresql.org/message-id/1688885b-5fb1-8bfa-b1b8-c2758dbe0b38@lab.ntt.co.jp\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 6 Sep 2016 21:45:34 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"Thanks Fujita-san for working on this.\\n\\n\\n> * with the patch:\\n> postgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\\n> QUERY PLAN\\n> ------------------------------------------------------------\\n> -----------------------------------------------------------------\\n> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\\n> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a, b), a\\n> FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\\n> (3 rows)\\n>\\n> The WIP patch has been created on top of the join pushdown patch [1]. So,\\n> for testing, please apply the patch in [1] first.\\n>\\n>\\nThe underlying scan on t2 requires ROW(a,b) for locking the row for\\nupdate/share. But clearly it's not required if the full query is being\\npushed down. Is there a way we can detect that ROW(a,b) is useless column\\n(not used anywhere in the other parts of the query like RETURNING, DELETE\\nclause etc.) and eliminate it? Similarly for a, it's part of the targetlist\\nof the underlying scan so that the WHERE clause can be applied on it. But\\nit's not needed if we are pushing down the query. If we eliminate the\\ntargetlist of the query, we could construct a remote query without having\\nsubquery in it, making it more readable.\\n\\n-- \\nBest Wishes,\\nAshutosh Bapat\\nEnterpriseDB Corporation\\nThe Postgres Database Company\\n\\nThanks Fujita-san for working on this.\\n\\n* with the patch:\\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\\n QUERY PLAN\\n-----------------------------------------------------------------------------------------------------------------------------\\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\\n Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a, b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\\n(3 rows)\\n\\nThe WIP patch has been created on top of the join pushdown patch [1]. So, for testing, please apply the patch in [1] first.\\nThe underlying scan on t2 requires ROW(a,b) for locking the row for update/share. But clearly it's not required if the full query is being pushed down. Is there a way we can detect that ROW(a,b) is useless column (not used anywhere in the other parts of the query like RETURNING, DELETE clause etc.) and eliminate it? Similarly for a, it's part of the targetlist of the underlying scan so that the WHERE clause can be applied on it. But it's not needed if we are pushing down the query. If we eliminate the targetlist of the query, we could construct a remote query without having subquery in it, making it more readable.-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company\",\n \"msg_date\": \"Wed, 7 Sep 2016 09:51:12 +0530\",\n \"msg_from\": \"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2016/09/07 13:21, Ashutosh Bapat wrote:\\n> * with the patch:\\n> postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\\n> ft2.a;\\n> QUERY PLAN\\n> -----------------------------------------------------------------------------------------------------------------------------\\n> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\\n> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\\n> b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\\n> (3 rows)\\n\\n> The underlying scan on t2 requires ROW(a,b) for locking the row for\\n> update/share. But clearly it's not required if the full query is being\\n> pushed down.\\n\\nExactly.\\n\\n> Is there a way we can detect that ROW(a,b) is useless\\n> column (not used anywhere in the other parts of the query like\\n> RETURNING, DELETE clause etc.) and eliminate it?\\n\\nI don't have a clear solution for that yet, but I'll try to remove that \\nin the next version.\\n\\n> Similarly for a, it's\\n> part of the targetlist of the underlying scan so that the WHERE clause\\n> can be applied on it. But it's not needed if we are pushing down the\\n> query. If we eliminate the targetlist of the query, we could construct a\\n> remote query without having subquery in it, making it more readable.\\n\\nWill try to do so also.\\n\\nThanks for the comments!\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 19:55:03 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2016/09/08 19:55, Etsuro Fujita wrote:\\n> On 2016/09/07 13:21, Ashutosh Bapat wrote:\\n>> * with the patch:\\n>> postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\\n>> ft2.a;\\n>> QUERY PLAN\\n>>\\n>> -----------------------------------------------------------------------------------------------------------------------------\\n>>\\n>> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n>> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\\n>> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\\n>> b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\\n>> (3 rows)\\n>\\n>> The underlying scan on t2 requires ROW(a,b) for locking the row for\\n>> update/share. But clearly it's not required if the full query is being\\n>> pushed down.\\n\\n>> Is there a way we can detect that ROW(a,b) is useless\\n>> column (not used anywhere in the other parts of the query like\\n>> RETURNING, DELETE clause etc.) and eliminate it?\\n\\n> I don't have a clear solution for that yet, but I'll try to remove that\\n> in the next version.\\n\\n>> Similarly for a, it's\\n>> part of the targetlist of the underlying scan so that the WHERE clause\\n>> can be applied on it. But it's not needed if we are pushing down the\\n>> query. If we eliminate the targetlist of the query, we could construct a\\n>> remote query without having subquery in it, making it more readable.\\n\\n> Will try to do so also.\\n\\nI addressed this by improving the deparse logic so that a remote query \\nfor performing an UPDATE/DELETE on a join directly on the remote can be \\ncreated as proposed if possible. Attached is an updated version of the \\npatch, which is created on top of the patch set [1]. The patch is still \\nWIP (ie, needs more comments and regression tests, at least), but any \\ncomments would be gratefully appreciated.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n[1] \\nhttps://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b642-b0e65037c76b%40lab.ntt.co.jp\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 11 Nov 2016 20:30:39 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"Thanks Fujita-san for working on this. I've signed up to review this patch.\\n\\nYour latest patch doesn't not get apply cleanly apply on master branch.\\n\\npatching file contrib/postgres_fdw/deparse.c\\n6 out of 17 hunks FAILED -- saving rejects to file\\ncontrib/postgres_fdw/deparse.c.rej\\npatching file contrib/postgres_fdw/expected/postgres_fdw.out\\n2 out of 2 hunks FAILED -- saving rejects to file\\ncontrib/postgres_fdw/expected/postgres_fdw.out.rej\\npatching file contrib/postgres_fdw/postgres_fdw.c\\n2 out of 22 hunks FAILED -- saving rejects to file\\ncontrib/postgres_fdw/postgres_fdw.c.rej\\npatching file contrib/postgres_fdw/postgres_fdw.h\\n1 out of 3 hunks FAILED -- saving rejects to file\\ncontrib/postgres_fdw/postgres_fdw.h.rej\\n\\nPlease share the patch which get apply clean on master branch.\\n\\n\\n\\nOn Fri, Nov 11, 2016 at 5:00 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\\nwrote:\\n\\n> On 2016/09/08 19:55, Etsuro Fujita wrote:\\n>\\n>> On 2016/09/07 13:21, Ashutosh Bapat wrote:\\n>>\\n>>> * with the patch:\\n>>> postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\\n>>> ft2.a;\\n>>> QUERY PLAN\\n>>>\\n>>> ------------------------------------------------------------\\n>>> -----------------------------------------------------------------\\n>>>\\n>>> Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n>>> -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\\n>>> Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\\n>>> b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\\n>>> (3 rows)\\n>>>\\n>>\\n>> The underlying scan on t2 requires ROW(a,b) for locking the row for\\n>>> update/share. But clearly it's not required if the full query is being\\n>>> pushed down.\\n>>>\\n>>\\n> Is there a way we can detect that ROW(a,b) is useless\\n>>> column (not used anywhere in the other parts of the query like\\n>>> RETURNING, DELETE clause etc.) and eliminate it?\\n>>>\\n>>\\n> I don't have a clear solution for that yet, but I'll try to remove that\\n>> in the next version.\\n>>\\n>\\n> Similarly for a, it's\\n>>> part of the targetlist of the underlying scan so that the WHERE clause\\n>>> can be applied on it. But it's not needed if we are pushing down the\\n>>> query. If we eliminate the targetlist of the query, we could construct a\\n>>> remote query without having subquery in it, making it more readable.\\n>>>\\n>>\\n> Will try to do so also.\\n>>\\n>\\n> I addressed this by improving the deparse logic so that a remote query for\\n> performing an UPDATE/DELETE on a join directly on the remote can be created\\n> as proposed if possible. Attached is an updated version of the patch,\\n> which is created on top of the patch set [1]. The patch is still WIP (ie,\\n> needs more comments and regression tests, at least), but any comments would\\n> be gratefully appreciated.\\n>\\n> Best regards,\\n> Etsuro Fujita\\n>\\n> [1] https://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b64\\n> 2-b0e65037c76b%40lab.ntt.co.jp\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\n>\\n>\\n\\n\\n-- \\nRushabh Lathia\\n\\nThanks Fujita-san for working on this. I've signed up to review this patch.Your latest patch doesn't not get apply cleanly apply on master branch.patching file contrib/postgres_fdw/deparse.c6 out of 17 hunks FAILED -- saving rejects to file contrib/postgres_fdw/deparse.c.rejpatching file contrib/postgres_fdw/expected/postgres_fdw.out2 out of 2 hunks FAILED -- saving rejects to file contrib/postgres_fdw/expected/postgres_fdw.out.rejpatching file contrib/postgres_fdw/postgres_fdw.c2 out of 22 hunks FAILED -- saving rejects to file contrib/postgres_fdw/postgres_fdw.c.rejpatching file contrib/postgres_fdw/postgres_fdw.h1 out of 3 hunks FAILED -- saving rejects to file contrib/postgres_fdw/postgres_fdw.h.rejPlease share the patch which get apply clean on master branch.On Fri, Nov 11, 2016 at 5:00 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2016/09/08 19:55, Etsuro Fujita wrote:\\n\\nOn 2016/09/07 13:21, Ashutosh Bapat wrote:\\n\\n * with the patch:\\n postgres=# explain verbose delete from ft1 using ft2 where ft1.a =\\n ft2.a;\\n QUERY PLAN\\n\\n-----------------------------------------------------------------------------------------------------------------------------\\n\\n Delete on public.ft1 (cost=100.00..102.04 rows=1 width=38)\\n -> Foreign Delete (cost=100.00..102.04 rows=1 width=38)\\n Remote SQL: DELETE FROM public.t1 r1 USING (SELECT ROW(a,\\n b), a FROM public.t2) ss1(c1, c2) WHERE ((r1.a = ss1.c2))\\n (3 rows)\\n\\n\\n\\nThe underlying scan on t2 requires ROW(a,b) for locking the row for\\nupdate/share. But clearly it's not required if the full query is being\\npushed down.\\n\\n\\n\\nIs there a way we can detect that ROW(a,b) is useless\\ncolumn (not used anywhere in the other parts of the query like\\nRETURNING, DELETE clause etc.) and eliminate it?\\n\\n\\n\\nI don't have a clear solution for that yet, but I'll try to remove that\\nin the next version.\\n\\n\\n\\nSimilarly for a, it's\\npart of the targetlist of the underlying scan so that the WHERE clause\\ncan be applied on it. But it's not needed if we are pushing down the\\nquery. If we eliminate the targetlist of the query, we could construct a\\nremote query without having subquery in it, making it more readable.\\n\\n\\n\\nWill try to do so also.\\n\\n\\nI addressed this by improving the deparse logic so that a remote query for performing an UPDATE/DELETE on a join directly on the remote can be created as proposed if possible. Attached is an updated version of the patch, which is created on top of the patch set [1]. The patch is still WIP (ie, needs more comments and regression tests, at least), but any comments would be gratefully appreciated.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n[1] https://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b642-b0e65037c76b%40lab.ntt.co.jp\\n\\n--\\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n-- Rushabh Lathia\",\n \"msg_date\": \"Tue, 15 Nov 2016 15:34:22 +0530\",\n \"msg_from\": \"Rushabh Lathia <rushabh.lathia@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2016/11/15 19:04, Rushabh Lathia wrote:\\n> Thanks Fujita-san for working on this. I've signed up to review this patch.\\n\\nThank you for reviewing the patch!\\n\\n> Your latest patch doesn't not get apply cleanly apply on master branch.\\n\\nDid you apply the patch set in [1] \\n(postgres-fdw-subquery-support-v4.patch and \\npostgres-fdw-phv-pushdown-v4.patch in this order) before applying the \\nlatest patch?\\n\\nBest regards,\\nEtsuro Fujita\\n\\n[1] \\nhttps://www.postgresql.org/message-id/11eafd10-d3f8-ac8a-b642-b0e65037c76b%40lab.ntt.co.jp\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 16 Nov 2016 11:55:03 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On Wed, Nov 16, 2016 at 8:25 AM, Etsuro Fujita\\n<fujita.etsuro@lab.ntt.co.jp> wrote:\\n> On 2016/11/15 19:04, Rushabh Lathia wrote:\\n>>\\n>> Thanks Fujita-san for working on this. I've signed up to review this\\n>> patch.\\n>\\n>\\n> Thank you for reviewing the patch!\\n>\\n>> Your latest patch doesn't not get apply cleanly apply on master branch.\\n>\\n>\\n> Did you apply the patch set in [1] (postgres-fdw-subquery-support-v4.patch\\n> and postgres-fdw-phv-pushdown-v4.patch in this order) before applying the\\n> latest patch?\\n>\\n\\nI don't see any reason why DML/UPDATE pushdown should depend upon\\nsubquery deparsing or least PHV patch. Combined together they can help\\nin more cases, but without those patches, we will be able to push-down\\nmore stuff. Probably, we should just restrict push-down only for the\\ncases when above patches are not needed. That makes reviews easy. Once\\nthose patches get committed, we may add more functionality depending\\nupon the status of this patch. Does that make sense?\\n\\n-- \\nBest Wishes,\\nAshutosh Bapat\\nEnterpriseDB Corporation\\nThe Postgres Database Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 16 Nov 2016 09:40:10 +0530\",\n \"msg_from\": \"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2016/11/16 13:10, Ashutosh Bapat wrote:\\n> On Wed, Nov 16, 2016 at 8:25 AM, Etsuro Fujita\\n> <fujita.etsuro@lab.ntt.co.jp> wrote:\\n>> On 2016/11/15 19:04, Rushabh Lathia wrote:\\n>>> Your latest patch doesn't not get apply cleanly apply on master branch.\\n\\n>> Did you apply the patch set in [1] (postgres-fdw-subquery-support-v4.patch\\n>> and postgres-fdw-phv-pushdown-v4.patch in this order) before applying the\\n>> latest patch?\\n\\n> I don't see any reason why DML/UPDATE pushdown should depend upon\\n> subquery deparsing or least PHV patch. Combined together they can help\\n> in more cases, but without those patches, we will be able to push-down\\n> more stuff. Probably, we should just restrict push-down only for the\\n> cases when above patches are not needed. That makes reviews easy. Once\\n> those patches get committed, we may add more functionality depending\\n> upon the status of this patch. Does that make sense?\\n\\nOK, I'll extract from the patch the minimal part that wouldn't depend on \\nthe two patches.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 16 Nov 2016 16:38:44 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2016/11/16 16:38, Etsuro Fujita wrote:\\n> On 2016/11/16 13:10, Ashutosh Bapat wrote:\\n>> I don't see any reason why DML/UPDATE pushdown should depend upon\\n>> subquery deparsing or least PHV patch. Combined together they can help\\n>> in more cases, but without those patches, we will be able to push-down\\n>> more stuff. Probably, we should just restrict push-down only for the\\n>> cases when above patches are not needed. That makes reviews easy. Once\\n>> those patches get committed, we may add more functionality depending\\n>> upon the status of this patch. Does that make sense?\\n\\n> OK, I'll extract from the patch the minimal part that wouldn't depend on\\n> the two patches.\\n\\nHere is a patch for that. Todo items are: (1) add more comments and (2) \\nadd more regression tests. I'll do that in the next version.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 18 Nov 2016 12:26:06 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"I started reviewing the patch and here are few initial review points and\\nquestions for you.\\n\\n1)\\n-static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\\n+static void deparseExplicitTargetList(bool is_returning,\\n+ List *tlist,\\n+ List **retrieved_attrs,\\n deparse_expr_cxt *context);\\n\\nAny particular reason of inserting new argument as 1st argunment? In general\\nwe add new flags at the end or before the out param for the existing\\nfunction.\\n\\n2)\\n-static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\n- RelOptInfo *joinrel, bool use_alias, List\\n**params_list);\\n+static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\nRelOptInfo *foreignrel,\\n+ bool use_alias, Index target_rel, List\\n**params_list);\\n\\n\\nGoing beyond 80 character length\\n\\n3)\\n static void\\n-deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\\n+deparseExplicitTargetList(bool is_returning,\\n+ List *tlist,\\n+ List **retrieved_attrs,\\n deparse_expr_cxt *context)\\n\\nThis looks bit wired to me - as comment for the deparseExplicitTargetList()\\nfunction name and comments says different then what its trying to do when\\nis_returning flag is passed. Either function comment need to be change or\\nmay be separate function fo deparse returning list for join relation?\\n\\nIs it possible to teach deparseReturningList() to deparse the returning\\nlist for the joinrel?\\n\\n4)\\n\\n+ if (foreignrel->reloptkind == RELOPT_JOINREL)\\n+ {\\n+ List *rlist = NIL;\\n+\\n+ /* Create a RETURNING list */\\n+ rlist = make_explicit_returning_list(rtindex, rel,\\n+ returningList,\\n+ fdw_scan_tlist);\\n+\\n+ deparseExplicitReturningList(rlist, retrieved_attrs, &context);\\n+ }\\n+ else\\n+ deparseReturningList(buf, root, rtindex, rel, false,\\n+ returningList, retrieved_attrs);\\n\\nThe code will be more centralized if we add the logic of extracting\\nreturninglist\\nfor JOINREL inside deparseReturningList() only, isn't it?\\n\\n5) make_explicit_returning_list() pull the var list from the returningList\\nand\\nbuild the targetentry for the returning list and at the end rewrites the\\nfdw_scan_tlist.\\n\\nAFAIK, in case of DML - which is going to pushdown to the remote server\\nideally fdw_scan_tlist should be same as returning list, as final output\\nfor the query is query will be RETUNING list only. isn't that true?\\n\\nIf yes, then why can't we directly replace the fdw_scan_tlist with the\\nreturning\\nlist, rather then make_explicit_returning_list()?\\n\\nAlso I think rewriting the fdw_scan_tlist should happen into postgres_fdw.c\\n-\\nrather then deparse.c.\\n\\n6) Test coverage for the returning list is missing.\\n\\n\\n\\nOn Fri, Nov 18, 2016 at 8:56 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\\nwrote:\\n\\n> On 2016/11/16 16:38, Etsuro Fujita wrote:\\n>\\n>> On 2016/11/16 13:10, Ashutosh Bapat wrote:\\n>>\\n>>> I don't see any reason why DML/UPDATE pushdown should depend upon\\n>>> subquery deparsing or least PHV patch. Combined together they can help\\n>>> in more cases, but without those patches, we will be able to push-down\\n>>> more stuff. Probably, we should just restrict push-down only for the\\n>>> cases when above patches are not needed. That makes reviews easy. Once\\n>>> those patches get committed, we may add more functionality depending\\n>>> upon the status of this patch. Does that make sense?\\n>>>\\n>>\\n> OK, I'll extract from the patch the minimal part that wouldn't depend on\\n>> the two patches.\\n>>\\n>\\n> Here is a patch for that. Todo items are: (1) add more comments and (2)\\n> add more regression tests. I'll do that in the next version.\\n>\\n> Best regards,\\n> Etsuro Fujita\\n>\\n\\n\\n\\n-- \\nRushabh Lathia\\n\\nI started reviewing the patch and here are few initial review points and questions for you.1)-static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,+static void deparseExplicitTargetList(bool is_returning,+ List *tlist,+ List **retrieved_attrs, deparse_expr_cxt *context);Any particular reason of inserting new argument as 1st argunment? In generalwe add new flags at the end or before the out param for the existing function.2) -static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,- RelOptInfo *joinrel, bool use_alias, List **params_list);+static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root, RelOptInfo *foreignrel,+ bool use_alias, Index target_rel, List **params_list);Going beyond 80 character length3) static void-deparseExplicitTargetList(List *tlist, List **retrieved_attrs,+deparseExplicitTargetList(bool is_returning,+ List *tlist,+ List **retrieved_attrs, deparse_expr_cxt *context)This looks bit wired to me - as comment for the deparseExplicitTargetList()function name and comments says different then what its trying to do whenis_returning flag is passed. Either function comment need to be change ormay be separate function fo deparse returning list for join relation?Is it possible to teach deparseReturningList() to deparse the returninglist for the joinrel?4)+ if (foreignrel->reloptkind == RELOPT_JOINREL)+ {+ List *rlist = NIL;++ /* Create a RETURNING list */+ rlist = make_explicit_returning_list(rtindex, rel,+ returningList,+ fdw_scan_tlist);++ deparseExplicitReturningList(rlist, retrieved_attrs, &context);+ }+ else+ deparseReturningList(buf, root, rtindex, rel, false,+ returningList, retrieved_attrs);The code will be more centralized if we add the logic of extracting returninglistfor JOINREL inside deparseReturningList() only, isn't it?5) make_explicit_returning_list() pull the var list from the returningList andbuild the targetentry for the returning list and at the end rewrites thefdw_scan_tlist. AFAIK, in case of DML - which is going to pushdown to the remote server ideally fdw_scan_tlist should be same as returning list, as final outputfor the query is query will be RETUNING list only. isn't that true?If yes, then why can't we directly replace the fdw_scan_tlist with the returninglist, rather then make_explicit_returning_list()?Also I think rewriting the fdw_scan_tlist should happen into postgres_fdw.c -rather then deparse.c.6) Test coverage for the returning list is missing.On Fri, Nov 18, 2016 at 8:56 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2016/11/16 16:38, Etsuro Fujita wrote:\\n\\nOn 2016/11/16 13:10, Ashutosh Bapat wrote:\\n\\nI don't see any reason why DML/UPDATE pushdown should depend upon\\nsubquery deparsing or least PHV patch. Combined together they can help\\nin more cases, but without those patches, we will be able to push-down\\nmore stuff. Probably, we should just restrict push-down only for the\\ncases when above patches are not needed. That makes reviews easy. Once\\nthose patches get committed, we may add more functionality depending\\nupon the status of this patch. Does that make sense?\\n\\n\\n\\nOK, I'll extract from the patch the minimal part that wouldn't depend on\\nthe two patches.\\n\\n\\nHere is a patch for that. Todo items are: (1) add more comments and (2) add more regression tests. I'll do that in the next version.\\n\\nBest regards,\\nEtsuro Fujita\\n-- Rushabh Lathia\",\n \"msg_date\": \"Tue, 22 Nov 2016 15:35:42 +0530\",\n \"msg_from\": \"Rushabh Lathia <rushabh.lathia@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"Hi Rushabh,\\n\\nOn 2016/11/22 19:05, Rushabh Lathia wrote:\\n> I started reviewing the patch and here are few initial review points and\\n> questions for you.\\n\\nThanks for the review!\\n\\n> 1)\\n> -static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\\n> +static void deparseExplicitTargetList(bool is_returning,\\n> + List *tlist,\\n> + List **retrieved_attrs,\\n> deparse_expr_cxt *context);\\n>\\n> Any particular reason of inserting new argument as 1st argunment? In general\\n> we add new flags at the end or before the out param for the existing\\n> function.\\n\\nNo, I don't. I think the *context should be the last argument as in \\nother functions in deparse.c. How about inserting that before the out \\nparam **retrieved_attrs, like this?\\n\\nstatic void\\ndeparseExplicitTargetList(List *tlist,\\n bool is_returning,\\n List **retrieved_attrs,\\n deparse_expr_cxt *context);\\n\\n> 2)\\n> -static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\n> - RelOptInfo *joinrel, bool use_alias, List\\n> **params_list);\\n> +static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\n> RelOptInfo *foreignrel,\\n> + bool use_alias, Index target_rel, List\\n> **params_list);\\n\\n> Going beyond 80 character length\\n\\nWill fix.\\n\\n> 3)\\n> static void\\n> -deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\\n> +deparseExplicitTargetList(bool is_returning,\\n> + List *tlist,\\n> + List **retrieved_attrs,\\n> deparse_expr_cxt *context)\\n>\\n> This looks bit wired to me - as comment for the deparseExplicitTargetList()\\n> function name and comments says different then what its trying to do when\\n> is_returning flag is passed. Either function comment need to be change or\\n> may be separate function fo deparse returning list for join relation?\\n>\\n> Is it possible to teach deparseReturningList() to deparse the returning\\n> list for the joinrel?\\n\\nI don't think it's possible to do that because deparseReturningList uses \\ndeparseTargetList internally, which only allows us to emit a target list \\nfor a baserel. For example, deparseReturningList can't handle a \\nreturning list that contains join outputs like this:\\n\\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a \\nreturning ft1.*, ft2.*;\\n QUERY PLAN\\n------------------------------------------------------------------------------------------------------------------------\\n Delete on public.ft1 (cost=100.00..102.06 rows=1 width=46)\\n Output: ft1.a, ft1.b, ft2.a, ft2.b\\n -> Foreign Delete (cost=100.00..102.06 rows=1 width=46)\\n Remote SQL: DELETE FROM public.t1 r1 USING public.t2 r2 WHERE \\n((r1.a = r2.a)) RETURNING r1.a, r1.b, r2.a, r2.b\\n(4 rows)\\n\\nI'd like to change the comment for deparseExplicitTargetList.\\n\\n> 4)\\n>\\n> + if (foreignrel->reloptkind == RELOPT_JOINREL)\\n> + {\\n> + List *rlist = NIL;\\n> +\\n> + /* Create a RETURNING list */\\n> + rlist = make_explicit_returning_list(rtindex, rel,\\n> + returningList,\\n> + fdw_scan_tlist);\\n> +\\n> + deparseExplicitReturningList(rlist, retrieved_attrs, &context);\\n> + }\\n> + else\\n> + deparseReturningList(buf, root, rtindex, rel, false,\\n> + returningList, retrieved_attrs);\\n>\\n> The code will be more centralized if we add the logic of extracting\\n> returninglist\\n> for JOINREL inside deparseReturningList() only, isn't it?\\n\\nYou are right. Will do.\\n\\n> 5) make_explicit_returning_list() pull the var list from the\\n> returningList and\\n> build the targetentry for the returning list and at the end rewrites the\\n> fdw_scan_tlist.\\n>\\n> AFAIK, in case of DML - which is going to pushdown to the remote server\\n> ideally fdw_scan_tlist should be same as returning list, as final output\\n> for the query is query will be RETUNING list only. isn't that true?\\n\\nThat would be true. But the fdw_scan_tlist passed from the core would \\ncontain junk columns inserted by the rewriter and planner work, such as \\nCTID for the target table and whole-row Vars for other tables specified \\nin the FROM clause of an UPDATE or the USING clause of a DELETE. So, I \\ncreated the patch so that the pushed-down UPDATE/DELETE retrieves only \\nthe data needed for the RETURNING calculation from the remote server, \\nnot the whole fdw_scan_tlist data.\\n\\n> If yes, then why can't we directly replace the fdw_scan_tlist with the\\n> returning\\n> list, rather then make_explicit_returning_list()?\\n\\nI think we could do that if we modified the core (maybe the executor \\npart). I'm not sure that's a good idea, though.\\n\\n> Also I think rewriting the fdw_scan_tlist should happen into\\n> postgres_fdw.c -\\n> rather then deparse.c.\\n\\nWill try.\\n\\n> 6) Test coverage for the returning list is missing.\\n\\nWill add.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 22 Nov 2016 21:54:55 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On Tue, Nov 22, 2016 at 6:24 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\\nwrote:\\n\\n> Hi Rushabh,\\n>\\n> On 2016/11/22 19:05, Rushabh Lathia wrote:\\n>\\n>> I started reviewing the patch and here are few initial review points and\\n>> questions for you.\\n>>\\n>\\n> Thanks for the review!\\n>\\n> 1)\\n>> -static void deparseExplicitTargetList(List *tlist, List\\n>> **retrieved_attrs,\\n>> +static void deparseExplicitTargetList(bool is_returning,\\n>> + List *tlist,\\n>> + List **retrieved_attrs,\\n>> deparse_expr_cxt *context);\\n>>\\n>> Any particular reason of inserting new argument as 1st argunment? In\\n>> general\\n>> we add new flags at the end or before the out param for the existing\\n>> function.\\n>>\\n>\\n> No, I don't. I think the *context should be the last argument as in other\\n> functions in deparse.c. How about inserting that before the out param\\n> **retrieved_attrs, like this?\\n>\\n> static void\\n> deparseExplicitTargetList(List *tlist,\\n> bool is_returning,\\n> List **retrieved_attrs,\\n> deparse_expr_cxt *context);\\n>\\n>\\nYes, adding it before retrieved_attrs would be good.\\n\\n\\n> 2)\\n>> -static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\n>> - RelOptInfo *joinrel, bool use_alias, List\\n>> **params_list);\\n>> +static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\n>> RelOptInfo *foreignrel,\\n>> + bool use_alias, Index target_rel, List\\n>> **params_list);\\n>>\\n>\\n> Going beyond 80 character length\\n>>\\n>\\n> Will fix.\\n>\\n> 3)\\n>> static void\\n>> -deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\\n>> +deparseExplicitTargetList(bool is_returning,\\n>> + List *tlist,\\n>> + List **retrieved_attrs,\\n>> deparse_expr_cxt *context)\\n>>\\n>> This looks bit wired to me - as comment for the\\n>> deparseExplicitTargetList()\\n>> function name and comments says different then what its trying to do when\\n>> is_returning flag is passed. Either function comment need to be change or\\n>> may be separate function fo deparse returning list for join relation?\\n>>\\n>> Is it possible to teach deparseReturningList() to deparse the returning\\n>> list for the joinrel?\\n>>\\n>\\n> I don't think it's possible to do that because deparseReturningList uses\\n> deparseTargetList internally, which only allows us to emit a target list\\n> for a baserel. For example, deparseReturningList can't handle a returning\\n> list that contains join outputs like this:\\n>\\n> postgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a\\n> returning ft1.*, ft2.*;\\n> QUERY PLAN\\n> ------------------------------------------------------------\\n> ------------------------------------------------------------\\n> Delete on public.ft1 (cost=100.00..102.06 rows=1 width=46)\\n> Output: ft1.a, ft1.b, ft2.a, ft2.b\\n> -> Foreign Delete (cost=100.00..102.06 rows=1 width=46)\\n> Remote SQL: DELETE FROM public.t1 r1 USING public.t2 r2 WHERE\\n> ((r1.a = r2.a)) RETURNING r1.a, r1.b, r2.a, r2.b\\n> (4 rows)\\n>\\n> I'd like to change the comment for deparseExplicitTargetList.\\n>\\n> 4)\\n>>\\n>> + if (foreignrel->reloptkind == RELOPT_JOINREL)\\n>> + {\\n>> + List *rlist = NIL;\\n>> +\\n>> + /* Create a RETURNING list */\\n>> + rlist = make_explicit_returning_list(rtindex, rel,\\n>> + returningList,\\n>> + fdw_scan_tlist);\\n>> +\\n>> + deparseExplicitReturningList(rlist, retrieved_attrs, &context);\\n>> + }\\n>> + else\\n>> + deparseReturningList(buf, root, rtindex, rel, false,\\n>> + returningList, retrieved_attrs);\\n>>\\n>> The code will be more centralized if we add the logic of extracting\\n>> returninglist\\n>> for JOINREL inside deparseReturningList() only, isn't it?\\n>>\\n>\\n> You are right. Will do.\\n>\\n> 5) make_explicit_returning_list() pull the var list from the\\n>> returningList and\\n>> build the targetentry for the returning list and at the end rewrites the\\n>> fdw_scan_tlist.\\n>>\\n>> AFAIK, in case of DML - which is going to pushdown to the remote server\\n>> ideally fdw_scan_tlist should be same as returning list, as final output\\n>> for the query is query will be RETUNING list only. isn't that true?\\n>>\\n>\\n> That would be true. But the fdw_scan_tlist passed from the core would\\n> contain junk columns inserted by the rewriter and planner work, such as\\n> CTID for the target table and whole-row Vars for other tables specified in\\n> the FROM clause of an UPDATE or the USING clause of a DELETE. So, I\\n> created the patch so that the pushed-down UPDATE/DELETE retrieves only the\\n> data needed for the RETURNING calculation from the remote server, not the\\n> whole fdw_scan_tlist data.\\n\\n\\nYes, I noticed that fdw_scan_tlist have CTID for the target table and\\nwhole-raw vars for\\nother tables specified in the FROM clause of the DML. But I was thinking\\nisn't it possible\\nto create new fdw_scan_tlist once we found that DML is direct pushable to\\nforeign server?\\nI tried quickly doing that - but later its was throwing \\\"variable not found\\nin subplan target list\\\"\\nfrom set_foreignscan_references().\\n\\n\\n>\\n> If yes, then why can't we directly replace the fdw_scan_tlist with the\\n>> returning\\n>> list, rather then make_explicit_returning_list()?\\n>>\\n>\\n> I think we could do that if we modified the core (maybe the executor\\n> part). I'm not sure that's a good idea, though.\\n\\n\\nYes modifying core is not good idea. But just want to understand why you\\nthink that this need need to modify core?\\n\\n\\n>\\n>\\n> Also I think rewriting the fdw_scan_tlist should happen into\\n>> postgres_fdw.c -\\n>> rather then deparse.c.\\n>>\\n>\\n> Will try.\\n\\n\\nThat would be good.\\n\\n\\n>\\n>\\n> 6) Test coverage for the returning list is missing.\\n>>\\n>\\n> Will add.\\n>\\n>\\nThanks.\\n\\n\\n> Best regards,\\n> Etsuro Fujita\\n>\\n>\\n>\\n\\n\\n-- \\nRushabh Lathia\\n\\nOn Tue, Nov 22, 2016 at 6:24 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:Hi Rushabh,\\n\\nOn 2016/11/22 19:05, Rushabh Lathia wrote:\\n\\nI started reviewing the patch and here are few initial review points and\\nquestions for you.\\n\\n\\nThanks for the review!\\n\\n\\n1)\\n-static void deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\\n+static void deparseExplicitTargetList(bool is_returning,\\n+ List *tlist,\\n+ List **retrieved_attrs,\\n deparse_expr_cxt *context);\\n\\nAny particular reason of inserting new argument as 1st argunment? In general\\nwe add new flags at the end or before the out param for the existing\\nfunction.\\n\\n\\nNo, I don't. I think the *context should be the last argument as in other functions in deparse.c. How about inserting that before the out param **retrieved_attrs, like this?\\n\\nstatic void\\ndeparseExplicitTargetList(List *tlist,\\n bool is_returning,\\n List **retrieved_attrs,\\n deparse_expr_cxt *context);\\nYes, adding it before retrieved_attrs would be good. \\n\\n2)\\n-static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\n- RelOptInfo *joinrel, bool use_alias, List\\n**params_list);\\n+static void deparseFromExprForRel(StringInfo buf, PlannerInfo *root,\\nRelOptInfo *foreignrel,\\n+ bool use_alias, Index target_rel, List\\n**params_list);\\n\\n\\n\\nGoing beyond 80 character length\\n\\n\\nWill fix.\\n\\n\\n3)\\n static void\\n-deparseExplicitTargetList(List *tlist, List **retrieved_attrs,\\n+deparseExplicitTargetList(bool is_returning,\\n+ List *tlist,\\n+ List **retrieved_attrs,\\n deparse_expr_cxt *context)\\n\\nThis looks bit wired to me - as comment for the deparseExplicitTargetList()\\nfunction name and comments says different then what its trying to do when\\nis_returning flag is passed. Either function comment need to be change or\\nmay be separate function fo deparse returning list for join relation?\\n\\nIs it possible to teach deparseReturningList() to deparse the returning\\nlist for the joinrel?\\n\\n\\nI don't think it's possible to do that because deparseReturningList uses deparseTargetList internally, which only allows us to emit a target list for a baserel. For example, deparseReturningList can't handle a returning list that contains join outputs like this:\\n\\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a returning ft1.*, ft2.*;\\n QUERY PLAN\\n------------------------------------------------------------------------------------------------------------------------\\n Delete on public.ft1 (cost=100.00..102.06 rows=1 width=46)\\n Output: ft1.a, ft1.b, ft2.a, ft2.b\\n -> Foreign Delete (cost=100.00..102.06 rows=1 width=46)\\n Remote SQL: DELETE FROM public.t1 r1 USING public.t2 r2 WHERE ((r1.a = r2.a)) RETURNING r1.a, r1.b, r2.a, r2.b\\n(4 rows)\\n\\nI'd like to change the comment for deparseExplicitTargetList.\\n\\n\\n4)\\n\\n+ if (foreignrel->reloptkind == RELOPT_JOINREL)\\n+ {\\n+ List *rlist = NIL;\\n+\\n+ /* Create a RETURNING list */\\n+ rlist = make_explicit_returning_list(rtindex, rel,\\n+ returningList,\\n+ fdw_scan_tlist);\\n+\\n+ deparseExplicitReturningList(rlist, retrieved_attrs, &context);\\n+ }\\n+ else\\n+ deparseReturningList(buf, root, rtindex, rel, false,\\n+ returningList, retrieved_attrs);\\n\\nThe code will be more centralized if we add the logic of extracting\\nreturninglist\\nfor JOINREL inside deparseReturningList() only, isn't it?\\n\\n\\nYou are right. Will do.\\n\\n\\n5) make_explicit_returning_list() pull the var list from the\\nreturningList and\\nbuild the targetentry for the returning list and at the end rewrites the\\nfdw_scan_tlist.\\n\\nAFAIK, in case of DML - which is going to pushdown to the remote server\\nideally fdw_scan_tlist should be same as returning list, as final output\\nfor the query is query will be RETUNING list only. isn't that true?\\n\\n\\nThat would be true. But the fdw_scan_tlist passed from the core would contain junk columns inserted by the rewriter and planner work, such as CTID for the target table and whole-row Vars for other tables specified in the FROM clause of an UPDATE or the USING clause of a DELETE. So, I created the patch so that the pushed-down UPDATE/DELETE retrieves only the data needed for the RETURNING calculation from the remote server, not the whole fdw_scan_tlist data.Yes, I noticed that fdw_scan_tlist have CTID for the target table and whole-raw vars forother tables specified in the FROM clause of the DML. But I was thinking isn't it possibleto create new fdw_scan_tlist once we found that DML is direct pushable to foreign server?I tried quickly doing that - but later its was throwing \\\"variable not found in subplan target list\\\"from set_foreignscan_references(). \\n\\n\\nIf yes, then why can't we directly replace the fdw_scan_tlist with the\\nreturning\\nlist, rather then make_explicit_returning_list()?\\n\\n\\nI think we could do that if we modified the core (maybe the executor part). I'm not sure that's a good idea, though.Yes modifying core is not good idea. But just want to understand why youthink that this need need to modify core? \\n\\n\\nAlso I think rewriting the fdw_scan_tlist should happen into\\npostgres_fdw.c -\\nrather then deparse.c.\\n\\n\\nWill try.That would be good. \\n\\n\\n6) Test coverage for the returning list is missing.\\n\\n\\nWill add.\\nThanks. \\nBest regards,\\nEtsuro Fujita\\n\\n\\n-- Rushabh Lathia\",\n \"msg_date\": \"Wed, 23 Nov 2016 16:58:19 +0530\",\n \"msg_from\": \"Rushabh Lathia <rushabh.lathia@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2016/11/23 20:28, Rushabh Lathia wrote:\\n> On Tue, Nov 22, 2016 at 6:24 PM, Etsuro Fujita\\n> <fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\\n\\n> 1)\\n> -static void deparseExplicitTargetList(List *tlist, List\\n> **retrieved_attrs,\\n> +static void deparseExplicitTargetList(bool is_returning,\\n> + List *tlist,\\n> + List **retrieved_attrs,\\n> deparse_expr_cxt *context);\\n>\\n> Any particular reason of inserting new argument as 1st\\n> argunment? In general\\n> we add new flags at the end or before the out param for the existing\\n> function.\\n\\n> No, I don't. I think the *context should be the last argument as in\\n> other functions in deparse.c. How about inserting that before the\\n> out param **retrieved_attrs, like this?\\n>\\n> static void\\n> deparseExplicitTargetList(List *tlist,\\n> bool is_returning,\\n> List **retrieved_attrs,\\n> deparse_expr_cxt *context);\\n\\n> Yes, adding it before retrieved_attrs would be good.\\n\\nOK, will do.\\n\\n> 5) make_explicit_returning_list() pull the var list from the\\n> returningList and\\n> build the targetentry for the returning list and at the end\\n> rewrites the\\n> fdw_scan_tlist.\\n>\\n> AFAIK, in case of DML - which is going to pushdown to the remote\\n> server\\n> ideally fdw_scan_tlist should be same as returning list, as\\n> final output\\n> for the query is query will be RETUNING list only. isn't that true?\\n\\n> That would be true. But the fdw_scan_tlist passed from the core\\n> would contain junk columns inserted by the rewriter and planner\\n> work, such as CTID for the target table and whole-row Vars for other\\n> tables specified in the FROM clause of an UPDATE or the USING clause\\n> of a DELETE. So, I created the patch so that the pushed-down\\n> UPDATE/DELETE retrieves only the data needed for the RETURNING\\n> calculation from the remote server, not the whole fdw_scan_tlist data.\\n\\n> Yes, I noticed that fdw_scan_tlist have CTID for the target table and\\n> whole-raw vars for\\n> other tables specified in the FROM clause of the DML. But I was thinking\\n> isn't it possible\\n> to create new fdw_scan_tlist once we found that DML is direct pushable\\n> to foreign server?\\n> I tried quickly doing that - but later its was throwing \\\"variable not\\n> found in subplan target list\\\"\\n> from set_foreignscan_references().\\n\\n> If yes, then why can't we directly replace the fdw_scan_tlist\\n> with the\\n> returning\\n> list, rather then make_explicit_returning_list()?\\n\\n> I think we could do that if we modified the core (maybe the executor\\n> part). I'm not sure that's a good idea, though.\\n\\n> Yes modifying core is not good idea. But just want to understand why you\\n> think that this need need to modify core?\\n\\nSorry, I don't remember that. Will check.\\n\\nI'd like to move this to the next CF.\\n\\nThank you for the comments!\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 30 Nov 2016 17:29:47 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2016/11/30 17:29, Etsuro Fujita wrote:\\n> On 2016/11/23 20:28, Rushabh Lathia wrote:\\n\\nI wrote:\\n>> How about inserting that before the\\n>> out param **retrieved_attrs, like this?\\n>>\\n>> static void\\n>> deparseExplicitTargetList(List *tlist,\\n>> bool is_returning,\\n>> List **retrieved_attrs,\\n>> deparse_expr_cxt *context);\\n\\n>> Yes, adding it before retrieved_attrs would be good.\\n\\n> OK, will do.\\n\\nDone.\\n\\nYou wrote:\\n>> 5) make_explicit_returning_list() pull the var list from the\\n>> returningList and\\n>> build the targetentry for the returning list and at the end\\n>> rewrites the\\n>> fdw_scan_tlist.\\n>>\\n>> AFAIK, in case of DML - which is going to pushdown to the remote\\n>> server\\n>> ideally fdw_scan_tlist should be same as returning list, as\\n>> final output\\n>> for the query is query will be RETUNING list only. isn't that\\n>> true?\\n\\nI wrote:\\n>> That would be true. But the fdw_scan_tlist passed from the core\\n>> would contain junk columns inserted by the rewriter and planner\\n>> work, such as CTID for the target table and whole-row Vars for other\\n>> tables specified in the FROM clause of an UPDATE or the USING clause\\n>> of a DELETE. So, I created the patch so that the pushed-down\\n>> UPDATE/DELETE retrieves only the data needed for the RETURNING\\n>> calculation from the remote server, not the whole fdw_scan_tlist\\n>> data.\\n\\n>> Yes, I noticed that fdw_scan_tlist have CTID for the target table and\\n>> whole-raw vars for\\n>> other tables specified in the FROM clause of the DML. But I was thinking\\n>> isn't it possible\\n>> to create new fdw_scan_tlist once we found that DML is direct pushable\\n>> to foreign server?\\n>> I tried quickly doing that - but later its was throwing \\\"variable not\\n>> found in subplan target list\\\"\\n>> from set_foreignscan_references().\\n\\nWe could probably avoid that error by replacing the targetlist of the \\nsubplan with fdw_scan_tlist, but that wouldn't be enough ...\\n\\nYou wrote:\\n>> If yes, then why can't we directly replace the fdw_scan_tlist\\n>> with the\\n>> returning\\n>> list, rather then make_explicit_returning_list()?\\n\\nI wrote:\\n>> I think we could do that if we modified the core (maybe the executor\\n>> part). I'm not sure that's a good idea, though.\\n\\n>> Yes modifying core is not good idea. But just want to understand why you\\n>> think that this need need to modify core?\\n\\n> Sorry, I don't remember that. Will check.\\n\\nThe reason why I think so is that the ModifyTable node on top of the \\nForeignScan node requires that the targetlist of the ForeignScan has (1) \\njunk whole-row Vars for secondary relations in UPDATE/DELETE and (2) all \\nattributes of the target relation to produce the new tuple for UPDATE. \\n(So, it wouldn't be enough to just replace the ForeignScan's targetlist \\nwith fdw_scan_tlist!) For #1, see this (and the following code) in \\nExecInitModifyTable:\\n\\n /*\\n * If we have any secondary relations in an UPDATE or DELETE, they \\nneed to\\n * be treated like non-locked relations in SELECT FOR UPDATE, ie, the\\n * EvalPlanQual mechanism needs to be told about them. Locate the\\n * relevant ExecRowMarks.\\n */\\n\\nAnd for #2, see this (and the following code, especially where calling \\nExecCheckPlanOutput) in the same function:\\n\\n * This section of code is also a convenient place to verify that the\\n * output of an INSERT or UPDATE matches the target table(s).\\n\\nWhat you proposed would be a good idea because the FDW could calculate \\nthe user-query RETURNING list more efficiently in some cases, but I'd \\nlike to leave that for future work.\\n\\nAttached is the new version of the patch. I also addressed other \\ncomments from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c, \\nadded/revised comments, and added regression tests for the case where a \\npushed down UPDATE/DELETE on a join has RETURNING.\\n\\nMy apologies for having been late to work on this.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 25 Jan 2017 19:20:22 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On Wed, Jan 25, 2017 at 7:20 PM, Etsuro Fujita\\n<fujita.etsuro@lab.ntt.co.jp> wrote:\\n> Attached is the new version of the patch. I also addressed other comments\\n> from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c,\\n> added/revised comments, and added regression tests for the case where a\\n> pushed down UPDATE/DELETE on a join has RETURNING.\\n>\\n> My apologies for having been late to work on this.\\n\\nMoved to CF 2017-03.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 1 Feb 2017 15:20:54 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"Sorry for delay in the review.\\n\\nI started reviewing the patch again. Patch applied cleanly on latest source\\nas well as regression pass through with the patch. I also performed\\nfew manual testing and haven't found any regression. Patch look\\nmuch cleaner the earlier version, and don't have any major concern as\\nsuch. Here are few comments:\\n\\n1)\\n\\n@@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\\n PGresult *result; /* result for query */\\n int num_tuples; /* # of result tuples */\\n int next_tuple; /* index of next one to return */\\n+ Relation resultRel; /* relcache entry for the target table */\\n\\n\\nWhy we need resultRel? Can't we directly use dmstate->rel ?\\n\\n\\n2) In the patch somewhere scanrelid condition being used as\\nfscan->scan.scanrelid == 0 where as some place its been used as\\nfsplan->scan.scanrelid > 0. Infact in the same function its been used\\ndifferently example postgresBeginDirectModify. Can make this consistent.\\n\\n3)\\n\\n+ * If UPDATE/DELETE on a join, create a RETURINING list used in the\\nremote\\n+ * query.\\n+ */\\n+ if (fscan->scan.scanrelid == 0)\\n+ returningList = make_explicit_returning_list(resultRelation, rel,\\n+ returningList);\\n+\\n\\nAbove block can be moved inside the if (plan->returningLists) condition\\nabove\\nthe block. Like this:\\n\\n /*\\n * Extract the relevant RETURNING list if any.\\n */\\n if (plan->returningLists)\\n {\\n returningList = (List *) list_nth(plan->returningLists,\\nsubplan_index);\\n\\n /*\\n * If UPDATE/DELETE on a join, create a RETURINING list used in the\\nremote\\n * query.\\n */\\n if (fscan->scan.scanrelid == 0)\\n returningList = make_explicit_returning_list(resultRelation,\\n rel,\\n returningList);\\n }\\n\\n\\nI am still doing few more testing with the patch, if I will found anything\\napart from\\nthis I will raise that into another mail.\\n\\nThanks,\\n\\n\\n\\nOn Wed, Feb 1, 2017 at 11:50 AM, Michael Paquier <michael.paquier@gmail.com>\\nwrote:\\n\\n> On Wed, Jan 25, 2017 at 7:20 PM, Etsuro Fujita\\n> <fujita.etsuro@lab.ntt.co.jp> wrote:\\n> > Attached is the new version of the patch. I also addressed other\\n> comments\\n> > from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c,\\n> > added/revised comments, and added regression tests for the case where a\\n> > pushed down UPDATE/DELETE on a join has RETURNING.\\n> >\\n> > My apologies for having been late to work on this.\\n>\\n> Moved to CF 2017-03.\\n> --\\n> Michael\\n>\\n\\n\\n\\n-- \\nRushabh Lathia\\n\\nSorry for delay in the review.I started reviewing the patch again. Patch applied cleanly on latest sourceas well as regression pass through with the patch. I also performedfew manual testing and haven't found any regression. Patch lookmuch cleaner the earlier version, and don't have any major concern as such. Here are few comments:1) @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState PGresult *result; /* result for query */ int num_tuples; /* # of result tuples */ int next_tuple; /* index of next one to return */+ Relation resultRel; /* relcache entry for the target table */Why we need resultRel? Can't we directly use dmstate->rel ?2) In the patch somewhere scanrelid condition being used asfscan->scan.scanrelid == 0 where as some place its been used asfsplan->scan.scanrelid > 0. Infact in the same function its been useddifferently example postgresBeginDirectModify. Can make this consistent.3)+ * If UPDATE/DELETE on a join, create a RETURINING list used in the remote+ * query.+ */+ if (fscan->scan.scanrelid == 0)+ returningList = make_explicit_returning_list(resultRelation, rel,+ returningList);+Above block can be moved inside the if (plan->returningLists) condition abovethe block. Like this: /* * Extract the relevant RETURNING list if any. */ if (plan->returningLists) { returningList = (List *) list_nth(plan->returningLists, subplan_index); /* * If UPDATE/DELETE on a join, create a RETURINING list used in the remote * query. */ if (fscan->scan.scanrelid == 0) returningList = make_explicit_returning_list(resultRelation, rel, returningList); }I am still doing few more testing with the patch, if I will found anything apart fromthis I will raise that into another mail.Thanks,On Wed, Feb 1, 2017 at 11:50 AM, Michael Paquier <michael.paquier@gmail.com> wrote:On Wed, Jan 25, 2017 at 7:20 PM, Etsuro Fujita\\n<fujita.etsuro@lab.ntt.co.jp> wrote:\\n> Attached is the new version of the patch. I also addressed other comments\\n> from you: moved rewriting the fdw_scan_tlist to postgres_fdw.c,\\n> added/revised comments, and added regression tests for the case where a\\n> pushed down UPDATE/DELETE on a join has RETURNING.\\n>\\n> My apologies for having been late to work on this.\\n\\nMoved to CF 2017-03.\\n--\\nMichael\\n-- Rushabh Lathia\",\n \"msg_date\": \"Mon, 13 Feb 2017 14:54:24 +0530\",\n \"msg_from\": \"Rushabh Lathia <rushabh.lathia@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2017/02/13 18:24, Rushabh Lathia wrote:\\n> I started reviewing the patch again. Patch applied cleanly on latest source\\n> as well as regression pass through with the patch. I also performed\\n> few manual testing and haven't found any regression. Patch look\\n> much cleaner the earlier version, and don't have any major concern as\\n> such.\\n\\nThanks for the review!\\n\\n> Here are few comments:\\n>\\n> 1)\\n>\\n> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\\n> PGresult *result; /* result for query */\\n> int num_tuples; /* # of result tuples */\\n> int next_tuple; /* index of next one to return */\\n> + Relation resultRel; /* relcache entry for the target table */\\n\\n> Why we need resultRel? Can't we directly use dmstate->rel ?\\n\\nThe reason why we need that is because in get_returning_data, we pass \\ndmstate->rel to make_tuple_from_result_row, which requires that \\ndmstate->rel be NULL when the scan tuple is described by fdw_scan_tlist. \\n So in that case we set dmstate->rel to NULL and have \\ndmstate->resultRel that is the relcache entry for the target relation in \\npostgresBeginDirectModify.\\n\\n> 2) In the patch somewhere scanrelid condition being used as\\n> fscan->scan.scanrelid == 0 where as some place its been used as\\n> fsplan->scan.scanrelid > 0. Infact in the same function its been used\\n> differently example postgresBeginDirectModify. Can make this consistent.\\n\\nOk, done.\\n\\n> 3)\\n>\\n> + * If UPDATE/DELETE on a join, create a RETURINING list used in the\\n> remote\\n> + * query.\\n> + */\\n> + if (fscan->scan.scanrelid == 0)\\n> + returningList = make_explicit_returning_list(resultRelation, rel,\\n> + returningList);\\n> +\\n>\\n> Above block can be moved inside the if (plan->returningLists) condition\\n> above\\n> the block. Like this:\\n>\\n> /*\\n> * Extract the relevant RETURNING list if any.\\n> */\\n> if (plan->returningLists)\\n> {\\n> returningList = (List *) list_nth(plan->returningLists,\\n> subplan_index);\\n>\\n> /*\\n> * If UPDATE/DELETE on a join, create a RETURINING list used in\\n> the remote\\n> * query.\\n> */\\n> if (fscan->scan.scanrelid == 0)\\n> returningList = make_explicit_returning_list(resultRelation,\\n> rel,\\n> returningList);\\n> }\\n\\nDone that way.\\n\\nAnother thing I noticed is duplicate work in apply_returning_filter; it \\ninitializes tableoid of an updated/deleted tuple if needed, but the core \\nwill do that (see ExecProcessReturning). I removed that work from \\napply_returning_filter.\\n\\n> I am still doing few more testing with the patch, if I will found\\n> anything apart from\\n> this I will raise that into another mail.\\n\\nThanks again!\\n\\nAttached is an updated version of the patch.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 20 Feb 2017 17:11:15 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\\nwrote:\\n\\n> On 2017/02/13 18:24, Rushabh Lathia wrote:\\n>\\n>> I started reviewing the patch again. Patch applied cleanly on latest\\n>> source\\n>> as well as regression pass through with the patch. I also performed\\n>> few manual testing and haven't found any regression. Patch look\\n>> much cleaner the earlier version, and don't have any major concern as\\n>> such.\\n>>\\n>\\n> Thanks for the review!\\n>\\n> Here are few comments:\\n>>\\n>> 1)\\n>>\\n>> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\\n>> PGresult *result; /* result for query */\\n>> int num_tuples; /* # of result tuples */\\n>> int next_tuple; /* index of next one to return */\\n>> + Relation resultRel; /* relcache entry for the target table\\n>> */\\n>>\\n>\\n> Why we need resultRel? Can't we directly use dmstate->rel ?\\n>>\\n>\\n> The reason why we need that is because in get_returning_data, we pass\\n> dmstate->rel to make_tuple_from_result_row, which requires that\\n> dmstate->rel be NULL when the scan tuple is described by fdw_scan_tlist.\\n> So in that case we set dmstate->rel to NULL and have dmstate->resultRel\\n> that is the relcache entry for the target relation in\\n> postgresBeginDirectModify.\\n>\\n>\\nThanks for the explanation. We might do something here by using\\nfdw_scan_tlist or changing the assumption of make_tuple_from_result_row(),\\nand that way we can avoid two similar variable pointer in the\\nPgFdwDirectModifyState.\\n\\nI am okay with currently also, but it adding a note somewhere about this\\nwould be great. Also let keep this point open for the committer, if\\ncommitter feel this is good then lets go ahead with this.\\n\\nHere are few other cosmetic changes:\\n\\n1)\\n\\n+ *\\n+ * 'target_rel' is either zero or the rangetable index of a target\\nrelation.\\n+ * In the latter case this construncts FROM clause of UPDATE or USING\\nclause\\n+ * of DELETE by simply ignoring the target relation while deparsing the\\ngiven\\n\\nSpell correction: - construncts\\n\\n2)\\n\\n+ /*\\n+ * If either input is the target relation, get all the joinclauses.\\n+ * Otherwise extract conditions mentioning the target relation from\\n+ * the joinclauses.\\n+ */\\n\\n\\nspace between joinclauses needed.\\n\\n3)\\n\\n+ /*\\n+ * If UPDATE/DELETE on a join, create a RETURINING list used in the\\n+ * remote query.\\n+ */\\n+ if (fscan->scan.scanrelid == 0)\\n+ returningList = make_explicit_returning_list(resultRelation,\\n+ rel,\\n+ returningList);\\n\\n\\nSpell correction: RETURINING\\n\\nI did above changes in the attached patch. Please have a look once and\\nthen I feel like this patch is ready for committer.\\n\\nThanks,\\nRushabh Lathia\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 21 Feb 2017 16:01:54 +0530\",\n \"msg_from\": \"Rushabh Lathia <rushabh.lathia@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2017/02/21 19:31, Rushabh Lathia wrote:\\n> On Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita\\n> <fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\\n\\n> On 2017/02/13 18:24, Rushabh Lathia wrote:\\n> Here are few comments:\\n>\\n> 1)\\n>\\n> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\\n> PGresult *result; /* result for query */\\n> int num_tuples; /* # of result tuples */\\n> int next_tuple; /* index of next one to\\n> return */\\n> + Relation resultRel; /* relcache entry for the\\n> target table */\\n>\\n>\\n> Why we need resultRel? Can't we directly use dmstate->rel ?\\n>\\n>\\n> The reason why we need that is because in get_returning_data, we\\n> pass dmstate->rel to make_tuple_from_result_row, which requires that\\n> dmstate->rel be NULL when the scan tuple is described by\\n> fdw_scan_tlist. So in that case we set dmstate->rel to NULL and\\n> have dmstate->resultRel that is the relcache entry for the target\\n> relation in postgresBeginDirectModify.\\n\\n> Thanks for the explanation. We might do something here by using\\n> fdw_scan_tlist or changing the assumption of\\n> make_tuple_from_result_row(), and that way we can avoid two similar\\n> variable pointer in the PgFdwDirectModifyState.\\n\\nI agree that the two similar variables are annoying, to some extent, but \\nISTM that is not that bad because that makes the handling of \\ndmstate->rel consistent with that of PgFdwScanState's rel. As you know, \\nPgFdwDirectModifyState is defined in a similar way as PgFdwScanState, in \\nwhich the rel is a relcache entry for the foreign table for a simple \\nforeign table scan and NULL for a foreign join scan (see comments for \\nthe definition of PgFdwScanState).\\n\\n> I am okay with currently also, but it adding a note somewhere about this\\n> would be great. Also let keep this point open for the committer, if\\n> committer feel this is good then lets go ahead with this.\\n\\nAgreed.\\n\\n> Here are few other cosmetic changes:\\n>\\n> 1)\\n>\\n> + *\\n> + * 'target_rel' is either zero or the rangetable index of a target\\n> relation.\\n> + * In the latter case this construncts FROM clause of UPDATE or USING\\n> clause\\n> + * of DELETE by simply ignoring the target relation while deparsing the\\n> given\\n>\\n> Spell correction: - construncts\\n>\\n> 2)\\n>\\n> + /*\\n> + * If either input is the target relation, get all the joinclauses.\\n> + * Otherwise extract conditions mentioning the target relation from\\n> + * the joinclauses.\\n> + */\\n>\\n>\\n> space between joinclauses needed.\\n>\\n> 3)\\n>\\n> + /*\\n> + * If UPDATE/DELETE on a join, create a RETURINING list used in the\\n> + * remote query.\\n> + */\\n> + if (fscan->scan.scanrelid == 0)\\n> + returningList = make_explicit_returning_list(resultRelation,\\n> + rel,\\n> + returningList);\\n>\\n>\\n> Spell correction: RETURINING\\n\\nGood catch!\\n\\n> I did above changes in the attached patch. Please have a look once and\\n\\nI'm fine with that. Thanks for the patch!\\n\\n> then I feel like this patch is ready for committer.\\n\\nThanks for reviewing!\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 22 Feb 2017 15:45:50 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On Wed, Feb 22, 2017 at 12:15 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp\\n> wrote:\\n\\n> On 2017/02/21 19:31, Rushabh Lathia wrote:\\n>\\n>> On Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita\\n>> <fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\\n>>\\n>\\n> On 2017/02/13 18:24, Rushabh Lathia wrote:\\n>> Here are few comments:\\n>>\\n>> 1)\\n>>\\n>> @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\\n>> PGresult *result; /* result for query */\\n>> int num_tuples; /* # of result tuples */\\n>> int next_tuple; /* index of next one to\\n>> return */\\n>> + Relation resultRel; /* relcache entry for the\\n>> target table */\\n>>\\n>>\\n>> Why we need resultRel? Can't we directly use dmstate->rel ?\\n>>\\n>>\\n>> The reason why we need that is because in get_returning_data, we\\n>> pass dmstate->rel to make_tuple_from_result_row, which requires that\\n>> dmstate->rel be NULL when the scan tuple is described by\\n>> fdw_scan_tlist. So in that case we set dmstate->rel to NULL and\\n>> have dmstate->resultRel that is the relcache entry for the target\\n>> relation in postgresBeginDirectModify.\\n>>\\n>\\n> Thanks for the explanation. We might do something here by using\\n>> fdw_scan_tlist or changing the assumption of\\n>> make_tuple_from_result_row(), and that way we can avoid two similar\\n>> variable pointer in the PgFdwDirectModifyState.\\n>>\\n>\\n> I agree that the two similar variables are annoying, to some extent, but\\n> ISTM that is not that bad because that makes the handling of dmstate->rel\\n> consistent with that of PgFdwScanState's rel. As you know,\\n> PgFdwDirectModifyState is defined in a similar way as PgFdwScanState, in\\n> which the rel is a relcache entry for the foreign table for a simple\\n> foreign table scan and NULL for a foreign join scan (see comments for the\\n> definition of PgFdwScanState).\\n>\\n> I am okay with currently also, but it adding a note somewhere about this\\n>> would be great. Also let keep this point open for the committer, if\\n>> committer feel this is good then lets go ahead with this.\\n>>\\n>\\n> Agreed.\\n>\\n>\\nThanks.\\n\\nMarked this as Ready for Committer.\\n\\n\\n> Here are few other cosmetic changes:\\n>>\\n>> 1)\\n>>\\n>> + *\\n>> + * 'target_rel' is either zero or the rangetable index of a target\\n>> relation.\\n>> + * In the latter case this construncts FROM clause of UPDATE or USING\\n>> clause\\n>> + * of DELETE by simply ignoring the target relation while deparsing the\\n>> given\\n>>\\n>> Spell correction: - construncts\\n>>\\n>> 2)\\n>>\\n>> + /*\\n>> + * If either input is the target relation, get all the\\n>> joinclauses.\\n>> + * Otherwise extract conditions mentioning the target relation\\n>> from\\n>> + * the joinclauses.\\n>> + */\\n>>\\n>>\\n>> space between joinclauses needed.\\n>>\\n>> 3)\\n>>\\n>> + /*\\n>> + * If UPDATE/DELETE on a join, create a RETURINING list used in\\n>> the\\n>> + * remote query.\\n>> + */\\n>> + if (fscan->scan.scanrelid == 0)\\n>> + returningList = make_explicit_returning_list(resultRelation,\\n>> + rel,\\n>> + returningList);\\n>>\\n>>\\n>> Spell correction: RETURINING\\n>>\\n>\\n> Good catch!\\n>\\n> I did above changes in the attached patch. Please have a look once and\\n>>\\n>\\n> I'm fine with that. Thanks for the patch!\\n>\\n> then I feel like this patch is ready for committer.\\n>>\\n>\\n> Thanks for reviewing!\\n>\\n> Best regards,\\n> Etsuro Fujita\\n>\\n>\\n>\\n\\n\\n-- \\nRushabh Lathia\\n\\nOn Wed, Feb 22, 2017 at 12:15 PM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2017/02/21 19:31, Rushabh Lathia wrote:\\n\\nOn Mon, Feb 20, 2017 at 1:41 PM, Etsuro Fujita\\n<fujita.etsuro@lab.ntt.co.jp <mailto:fujita.etsuro@lab.ntt.co.jp>> wrote:\\n\\n\\n\\n On 2017/02/13 18:24, Rushabh Lathia wrote:\\n Here are few comments:\\n\\n 1)\\n\\n @@ -211,6 +211,12 @@ typedef struct PgFdwDirectModifyState\\n PGresult *result; /* result for query */\\n int num_tuples; /* # of result tuples */\\n int next_tuple; /* index of next one to\\n return */\\n + Relation resultRel; /* relcache entry for the\\n target table */\\n\\n\\n Why we need resultRel? Can't we directly use dmstate->rel ?\\n\\n\\n The reason why we need that is because in get_returning_data, we\\n pass dmstate->rel to make_tuple_from_result_row, which requires that\\n dmstate->rel be NULL when the scan tuple is described by\\n fdw_scan_tlist. So in that case we set dmstate->rel to NULL and\\n have dmstate->resultRel that is the relcache entry for the target\\n relation in postgresBeginDirectModify.\\n\\n\\n\\nThanks for the explanation. We might do something here by using\\nfdw_scan_tlist or changing the assumption of\\nmake_tuple_from_result_row(), and that way we can avoid two similar\\nvariable pointer in the PgFdwDirectModifyState.\\n\\n\\nI agree that the two similar variables are annoying, to some extent, but ISTM that is not that bad because that makes the handling of dmstate->rel consistent with that of PgFdwScanState's rel. As you know, PgFdwDirectModifyState is defined in a similar way as PgFdwScanState, in which the rel is a relcache entry for the foreign table for a simple foreign table scan and NULL for a foreign join scan (see comments for the definition of PgFdwScanState).\\n\\n\\nI am okay with currently also, but it adding a note somewhere about this\\nwould be great. Also let keep this point open for the committer, if\\ncommitter feel this is good then lets go ahead with this.\\n\\n\\nAgreed.Thanks.Marked this as Ready for Committer.\\n\\n\\nHere are few other cosmetic changes:\\n\\n1)\\n\\n+ *\\n+ * 'target_rel' is either zero or the rangetable index of a target\\nrelation.\\n+ * In the latter case this construncts FROM clause of UPDATE or USING\\nclause\\n+ * of DELETE by simply ignoring the target relation while deparsing the\\ngiven\\n\\nSpell correction: - construncts\\n\\n2)\\n\\n+ /*\\n+ * If either input is the target relation, get all the joinclauses.\\n+ * Otherwise extract conditions mentioning the target relation from\\n+ * the joinclauses.\\n+ */\\n\\n\\nspace between joinclauses needed.\\n\\n3)\\n\\n+ /*\\n+ * If UPDATE/DELETE on a join, create a RETURINING list used in the\\n+ * remote query.\\n+ */\\n+ if (fscan->scan.scanrelid == 0)\\n+ returningList = make_explicit_returning_list(resultRelation,\\n+ rel,\\n+ returningList);\\n\\n\\nSpell correction: RETURINING\\n\\n\\nGood catch!\\n\\n\\nI did above changes in the attached patch. Please have a look once and\\n\\n\\nI'm fine with that. Thanks for the patch!\\n\\n\\nthen I feel like this patch is ready for committer.\\n\\n\\nThanks for reviewing!\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n-- Rushabh Lathia\",\n \"msg_date\": \"Wed, 22 Feb 2017 16:27:55 +0530\",\n \"msg_from\": \"Rushabh Lathia <rushabh.lathia@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 2017/02/22 19:57, Rushabh Lathia wrote:\\n> Marked this as Ready for Committer.\\n\\nI noticed that this item in the CF app was incorrectly marked as \\nCommitted. This patch isn't committed, so I returned it to the previous \\nstatus. I also rebased the patch. Attached is a new version of the patch.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 22 Mar 2017 19:20:52 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On Wed, Mar 22, 2017 at 6:20 AM, Etsuro Fujita\\n<fujita.etsuro@lab.ntt.co.jp> wrote:\\n> On 2017/02/22 19:57, Rushabh Lathia wrote:\\n>> Marked this as Ready for Committer.\\n>\\n> I noticed that this item in the CF app was incorrectly marked as Committed.\\n> This patch isn't committed, so I returned it to the previous status. I also\\n> rebased the patch. Attached is a new version of the patch.\\n\\nSorry, I marked the wrong patch as committed. Apologies for that.\\n\\nThis doesn't apply any more because of recent changes.\\n\\ngit diff --check complains:\\ncontrib/postgres_fdw/postgres_fdw.c:3653: space before tab in indent.\\n\\n+ /* Shouldn't contain the target relation. */\\n+ Assert(target_rel == 0);\\n\\nThis comment should give a reason.\\n\\n void\\n deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,\\n Index rtindex, Relation rel,\\n+ RelOptInfo *foreignrel,\\n List *targetlist,\\n List *targetAttrs,\\n List *remote_conds,\\n\\nCould you add a comment explaining the meaning of these various\\narguments? It takes rtindex, rel, and foreignrel, which apparently\\nare all different things, but the meaning is not explained.\\n\\n /*\\n+ * Add a RETURNING clause, if needed, to an UPDATE/DELETE on a join.\\n+ */\\n+static void\\n+deparseExplicitReturningList(List *rlist,\\n+ List **retrieved_attrs,\\n+ deparse_expr_cxt *context)\\n+{\\n+ deparseExplicitTargetList(rlist, true, retrieved_attrs, context);\\n+}\\n\\nDo we really want to add a function for one line of code?\\n\\n+/*\\n+ * Look for conditions mentioning the target relation in the given join tree,\\n+ * which will be pulled up into the WHERE clause. Note that this is safe due\\n+ * to the same reason stated in comments in deparseFromExprForRel.\\n+ */\\n\\nThe comments for deparseFromExprForRel do not seem to address the\\ntopic of why this is safe. Also, the answer to the question \\\"safe\\nfrom what?\\\" is not clear.\\n\\n- deparseReturningList(buf, root, rtindex, rel, false,\\n- returningList, retrieved_attrs);\\n+ if (foreignrel->reloptkind == RELOPT_JOINREL)\\n+ deparseExplicitReturningList(returningList, retrieved_attrs, &context);\\n+ else\\n+ deparseReturningList(buf, root, rtindex, rel, false,\\n+ returningList, retrieved_attrs);\\n\\nWhy do these cases need to be handled differently? Maybe add a brief comment?\\n\\n+ if ((outerrel->reloptkind == RELOPT_BASEREL &&\\n+ outerrel->relid == target_rel) ||\\n+ (innerrel->reloptkind == RELOPT_BASEREL &&\\n+ innerrel->relid == target_rel))\\n\\n1. Surely it's redundant to check the RelOptKind if the RTI matches?\\n\\n2. Generally, the tests in this patch against various RelOptKind\\nvalues should be adapted to use the new macros introduced in\\n7a39b5e4d11229ece930a51fd7cb29e535db4494.\\n\\nThe regression tests remove every remaining case where an update or\\ndelete gets fails to get pushed to the remote side. I think we should\\nstill test that path, because we've still got that code. Maybe use a\\nnon-pushable function in the join clause, or something.\\n\\nThe new test cases could use some brief comments explaining their purpose.\\n\\n if (plan->returningLists)\\n+ {\\n returningList = (List *) list_nth(plan->returningLists, subplan_index);\\n\\n+ /*\\n+ * If UPDATE/DELETE on a join, create a RETURNING list used in the\\n+ * remote query.\\n+ */\\n+ if (fscan->scan.scanrelid == 0)\\n+ returningList = make_explicit_returning_list(resultRelation,\\n+ rel,\\n+ returningList);\\n+ }\\n\\nAgain, the comment doesn't really explain why we're doing this. And\\ninitializing returningList twice in a row seems strange, too.\\n\\nI am unfortunately too tired to finish properly reviewing this tonight. :-(\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 7 Apr 2017 21:28:34 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On 3/22/17 6:20 AM, Etsuro Fujita wrote:\\n> On 2017/02/22 19:57, Rushabh Lathia wrote:\\n>> Marked this as Ready for Committer.\\n> \\n> I noticed that this item in the CF app was incorrectly marked as\\n> Committed. This patch isn't committed, so I returned it to the previous\\n> status. I also rebased the patch. Attached is a new version of the patch.\\n\\nThis submission has been moved to CF 2017-07.\\n\\n-- \\n-David\\ndavid@pgmasters.net\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 8 Apr 2017 10:14:24 -0400\",\n \"msg_from\": \"David Steele <david@pgmasters.net>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"> On 08 Apr 2017, at 16:14, David Steele <david@pgmasters.net> wrote:\\n> \\n> On 3/22/17 6:20 AM, Etsuro Fujita wrote:\\n>> On 2017/02/22 19:57, Rushabh Lathia wrote:\\n>>> Marked this as Ready for Committer.\\n>> \\n>> I noticed that this item in the CF app was incorrectly marked as\\n>> Committed. This patch isn't committed, so I returned it to the previous\\n>> status. I also rebased the patch. Attached is a new version of the patch.\\n> \\n> This submission has been moved to CF 2017-07.\\n\\nThis patch has been marked Ready for Committer in the current commitfest\\nwithout being committed or rejected. Moving to the next commitfest, but since\\nit has bitrotted I’m moving it to Waiting for author.\\n\\ncheers ./daniel\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 2 Oct 2017 02:08:02 +0200\",\n \"msg_from\": \"Daniel Gustafsson <daniel@yesql.se>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Push down more UPDATEs/DELETEs in postgres_fdw\"\n },\n {\n \"msg_contents\": \"On Mon, Oct 2, 2017 at 9:08 AM, Daniel Gustafsson <daniel@yesql.se> wrote:\\n> This patch has been marked Ready for Committer in the current commitfest\\n> without being committed or rejected. Moving to the next commitfest, but since\\n> it has bitrotted I’m moving it to Waiting for author.\\n\\nNo updates have showed up since, so returned with feedback. Please\\nfeel free to send a new version if you can hack it.\\n-- \\nMichael\\n\\n\",\n \"msg_date\": \"Wed, 29 Nov 2017 13:51:58 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [HACKERS] Push down more UPDATEs/DELETEs in postgres_fdw\"\n }\n]","isConversational":false}}},{"rowIdx":43099,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\n\nlazy_truncate_heap() was waiting for\nVACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\nnot milliseconds as originally intended.\n\nFound by code inspection.\n\nSimon Riggs\n\nBranch\n------\nmaster\n\nDetails\n-------\nhttp://git.postgresql.org/pg/commitdiff/dcb12ce8d8691e0e526d3f38d14c4d7fc9c664f5\n\nModified Files\n--------------\nsrc/backend/commands/vacuumlazy.c | 2 +-\n1 file changed, 1 insertion(+), 1 deletion(-)\n\n\n-- \nSent via pgsql-committers mailing list (pgsql-committers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-committers\n","msg_date":"Tue, 06 Sep 2016 14:41:26 +0000","msg_from":"Simon Riggs <simon@2ndQuadrant.com>","msg_from_op":true,"msg_subject":"pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"},{"msg_contents":"On Tue, Sep 6, 2016 at 11:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\n> Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\n>\n> lazy_truncate_heap() was waiting for\n> VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\n> not milliseconds as originally intended.\n\nDon't we need to back-patch this?\n\nRegards,\n\n-- \nFujii Masao\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 21:47:08 +0900","msg_from":"Fujii Masao <masao.fujii@gmail.com>","msg_from_op":false,"msg_subject":"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"},{"msg_contents":"On 7 September 2016 at 13:47, Fujii Masao <masao.fujii@gmail.com> wrote:\n> On Tue, Sep 6, 2016 at 11:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\n>> Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\n>>\n>> lazy_truncate_heap() was waiting for\n>> VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\n>> not milliseconds as originally intended.\n>\n> Don't we need to back-patch this?\n\nIf we do then a database-wide VACUUM on a busy database will take\nsubstantially longer than it does now.\n\nThat may not be perceived as a \"fix\" by everybody, so we should not do\nit without an explicit agreement by many.\n\nThoughts?\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 7 Sep 2016 13:50:49 +0100","msg_from":"Simon Riggs <simon@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"},{"msg_contents":"Simon Riggs <simon@2ndquadrant.com> writes:\n> On 7 September 2016 at 13:47, Fujii Masao <masao.fujii@gmail.com> wrote:\n>> On Tue, Sep 6, 2016 at 11:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\n>>> lazy_truncate_heap() was waiting for\n>>> VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\n>>> not milliseconds as originally intended.\n\n>> Don't we need to back-patch this?\n\n> If we do then a database-wide VACUUM on a busy database will take\n> substantially longer than it does now.\n\nOn the other hand, it's also more likely to successfully perform desired\ntruncations.\n\n> That may not be perceived as a \"fix\" by everybody, so we should not do\n> it without an explicit agreement by many.\n\nAgreed, but I vote with Fujii-san for back-patching.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 07 Sep 2016 09:58:16 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"},{"msg_contents":"On 7 September 2016 at 14:58, Tom Lane <tgl@sss.pgh.pa.us> wrote:\n\n>> That may not be perceived as a \"fix\" by everybody, so we should not do\n>> it without an explicit agreement by many.\n>\n> Agreed, but I vote with Fujii-san for back-patching.\n\nNo problem with backpatching, just wanted some +1s before I did it.\n\nWill do that tomorrow.\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 8 Sep 2016 10:18:24 +0100","msg_from":"Simon Riggs <simon@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL"}],"string":"[\n {\n \"msg_contents\": \"Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\\n\\nlazy_truncate_heap() was waiting for\\nVACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\\nnot milliseconds as originally intended.\\n\\nFound by code inspection.\\n\\nSimon Riggs\\n\\nBranch\\n------\\nmaster\\n\\nDetails\\n-------\\nhttp://git.postgresql.org/pg/commitdiff/dcb12ce8d8691e0e526d3f38d14c4d7fc9c664f5\\n\\nModified Files\\n--------------\\nsrc/backend/commands/vacuumlazy.c | 2 +-\\n1 file changed, 1 insertion(+), 1 deletion(-)\\n\\n\\n-- \\nSent via pgsql-committers mailing list (pgsql-committers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-committers\\n\",\n \"msg_date\": \"Tue, 06 Sep 2016 14:41:26 +0000\",\n \"msg_from\": \"Simon Riggs <simon@2ndQuadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 6, 2016 at 11:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\\n>\\n> lazy_truncate_heap() was waiting for\\n> VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\\n> not milliseconds as originally intended.\\n\\nDon't we need to back-patch this?\\n\\nRegards,\\n\\n-- \\nFujii Masao\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 21:47:08 +0900\",\n \"msg_from\": \"Fujii Masao <masao.fujii@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n },\n {\n \"msg_contents\": \"On 7 September 2016 at 13:47, Fujii Masao <masao.fujii@gmail.com> wrote:\\n> On Tue, Sep 6, 2016 at 11:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>> Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\\n>>\\n>> lazy_truncate_heap() was waiting for\\n>> VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\\n>> not milliseconds as originally intended.\\n>\\n> Don't we need to back-patch this?\\n\\nIf we do then a database-wide VACUUM on a busy database will take\\nsubstantially longer than it does now.\\n\\nThat may not be perceived as a \\\"fix\\\" by everybody, so we should not do\\nit without an explicit agreement by many.\\n\\nThoughts?\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 7 Sep 2016 13:50:49 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n },\n {\n \"msg_contents\": \"Simon Riggs <simon@2ndquadrant.com> writes:\\n> On 7 September 2016 at 13:47, Fujii Masao <masao.fujii@gmail.com> wrote:\\n>> On Tue, Sep 6, 2016 at 11:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n>>> lazy_truncate_heap() was waiting for\\n>>> VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\\n>>> not milliseconds as originally intended.\\n\\n>> Don't we need to back-patch this?\\n\\n> If we do then a database-wide VACUUM on a busy database will take\\n> substantially longer than it does now.\\n\\nOn the other hand, it's also more likely to successfully perform desired\\ntruncations.\\n\\n> That may not be perceived as a \\\"fix\\\" by everybody, so we should not do\\n> it without an explicit agreement by many.\\n\\nAgreed, but I vote with Fujii-san for back-patching.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 07 Sep 2016 09:58:16 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n },\n {\n \"msg_contents\": \"On 7 September 2016 at 14:58, Tom Lane <tgl@sss.pgh.pa.us> wrote:\\n\\n>> That may not be perceived as a \\\"fix\\\" by everybody, so we should not do\\n>> it without an explicit agreement by many.\\n>\\n> Agreed, but I vote with Fujii-san for back-patching.\\n\\nNo problem with backpatching, just wanted some +1s before I did it.\\n\\nWill do that tomorrow.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 8 Sep 2016 10:18:24 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: [COMMITTERS] pgsql: Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\"\n }\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":430,"numItemsPerPage":100,"numTotalItems":58371,"offset":43000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTQ2ODIyMCwianRpIjoiMTc1ZDg1NGUtMjU4MS00NzExLWIxZmItMzUyZTU4YjZmMGFjIiwic3ViIjoiL2RhdGFzZXRzL3dhbnNoZW5sL3Bnc3FsLWhhY2tlcnMiLCJleHAiOjE3ODU0NzE4MjAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.hrnIH_byrzpyMSo8IO1gl9HgKqwpDewJdMWzA9EvvaKri3aO2IZfGn8NwDfpaz3QYfxtpHMQsCrE72rAmdz0AQ","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\nI've attached a patch to check if the current page is equal with the\nFPW after applying WAL on it. This is how the patch works:\n\n1. When a WAL record is inserted, a FPW is done for that operation.\nBut, a flag is kept to indicate whether that page needs to be\nrestored.\n2. During ... |
[
{
"msg_contents": "Hi hackers,\n\nI've found a typo in a comment to function LockHasWaitersRelation() [lmgr.c : \n271, master branch]:\n\n>> This is a functiion to check\n\n\n-- \nDmitry Ivanov\nPostgres Professional: http://www.postgrespro.com\nRussian Postgres Company\n\n\n-- \nSent via pgsql-hackers mailing ... |
[
{
"msg_contents": "Hi guys,\n\n while adding synchronous WAL streaming to Barman, I noticed that\npg_receivexlog - unless a replication slot is specified and --synchronous\nis passed - does not become a synchronous receiver (if the application_name\nis in the synchronous_standby_names value). I was a bit surpr... |
[
{
"msg_contents": "I got tired of hearing complaints about the issue described in\nthis thread:\nhttps://www.postgresql.org/message-id/flat/24241.1329347196%40sss.pgh.pa.us\n\nHere's a proposed fix. I've not done extensive performance testing,\nbut it seems to be as fast or faster than the old code in cases wh... |
[
{
"msg_contents": "$SUBJECT will make hash indexes reliable and usable on standby.\nAFAIU, currently hash indexes are not recommended to be used in\nproduction mainly because they are not crash-safe and with this patch,\nI hope we can address that limitation and recommend them for use in\nproduction.\n\nThis pa... |
[
{
"msg_contents": "Hi all,\n\nI'd like to propose block level parallel VACUUM.\nThis feature makes VACUUM possible to use multiple CPU cores.\n\nVacuum Processing Logic\n===================\n\nPostgreSQL VACUUM processing logic consists of 2 phases,\n1. Collecting dead tuple locations on heap.\n2. Reclaiming de... |
[
{
"msg_contents": "comment typo in src/backend/storage/lmgr.c attached\n\nErik Rijkers\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers",
"msg_date": "Tue, 23 Aug 2016 14:13:33 +0200",
... |
[
{
"msg_contents": "I'm failing to understand why [1] mentions \"table-rewriting forms of ALTER\nTABLE\" besides TRUNCATE command.\n\nFor TRUNCATE it seems clear: if transaction A takes the snapshot before it\naccesses the table first time (typically because isolation level is at least\nREPEATABLE READ) and tran... |
[
{
"msg_contents": "Hello devs,\n\nWhen \\sleep is used within a pgbench script it resets txn_scheduled which \nis used for computing stats about the transaction, resulting in absurd \nstatistics:\n\n latency average = 0.649 ms *** ??? ***\n ...\n script statistics:\n - statement latencies in milliseconds:\... |
[
{
"msg_contents": "I happened to notice, while experimenting with the data set used\nin the SPGIST-for-inet thread, that loading the supplied pg_dump\nscript and immediately dumping it does not reproduce the row order\nappearing in the original dump script. I thought maybe this had\nsomething to do with the he... |
[
{
"msg_contents": "Greetings,\n\nAttached is an rebased and updated patch to remove the explicit\nsuperuser() checks from the contrib extension pgstattuple, in favor of\nusing the GRANT system to control access, and give the admin flexibility\nto GRANT access to this function without having to write wrapper\nfu... |
[
{
"msg_contents": "Sorry for starting a new thread, I can't find the correct one to reply to.\n\nUsing: gcc version 4.8.3 20140627 [gcc-4_8-branch revision 212064] (SUSE Linux)\n\ncommit ed0097e4f9e6b1 has introduced two compiler warnings:\n\ngistutil.c: In function 'gistproperty':\ngistutil.c:855:16: warning: ... |
[
{
"msg_contents": "Hi,\n\nWhile playing with LATERAL along with some aggregates in sub-query, I have\nobserved somewhat unusual behavior.\n\nConsider following steps:\n\ncreate table tab1(c1 int, c2 int);\ninsert into tab1 select id, 1 from generate_series(1, 3) id;\ncreate function sum_tab1(extra int) returns ... |
[
{
"msg_contents": "There was some discussion earlier in adding pg_stat_lwlock view in [1].\nThe main objections which I observed for that patch was showing LWLOCK\ninformation to the user that don't understand what this lock used for and etc.\n\nCurrently as part of wait_event information in pg_stat_activity th... |
[
{
"msg_contents": "Over in the thread about the SP-GiST inet opclass, I threatened to post\na patch like this, and here it is.\n\nThe basic idea is to track more than just the very latest page we've used\nin each of the page categories that SP-GiST works with. I started with an\narrangement that gave an equal ... |
[
{
"msg_contents": "Hi,\n\nI'd like to propose that we increase the default WAL segment size,\nwhich is currently 16MB. It was first set to that value in commit\n47937403676d913c0e740eec6b85113865c6c8ab in October of 1999; prior to\nthat, it was 64MB. Between 1999 and now, there have been three\nsignificant ch... |
[
{
"msg_contents": "Hello, gurus,\n\nI faced incorrect checksum on \"global/pg_filenode.map\" at the right timing \"VACUUM FULL\" is executed and session was aborted.\n\nAug 16 20:51:19 postgres[22329]: [2-1] FATAL: relation mapping file \"global/pg_filenode.map\" contains incorrect checksum\n\n\nAug 16 20:51:1... |
[
{
"msg_contents": "Suppose we have some table\n\ncreate table cnt( \n usr_id int primary key, \n usr_doc_ref text not null, \n cnt int, \n sum int \n);\n\nAnd going to run some insert on conflict update on it (pgbench script):\n\n\\setrandom id 1 50 \ninsert into cnt as c(usr_id,usr_doc_ref, cnt) values(:id, '#... |
[
{
"msg_contents": "Hello hackers.\n\nI have a small question. While working on an incremental backup I noticed a \nstrange thing.\nNewly created index is contains the invalid LSN (0/0).\nExmaple:\npostgres=# select lsn from page_header(get_raw_page('test_a_idx2',0));\n lsn \n-----\n 0/0\n(1 row)\n\nCan you expl... |
[
{
"msg_contents": "Hi,\n\nMy PostgreSQL client checks the PG_DIAG_SEVERITY error field to determine the error level.\n\nHowever, I have now learned that this field is localized. This means that a server configured with --enable-nls might for example return the string ERREUR instead of ERROR.\n\nSo if I want to ... |
[
{
"msg_contents": "\nHello Peter,\n\nMy 0.02ￜ (not $0.02:-) comments on this patch:\n\nPatch applies and \"make check\" is ok. I see no issue with the code.\n\nA few comments below.\n\nThe regression tests are clearer & commented, it is an improvement.\n\nWhile you are at it, maybe you could consider adding t... |
[
{
"msg_contents": "This is a chance to add default configuration for Greek language if\nsomebody with good knowledge could follow this development.\n\nOleg\n\n---------- Forwarded message ----------\nFrom: Oleg Smirnov <oleg.smirnov@gmail.com>\nDate: Thu, Aug 25, 2016 at 5:26 PM\nSubject: [Snowball-discuss] Gre... |
[
{
"msg_contents": "Hello,\n\nOur customer hit a problem of cascading replication, and we found the cause. They are using the latest PostgreSQL 9.2.18. The bug seems to have been fixed in 9.4 and higher during the big modification of xlog.c, but it's not reflected in older releases.\n\nThe attached patch is fo... |
[
{
"msg_contents": "Hi all,\n\nI am relaunching $subject as 10 development will begin soon. As far as\nI know, there is agreement that we can do something here. Among the\ndifferent proposals I have found:\n- pg_clog renamed to pg_commit_status, pg_xact or pg_commit\n- pg_xlog renamed to pg_xjournal, pg_wal or p... |
[
{
"msg_contents": "Latest from lorikeet:\nhttp://buildfarm.postgresql.org/cgi-bin/show_log.pl?nm=lorikeet&dt=2016-08-26%2008%3A37%3A27\n\nTRAP: FailedAssertion(\"!(vmq->mq_sender == ((void *)0))\", File: \"/home/andrew/bf64/root/REL9_6_STABLE/pgsql.build/../pgsql/src/backend/storage/ipc/shm_mq.c\", Line: 220)\n... |
[
{
"msg_contents": "Actually we don't support the SQL feature F867 \"FETCH FIRST clause: WITH \nTIES option\". On the other side we support the window function \"rank()\" \nwhich acts like the \"WITH TIES option\". My questions are: Is it hard to \nimplement the \"WITH TIES option\"? Are there plans for a realiz... |
[
{
"msg_contents": "Hello, Michael.\n\nYour patch [1] was marked as \"Needs review\" so I decided to take a look.\n\nIt looks good to me. However I found dozens of places in PostgreSQL code\nthat seem to have similar problem you are trying to fix [2]. As far as I\nunderstand these are only places left that don't... |
[
{
"msg_contents": "Hi,\n\nI'm bringing this $subject into discussion again. Historically, we are\ncarrying binary names that have been confused newbies. createuser is the\nworst name so for. Also, names like createdb, initdb, reindexdb, and\ndroplang does not suggest what product it is referring to. Adding a\np... |
[
{
"msg_contents": "Hello,\n\nI've attached a patch to add SortSupport for Postgres' macaddr which has the\neffect of improving the performance of sorting operations for the type. The\nstrategy that I employ is very similar to that for UUID, which is to create\nabbreviated keys by packing as many bytes from the ... |
[
{
"msg_contents": "I doubt the documentation for old_snapshot_threshold is going to be\nunderstood by many ordinary users. What is a \"snapshot\", first of all?\nWhy would a snapshot be old? Why is that a problem? What can I do to\navoid it? What are the circumstances in practice where this issue would\nari... |
[
{
"msg_contents": "The standard calling pattern for AllocSetContextCreate is\n\n cxt = AllocSetContextCreate(parent, name,\n ALLOCSET_DEFAULT_MINSIZE,\n ALLOCSET_DEFAULT_INITSIZE,\n ALLOCSET_DEFAULT_MAXSIZE);\n\nor f... |
[
{
"msg_contents": "Hi,\n\nI've noticed the comment in src/include/catalog/pg_foreign_table.h still \ntalks about genbki.sh, but AFAIK it was replaced with genbki.pl.\n\nregards\n\n-- \nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services... |
[
{
"msg_contents": "The routine in PostGIS to parse out the version number from pg_config is\nbreaking in the 10 cycle.\n\nIssue seems to be because there is no minor specified.\n\ne.g.\n\npgconfig --version \n\nreturns:\n\nPostgreSQL 10devel\n\nInstead of expected\n\nPostgreSQL 10.0devel\n\nIs this the way it's... |
[
{
"msg_contents": "Just making sure everyone's on the same page.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n",
"msg_date": "Sun, 28 Aug 2016 18:11:20 -0400",... |
[
{
"msg_contents": "Hello,\n\nI noticed the source code comment around CustomPath structure says \"see above\"\nfor definition of CUSTOMPATH_* flags. It was originally right, but it was moved\nto nodes/extensible.h on the further development. So, no comments are above.\nThe attached patch corrects the comment fo... |
[
{
"msg_contents": "The attached two patches scratch two itches I've been having for a\nwhile. I'm attaching them together because the second depends on the first.\n\nBoth deal with the fact that [auto]vacuum has taken on more roles than\nits original purpose.\n\n\nPatch One: autovacuum insert-heavy tables\n\nI... |
[
{
"msg_contents": "We have sample configuration files for postgresql.conf and\nrecovery.conf, but we do not have them for contrib modules. This patch\nattempts to add them.\n\nAlthough the patch puts the sample configuration files in the tree, it\ndoesn't try to install them. That's partly because I think it ... |
[
{
"msg_contents": "Hello,\n\nThe attached patch adds an optional callback to support special optimization\nif ForeignScan/CustomScan are located under the Limit node in plan-tree.\n\nOur sort node wisely switches the behavior when we can preliminary know\nexact number of rows to be produced, because all the Sor... |
[
{
"msg_contents": "Hi, hackers!\n\n\nSome time ago I put a patch to commitfest that optimizes slightly GiST\ninserts and updates. It's effect in general is quite modest (15% perf\nimproved), but for sorted data inserts are 3 times quicker. This\neffect I attribute to mitigation of deficiencies of old split\nalg... |
[
{
"msg_contents": "ecpg option --help alternative -? doesn't work in windows.\nIn windows, the PG provided getopt_long function is used\nfor reading the provided options.\n\nThe getopt_long function returns '?' for invalid characters\nalso but it sets optopt option to 0 in case if the character\nitself is a '?'... |
[
{
"msg_contents": "Hi all\n\nIt's recently been observed[1] that the 10.0 version scheme change has\naffected PostGIS, which relies on parsing the server version string\nand broke when faced with a string like \"10.0devel\" since it expected\na minor version.\n\nIn that thread Tom points out [2] that they shoul... |
[
{
"msg_contents": "Fix pg_receivexlog --synchronous\n\nMake pg_receivexlog work correctly with —-synchronous without slots\n\nBackpatch to 9.5\n\nGabriele Bartolini, reviewed by Michael Paquier and Simon Riggs\n\nBranch\n------\nREL9_5_STABLE\n\nDetails\n-------\nhttp://git.postgresql.org/pg/commitdiff/9050e5c8... |
[
{
"msg_contents": "Hi, hackers!\n\nNow I complete extension that provides facility to see the current state \nof query execution working on external session in form of EXPLAIN \nANALYZE output. This extension works on 9.5 version, for 9.6 and later \nit doesn't support detailed statistics for parallel nodes yet... |
[
{
"msg_contents": "In bug #14300 it's pointed out that cube_in rejects zero-element\ncubes, as well as infinity and NaN coordinate values. Since it's\neasy to make such cube values via the cube-from-float-array\nconstructors, this is a dump/reload hazard. The attached proposed\npatch attempts to fix it up.\n\... |
[
{
"msg_contents": "Hello.\n\nThe comment on GatherPath.single_copy is the following.\n\n===\n/*\n * GatherPath runs several copies of a plan in parallel and collects the\n * results. The parallel leader may also execute the plan, unless the\n * single_copy flag is set.\n */\ntypedef struct GatherPath\n{\n ... |
[
{
"msg_contents": "Hello,\n\nDuring the server restart, we are getting postgres crash with sigabrt. No other operation being performed.\nAttached the backtrace.\n\n\nThe occurrence is occasional. The issue is seen once in 30~50 times.\nRecently we had performed postgres upgrade from 9.3.9 to 9.3.11. The issue i... |
[
{
"msg_contents": "Hi,\n\nI received an email offlist about a crash that a non-customer experienced\nrecently. I asked them to send a few details about the crash, so here it is.\nPlease note that I don't have access to their systems, but they will be fast\nenough to provide data if needed. (They asked me to mas... |
[
{
"msg_contents": "While profiling some queries and looking at executor overhead, I \nrealized that we're not making much use of TupleTableSlot's ability to \nhold a buffer pin. In a SeqScan, the buffer is held pinned by the \nunderlying heap-scan anyway. Same with an IndexScan, and the SampleScan. \nThe only t... |
[
{
"msg_contents": "I was toying with a couple of ideas that would involve changing the\nstorage of sequences. (Say, for the sake of discussion, removing the\nproblematic/useless sequence_name field.) This would cause problems for\npg_upgrade, because pg_upgrade copies the \"heap\" storage of sequences\nlike i... |
[
{
"msg_contents": "Hi all,\n\nAttached is the patch which adds support to push down aggregation and\ngrouping\nto the foreign server for postgres_fdw. Performing aggregation on foreign\nserver results into fetching fewer rows from foreign side as compared to\nfetching all the rows and aggregating/grouping local... |
[
{
"msg_contents": "Hi\n\nI am working on pgaudit customization for one my customer.\n\nThere are few requests:\n\n1. flat format without complex types, without nesting - CSV is ideal.\n2. all important attributes should be separated - is not possible to search\nin original queries: table name, database name, ro... |
[
{
"msg_contents": "Hi,\n\nAttached is a patch that adds support for hash indexes in pageinspect.\n\nThe functionality (hash_metap, hash_page_stats and hash_page_items) \nfollows the B-tree functions.\n\nThis patch will need an update once Amit's and Mithun's work on \nConcurrent Hash Indexes is committed to acc... |
[
{
"msg_contents": "I would like to propose the attached patch implementing autonomous\ntransactions for discussion and review.\n\nThis work was mostly inspired by the discussion about pg_background a\nwhile back [0]. It seemed that most people liked the idea of having\nsomething like that, but couldn't perhaps... |
[
{
"msg_contents": "Here is a patch I've been working on to allow the use of ICU for sorting\nand other locale things.\n\nThis is mostly complementary to the existing FreeBSD ICU patch, most\nrecently discussed in [0]. While that patch removes the POSIX locale\nuse and replaces it with ICU, my interest was on a... |
[
{
"msg_contents": "Here is another attempt to implement identity columns. This is a\nstandard-conforming variant of PostgreSQL's serial columns. It also\nfixes a few usability issues that serial columns have:\n\n- need to set permissions on sequence in addition to table (*)\n- CREATE TABLE / LIKE copies defau... |
[
{
"msg_contents": "Here is a patch that adds the notion of a data type to a sequence. So\nit might be CREATE SEQUENCE foo AS integer. The types are restricted to\nint{2,4,8} as now.\n\nThe main point of this is to make monitoring sequences less complicated.\n Right now, a serial column creates an int4 column ... |
[
{
"msg_contents": "Hi all,\n\nCleanup $subject has been raised a couple of times, like one year ago here:\nhttps://www.postgresql.org/message-id/CAB7nPqRxvq+Q66UFzD9wa5UAftYN4WAUADbjXKFrync96kf-VQ@mail.gmail.com\nAnd more recently here while working on the NULL checks for malloc():\nhttps://www.postgresql.org/m... |
[
{
"msg_contents": "Hi,\n\nattached is a small patch that adds an -N option to pg_restore, in order\nto exclude a schema, in addition to -n for the restriction to a schema.\n\nIn principle, this could be extended to -t etc., but I think having this\nfor schemas would be the most useful with the least effort.\n\n... |
[
{
"msg_contents": "Hi,\n\nNow that we are OK with static inline functions, we can save some cycles \nfrom floating-point functions, by turning Float4GetDatum, \nFloat8GetDatum, and DatumGetFloat8 into static inlines. They are only a \nfew instructions, but couldn't be implemented as macros before, because \nthe... |
[
{
"msg_contents": "When SSL renegotiation was removed in 426746b9 the only consumer of the openssl\nspecific count member in the Port struct was removed, but the member was left\ntogether with a few updates to it which are unused. Attached patch removes the\nleftovers which now serves no purpose unless I’m mis... |
[
{
"msg_contents": "Use static inline functions for float <-> Datum conversions.\n\nNow that we are OK with using static inline functions, we can use them\nto avoid function call overhead of pass-by-val versions of Float4GetDatum,\nDatumGetFloat8, and Float8GetDatum. Those functions are only a few CPU\ninstructi... |
[
{
"msg_contents": "While I was hacking around sequence stuff, I felt the urge to look into\nan old peeve: That sequence metadata is not stored in a proper catalog.\nRight now in order to find out some metadata about sequences (min, max,\nincrement, etc.), you need to look into the sequence. That is like\nhavin... |
[
{
"msg_contents": "Hi hackers,\n\nFew days earlier I've finished my work on WAITLSN statement utility, so \nI’d like to share it.\n\n\nIntroduction\n============\n\nOur clients who deal with 9.5 and use asynchronous master-slave \nreplication, asked to make the wait-mechanism on the slave side to \nprevent the ... |
[
{
"msg_contents": "I've been profiling simple aggregate queries, looking for any \nlow-hanging fruit. For this query:\n\n\n-- setup\ncreate table floats as select g::float8 as a, g::float8 as b, g::float8 \nas c from generate_series(1, 10000000) g;\nvacuum freeze floats;\n\n-- query\nselect sum(a), sum(b+c) fro... |
[
{
"msg_contents": "Hi hackers,\n\nRecently I have finished my work on a patch for pg_buffercache contrib, \nI think it's time to share my results.\n\n\nIntroduction\n============\n\nI want to offer you the implementation that allows to decrease system \nworkload by\npartially sacrificing (fully snapshot consist... |
[
{
"msg_contents": "Hi\n\nI propose a new type of psql variables - file references. The content of\nfile reference is specified by referenced file. It allows simple inserting\nlarge data without necessity of manual escaping or using LO api.\n\nWhen I wrote the patch, I used parametrized queries for these data in... |
[
{
"msg_contents": "This is a summary of proposed changes to the recovery.conf API for\nv10. These are based in part on earlier discussions, and represent a\nminimal modification to current usage.\n\nProposed changes (with reference to patches from Abhijit Menon-Sen and myself)\n\n* pg_ctl start -M (normal|recov... |
[
{
"msg_contents": "Hi All,\n\nAs previously discussed [1], WARM is a technique to reduce write\namplification when an indexed column of a table is updated. HOT fails to\nhandle such updates and ends up inserting a new index entry in all indexes\nof the table, irrespective of whether the index key has changed or... |
[
{
"msg_contents": "Attached patch adds support for -X stream to work with .tar and .tar.gz\nfile formats.\n\nIf tar mode is specified, a separate pg_xlog.tar (or .tar.gz) file is\ncreated and the data is streamed into it. Regular mode is (should not) see\nany changes in how it works.\n\nThe implementation creat... |
[
{
"msg_contents": "-hackers,\n\nSo this is more of a spit balling thread than anything. As I understand \nit, if we have a long running transaction or a large number of wal logs \nand we crash, we then have to restore those logs on restart to the last \nknown good transaction. No problem.\n\nI recently ran a ve... |
[
{
"msg_contents": "Hi all\n\nAttached is a rebased and updated logical decoding timeline following\npatch for 10.0.\n\nThis is a pre-requisite for the pending work on logical decoding on\nstandby servers and simplified failover of logical decoding.\n\nRestating the commit message:\n__________\n\nFollow timeline... |
[
{
"msg_contents": "Hi all\n\nHere's a rebased version of my pg_recvlogical --endpos patch from the\n9.5 series, updated to incoroprate Álvaro's changes.\n\nThis will be mainly useful for recovery tests as we start adding more\nlogical decoding testing.\n\nSee original post for more detail:\n\nhttps://www.postgr... |
[
{
"msg_contents": "Greetings,\n\nAs outlined in the commit message, this adds support for restrictive RLS\npolicies. We've had this in the backend since 9.5, but they were only\navailable via hooks and therefore extensions. This adds support for\nthem to be configured through regular DDL commands. These poli... |
[
{
"msg_contents": "Hi\n\nI see a new warning in upstream\n\nr/include/libxml2 -c -o path.o path.c\npath.c: In function ‘has_drive_prefix’:\npath.c:89:26: warning: self-comparison always evaluates to false\n[-Wtautological-compare]\n return skip_drive(path) != path;\n ^~\nRegards\n\n[... |
[
{
"msg_contents": "Dear all,\n\nI am developing an extension for the PostgreSQL that write/read some\nexternal files from the PostgreSQL. In order to write/read, I am using the\nO_DIRECT flag and using the posix_memalign to allocate memory. I would like\nto know if the postgresql internal library provides an eq... |
[
{
"msg_contents": "Hi,\n\nWhile investigating a CTE-related query, I've noticed that we don't\nreally remove all unreachable CTEs. For example, for this query\n\n with a as (select 1),\n b as (select * from a),\n c as (select * from b)\n select 2;\n\nwhere none of the CTEs if (directly or ... |
[
{
"msg_contents": "Hi all,\n\nThe 2016-09 commitfest is officially in progress, and I'm the manager.\n\nThe current status summary is\n\nNeeds review: 119\nNeeds *reviewer*: 63\n\nPlease check the \"needs reviewer\" list\n(https://commitfest.postgresql.org/10/?reviewer=-2\n<https://commitfest.postgresql.org/9/?... |
[
{
"msg_contents": "Hi,\n\nAttached is a patch to make it build with OpenSSL 1.1.0.\n\nThere is probably a minor problem on windows where the name of the\ndlls got changed. Someone probably should look into that.\n\n\nKurt\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make... |
[
{
"msg_contents": "Hi all\n Using logical decoding i set up a plugin to refresh materialized\nviews incrementally(only the changes that are did after the previous\nrefresh). I used the approach that oracle uses for fast refresh of\nmaterialized view using log table to record delta changes.\n\n Mostly i... |
[
{
"msg_contents": "It turns out that some of the zone abbreviations shown in the IANA\ntimezone database don't correspond to any real-world usage, but were\nmore or less made up by the timezone database crew. And of late,\nthose folk have started to remove these invented abbreviations in favor\nof just using n... |
[
{
"msg_contents": "Hi,\n\nThe use of __attribute__ is currently enabled by checking for\n__SUNPRO_C. However, this compiler only added support for\n__attribute__ keywords in version 5.10 [1]. This patch adds a version\ncheck to only enable this for supported versions [2].\n\nI have tested this with Sun C 5.8 on... |
[
{
"msg_contents": "In CteScanNext():\n\n\t/*\n \t * If we are not at the end of the tuplestore, or are going \nbackwards, try\n \t * to fetch a tuple from tuplestore.\n \t */\n \teof_tuplestore = tuplestore_ateof(tuplestorestate);\n\n \tif (!forward && eof_tuplestore)\n\nFor the comment to be correct, woul... |
[
{
"msg_contents": "The attached patch allows setting maintainance_work_mem or\nautovacuum_work_mem higher than 1GB (and be effective), by turning the\nallocation of the dead_tuples into a huge allocation.\n\nThis results in fewer index scans for heavily bloated tables, and\ncould be a lifesaver in many situatio... |
[
{
"msg_contents": "Hi,\n\nupdating master from be7f7ee..39b691f, the following assertion is\ntriggered frequently by sqlsmith:\n\nTRAP: BadArgument(\"!(((context) != ((void *)0) && (((((const Node*)((context)))->type) == T_AllocSetContext))))\", File: \"mcxt.c\", Line: 1010)\n\nDigging in the coredumps, it look... |
[
{
"msg_contents": "One thing that has been irking me ever since I came to PostgreSQL is the\nfact that pg_ctl -w (and -W) don't have longhand equivalents. I like to\nuse the long version in scripts and such as extra documentation, and\nI've never been able to with these. What's more, I keep forgetting that\n-... |
[
{
"msg_contents": "Hi guys,\n\nI'm trying to get my feet wet in PG development, but I ran into a snag\nwith the TODO item I picked. Could someone please tell me if I'm\nmaking an obvious error?\n\nI chose this item from the TODO page: \"[E] Remove warnings created by\n-Wcast-align\". It didn't have a check-ma... |
[
{
"msg_contents": "I noticed some imbalanced '-'s in execnodes.h. Though, ISTM newer code \ndoesn't use -'s in comments anymore, so maybe it'd be better to just \nditch them?\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Troub... |
[
{
"msg_contents": "Hi all\n\nCurrently hot standby feedback sends GetOldestXmin()'s result to the\nupstream as the required xmin. GetOldestXmin() returns a slot's\ncatalog_xmin if that's the lowest xmin on the system.\n\nThat's fine so long as we don't do logical decoding on standbys, but\nif we start allowing ... |
[
{
"msg_contents": "Hello,\n\nI'd like to propose adding SJIS as a database encoding. You may wonder why SJIS is still necessary in the world of Unicode. The purpose is to achieve comparable performance when migrating legacy database systems from other DBMSs without little modification of applications.\n\nRece... |
[
{
"msg_contents": "While reading the logical replication (and related) code, I found a few unused\nfunction arguments:\n\n\t * XactLogCommitRecord() - unused argument forceSync\n\n\t * SnapBuildBuildSnapshot() - xid\n\n\t * TeardownHistoricSnapshot() - is_error\n\nNo idea which ones are intended for future use ... |
[
{
"msg_contents": "Hi all\n\nNow that it's becoming more common to post patch series, not just\nstandalone patches, it might be worth looking at how the CF app can\nhelp manage them.\n\nAny ideas? Especially since the patch series may not get committed all\nin one go, but progressively rebased on top of the bit... |
[
{
"msg_contents": "Hello, hackers!\n\nWe were testing how well some application works with PostgreSQL and \nstumbled upon an autovacuum behavior which I fail to understand.\nApplication in question have a habit to heavily use temporary tables in \nfunny ways.\nFor example it creates A LOT of them.\nWhich is ok.... |
[
{
"msg_contents": "Hi guys,\n\nCan anyone suggest a project for my first PG contribution?\n\nMy first two ideas didn't pan out: Yury doesn't seem to need help\nwith CMake, and the TODO list's \"-Wcast-align\" project (now deleted)\nappeared impractical.\n\nI can continue trying things from the TODO list, but i... |
[
{
"msg_contents": "While working on my parallel CREATE INDEX patch, I came across a\nproblem. I initially assumed that what I saw was just a bug in my\ndevelopment branch. During a final merge in a parallel worker, with\nvery little maintenance_work_mem, workers attempted to allocate an\namount of memory slight... |
[
{
"msg_contents": "Attached fixes a typo in header comment in libpq-be.h.\n\ns/libpq_be.h/libpq-be.h/g\n\nThanks,\nAmit\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers",
"msg_date": "Tue, ... |
[
{
"msg_contents": "While reviewing Jeff's notice_lock_waits patch, I came across his comment\nabout having a general facility for promoting selected LOG messages. So I\nthought I should post it here, even though the patch is probably far from\nbeing accepted in Postgres.\n\nI recently wrote a patch for Postgres... |
[
{
"msg_contents": "In vacuumlazy.c, VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL is described as\nbeing in ms on line 85, yet it is used on line 1759 in a call to\npg_usleep, so is treated as microseconds rather than milliseconds.\n\nAs a result, the timeout during lazy_truncate_heap() is actually only\n5ms long, not 5s ... |
[
{
"msg_contents": "While reviewing Peter's latest round of sorting patches, and trying to \nunderstand the new \"batch allocation\" mechanism, I started to wonder how \nuseful the pre-reading in the merge stage is in the first place.\n\nI'm talking about the code that reads a bunch of from each tape, loading \n... |
[
{
"msg_contents": "Hi,\n\nAttached is a WIP patch extending the postgres_fdw DML pushdown in 9.6 \nso that it can perform an update/delete on a join remotely. An example \nis shown below:\n\n* without the patch:\npostgres=# explain verbose delete from ft1 using ft2 where ft1.a = ft2.a;\n \n QUE... |
[
{
"msg_contents": "Fix VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL\n\nlazy_truncate_heap() was waiting for\nVACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, but in microseconds\nnot milliseconds as originally intended.\n\nFound by code inspection.\n\nSimon Riggs\n\nBranch\n------\nmaster\n\nDetails\n-------\nhttp://git.postgresql.or... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.