Ideas for improving Concurrency Tests

Ideas for improving Concurrency testing                              

1. Synchronization points in server code - To have better control for concurrency testing, define synchronization points in server code which can be used as follows:
                                   
                                    heap_truncate(..)
                                    {
                                        ....
                                   
                                    SYNC_POINT(procid,'before_heap_open')
                                    rel = heap_open(rid, AccessExclusiveLock);
                                    relations = lappend(relations, rel);
                                    }
                               
                                    exec_simple_query(..)
                                    {
                                        ...                                    
                                            finish_xact_command();
                                            SYNC_POINT(procid,'finish_xact_command')

                                        /*
                                         * If there were no parsetrees, return EmptyQueryResponse message.
                                         */
                                         if (!parsetree_list)
                                            NullCommand(dest);
                                         ...
                                     }  
                                         

                                   
                                    When code reaches at sync point it can either emit a signal
                                    or wait for a signal
                                   
                                    Signal
                                    A value of a shared memory variable that will be interpretted by different
                                    SYNC POINTS based on it's value.
                                   
                                    Emit a signal
                                    Assign the value (the signal) to the shared memory variable ("set a flag") and
                                    broadcast a global condition to wake those waiting for a signal.
                                   
                                    Wait for a signal
                                    Loop over waiting for the global condition until the global value matches
                                    the wait-for signal

                       To activate Synchronization points appropriate actions can be set.
                       For Example,
                            SET SYNC_POINT = 'before_heap_open WAIT_FOR commit';
                            SET SYNC_POINT = 'after_finish_xact_command SIGNAL commit';
                           
                       This above commands can activate the synchronization points named 'before_heap_open'
                       and 'after_finish_xact_command'.
                       
                       
                       session "s1"
                       step s11  {SET SYNC_POINT = 'before_heap_open WAIT_FOR commit';}
                       step s12  {Truncate tbl;}
                       session "s2"
                       step s21  {SET SYNC_POINT = 'after_finish_xact_command SIGNAL commit';}
                       step s22  {Insert into tbl values(1);}
                       
                       The first activation requests the synchronization point to wait for
                       another backend to emit the signal 'commit', and second activation requests
                       the synchronization point to emit the signal 'commit', when the process's execution runs through
                       the synchronization point.
                       
                       Above defined test will allow Truncate table to wait for Insert to finish

2. Enhance Isolation Framework - Currently, at most one step can be waiting at a time. Enhance Concurrency test framework (isolation tester) to make multiple sessions wait and then allow to release it serially.

                                                  This might help in generating complex dead lock scenario's.

Above ideas could be useful to improve concurrency testing and can also be helpful to generate test cases for some of the complicated bugs for which there is no direct test.

This work is not a patch for 9.3, I just wanted an initial feedback.

Feedback/Suggestions?

Reference : http://dev.mysql.com/doc/internals/en/debug-sync-facility.html

With Regards,

Amit Kapila.