Re: Relation extension scalability

I have tried the approach of group extend,

1. We convert the extension lock to TryLock and if we get the lock then extend by one block.2.
2. If don't get the Lock then use the Group leader concep where only one process will extend for all, Slight change from ProcArrayGroupClear is that here other than satisfying the requested backend we Add some extra blocks in FSM, say GroupSize*10.
3. So Actually we can not get exact load but still we have some factor like group size tell us exactly the contention size and we extend in multiple of that.

Performance Analysis:
---------------------
Performance is scaling with this approach, its slightly less compared to previous patch where we directly give extend_by_block parameter and extend in multiple blocks, and I think that's obvious because in group extend case only after contention happen on lock we add extra blocks, but in former case it was extending extra blocks optimistically.

Test1(COPY)
-----
./psql -d postgres -c "COPY (select g.i::text FROM generate_series(1, 10000) g(i)) TO '/tmp/copybinary' WITH BINARY";
echo COPY data from '/tmp/copybinary' WITH BINARY; > copy_script

./pgbench -f copy_script -T 300 -c$ -j$ postgres

Shared Buffer:8GB    max_wal_size:10GB      Storage:Magnetic Disk    WAL:SSD
-----------------------------------------------------------------------------------------------
Client    Base  multi_extend by 20 page     group_extend_patch(groupsize*10)
1              105                157                               149   
2              217                255                               282   
4              210                 494                              452
8              166                702                               629
16            145                 563                              561
32            124                 480                              566   

Test2(INSERT)
--------
./psql -d postgres -c "create table test_data(a int, b text)"
./psql -d postgres -c "insert into test_data values(generate_series(1,1000),repeat('x', 1024))"
./psql -d postgres -c "create table data (a int, b text)
echo "insert into data select * from test_data;" >> insert_script

 shared_buffers=512GB  max_wal_size=20GB  checkpoint_timeout=10min
./pgbench -c $ -j $ -f insert_script -T 300 postgres

Client        Base    Multi-extend by 1000    *group extend (group*10)    *group extend (group*100)
1                117                    118                                        125                 122
2                111                    140                                        161                 159
4                 51                     190                                        141                 187
8                43                      254                                        148                 172
16               40                     243                                        150                 173

* (group*10)-> means inside the code, Group leader will see how many members are in the group who want blocks, so we will satisfy request of all member + will put extra blocks in FSM extra block to extend are = (group*10) --> 10 is just some constant.

Summary:
------------

1. Here with group extend patch, there is no configuration to tell that how many block to extend, so that should be decided by current load in the system (contention on the extension lock).

2. With small multiplier i.e. 10 we can get fairly good improvement compare to base code, but when load is high like record size is 1K, improving the multiplier size giving better results.

* Note: Currently this is POC patch, It has only one group Extend List, so currently can handle only one relation Group extend.

--