Add file-based synchronization to flaky test

[aprantl]

Summary

TestQueues is failing randomly on green dragon and I suspect it is because the enqueued threads haven't executed by the time we expect them.

[JDevlieghere]

Thanks Adrian, looks good.

[labath]

lldb/trunk/packages/Python/lldbsuite/test/macosx/queues/TestQueues.py

132 ↗

(On Diff #179896)

Will this actually help? It could be I'm missing something about how macos queues work, but it seems to me that at this point the process is already stopped, and so it has either managed to create the token files, or it hasn't. Waiting isn't going to make things better.

The way I'd synchronize these things is via barriers. I'd put one pseudo_barrier_wait in place of the touch calls, and then another just before the call to stopper. That way you guarantee that the queues have been initialized even before you hit the stopper breakpoint.

Note that using barriers will require porting this code to (obj)c++ (they use atomics), but that doesn't seem like it would alter the purpose of this test.

[aprantl]

I implemented a poor man's version of that in r350360.

packages/Python/lldbsuite/test/macosx/queues/TestQueues.py

def test_with_python_api(self):
         self.queues_with_libBacktraceRecording()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
+    def remove_token(self, name):
+        for i in range(6):
+            token = name+'.token.%d'%(i+1)
+            if os.path.exists(token):
+                os.remove(token)
+
+    def await_token(self, name):
+        for i in range(6):
+            lldbutil.wait_for_file_on_target(self, name+'.token.%d'%(i+1))
+
     def check_queue_for_valid_queue_id(self, queue):
         self.assertTrue(
             queue.GetQueueID() != 0, "Check queue %s for valid QueueID (got 0x%x)" %
             (queue.GetName(), queue.GetQueueID()))
 
     def check_running_and_pending_items_on_queue(
             self, queue, expected_running, expected_pending):
         self.assertTrue(
def queues(self):
         """Test queues inspection SB APIs without libBacktraceRecording."""
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
         break1 = target.BreakpointCreateByName("stopper", 'a.out')
         self.assertTrue(break1, VALID_BREAKPOINT)
+        self.remove_token(exe)
         process = target.LaunchSimple(
-            None, None, self.get_process_working_directory())
+            [exe+'.token.'], None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
         threads = lldbutil.get_threads_stopped_at_breakpoint(process, break1)
         if len(threads) != 1:
             self.fail("Failed to stop at breakpoint 1.")
+        self.await_token(exe)
 
         queue_submittor_1 = lldb.SBQueue()
         queue_performer_1 = lldb.SBQueue()
         queue_performer_2 = lldb.SBQueue()
         queue_performer_3 = lldb.SBQueue()
         for idx in range(0, process.GetNumQueues()):
             q = process.GetQueueAtIndex(idx)
             if q.GetName() == "com.apple.work_submittor_1":
def queues_with_libBacktraceRecording(self):
         break1 = target.BreakpointCreateByName("stopper", 'a.out')
         self.assertTrue(break1, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         libbtr_path = "/Applications/Xcode.app/Contents/Developer/usr/lib/libBacktraceRecording.dylib"
         if self.getArchitecture() in ['arm', 'arm64', 'arm64e', 'arm64_32', 'armv7', 'armv7k']:
             libbtr_path = "/Developer/usr/lib/libBacktraceRecording.dylib"
 
+        self.remove_token(exe)
         process = target.LaunchSimple(
-            None,
+            [exe+'.token.'],
             [
                 'DYLD_INSERT_LIBRARIES=%s' % (libbtr_path),
                 'DYLD_LIBRARY_PATH=/usr/lib/system/introspection'],
             self.get_process_working_directory())
 
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         threads = lldbutil.get_threads_stopped_at_breakpoint(process, break1)
         if len(threads) != 1:
             self.fail("Failed to stop at breakpoint 1.")
+        self.await_token(exe)
 
         libbtr_module_filespec = lldb.SBFileSpec("libBacktraceRecording.dylib")
         libbtr_module = target.FindModule(libbtr_module_filespec)
         if not libbtr_module.IsValid():
             self.skipTest(
                 "Skipped because libBacktraceRecording.dylib was not loaded into the process.")
 
         self.assertTrue(

packages/Python/lldbsuite/test/macosx/queues/main.c

 #include <stdio.h>
+#include <string.h>
 #include <unistd.h>
 #include <dispatch/dispatch.h>
 #include <pthread.h>
 
 int finished_enqueueing_work = 0;
 
 void
+touch (const char *name, unsigned n)
+{
+  char token[2048];
+  snprintf(token, 2048, "%s%d", name, n);
+  FILE *f = fopen(token, "wx");
+  fputs("\n", f);
+  fflush(f);
+  fclose(f);
+}
+
+void
 doing_the_work_1(void *in)
 {
     while (1)
         sleep (1);
 }
 
 void
 submit_work_1a(void *in)

 void
 stopper ()
 {
     while (1)
         sleep (1);
 }
 
 
-int main ()
+int main (int argc, const char **argv)
 {
     dispatch_queue_t work_submittor_1 = dispatch_queue_create ("com.apple.work_submittor_1", DISPATCH_QUEUE_SERIAL);
     dispatch_queue_t work_submittor_2 = dispatch_queue_create ("com.apple.work_submittor_and_quit_2", DISPATCH_QUEUE_SERIAL);
     dispatch_queue_t work_submittor_3 = dispatch_queue_create ("com.apple.work_submittor_3", DISPATCH_QUEUE_SERIAL);
 
     dispatch_queue_t work_performer_1 = dispatch_queue_create ("com.apple.work_performer_1", DISPATCH_QUEUE_SERIAL);
     dispatch_queue_t work_performer_2 = dispatch_queue_create ("com.apple.work_performer_2", DISPATCH_QUEUE_SERIAL);
 
     dispatch_queue_t work_performer_3 = dispatch_queue_create ("com.apple.work_performer_3", DISPATCH_QUEUE_CONCURRENT);
 
     dispatch_async_f (work_submittor_1, (void*) &work_performer_1, submit_work_1a);
     dispatch_async_f (work_submittor_1, (void*) &work_performer_1, submit_work_1b);
 
     dispatch_async_f (work_submittor_2, (void*) &work_performer_2, submit_work_2);
 
     dispatch_async_f (work_submittor_3, (void*) &work_performer_3, submit_work_3);
 
 
     // Spin up threads with each of the different libdispatch QoS values.
 
     dispatch_async (dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
             pthread_setname_np ("user initiated QoS");
+            touch(argv[1], 1);
             while (1)
                 sleep (10);
                 });
     dispatch_async (dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
             pthread_setname_np ("user interactive QoS");
+            touch(argv[1], 2);
             while (1)
                 sleep (10);
                 });
     dispatch_async (dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0), ^{
             pthread_setname_np ("default QoS");
+            touch(argv[1], 3);
             while (1)
                 sleep (10);
                 });
     dispatch_async (dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
             pthread_setname_np ("utility QoS");
+            touch(argv[1], 4);
             while (1)
                 sleep (10);
                 });
     dispatch_async (dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), ^{
             pthread_setname_np ("background QoS");
+            touch(argv[1], 5);
             while (1)
                 sleep (10);
                 });
     dispatch_async (dispatch_get_global_queue(QOS_CLASS_UNSPECIFIED, 0), ^{
             pthread_setname_np ("unspecified QoS");
+            touch(argv[1], 6);
             while (1)
                 sleep (10);
                 });
 
 
     while (finished_enqueueing_work == 0)
         sleep (1);
     stopper ();
 
 }