diff options
Diffstat (limited to 'gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues')
3 files changed, 545 insertions, 0 deletions
diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/Makefile new file mode 100644 index 00000000000..10495940055 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/Makefile @@ -0,0 +1,3 @@ +C_SOURCES := main.c + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/TestQueues.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/TestQueues.py new file mode 100644 index 00000000000..805ad21a413 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/TestQueues.py @@ -0,0 +1,391 @@ +"""Test queues inspection SB APIs.""" + +from __future__ import print_function + + +import unittest2 +import os +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestQueues(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipUnlessDarwin + @add_test_categories(['pyapi']) + def test_with_python_api_queues(self): + """Test queues inspection SB APIs.""" + self.build() + self.queues() + + @skipUnlessDarwin + @add_test_categories(['pyapi']) + def test_with_python_api_queues_with_backtrace(self): + """Test queues inspection SB APIs.""" + self.build() + 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 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( + queue.GetNumPendingItems() == expected_pending, + "queue %s should have %d pending items, instead has %d pending items" % + (queue.GetName(), + expected_pending, + (queue.GetNumPendingItems()))) + self.assertTrue( + queue.GetNumRunningItems() == expected_running, + "queue %s should have %d running items, instead has %d running items" % + (queue.GetName(), + expected_running, + (queue.GetNumRunningItems()))) + + def describe_threads(self): + desc = [] + for x in self.inferior_process: + id = x.GetIndexID() + reason_str = lldbutil.stop_reason_to_str(x.GetStopReason()) + + location = "\t".join([lldbutil.get_description( + x.GetFrameAtIndex(i)) for i in range(x.GetNumFrames())]) + desc.append( + "thread %d: %s (queue id: %s) at\n\t%s" % + (id, reason_str, x.GetQueueID(), location)) + print('\n'.join(desc)) + + def check_number_of_threads_owned_by_queue(self, queue, number_threads): + if (queue.GetNumThreads() != number_threads): + self.describe_threads() + + self.assertTrue( + queue.GetNumThreads() == number_threads, + "queue %s should have %d thread executing, but has %d" % + (queue.GetName(), + number_threads, + queue.GetNumThreads())) + + def check_queue_kind(self, queue, kind): + expected_kind_string = "Unknown" + if kind == lldb.eQueueKindSerial: + expected_kind_string = "Serial queue" + if kind == lldb.eQueueKindConcurrent: + expected_kind_string = "Concurrent queue" + actual_kind_string = "Unknown" + if queue.GetKind() == lldb.eQueueKindSerial: + actual_kind_string = "Serial queue" + if queue.GetKind() == lldb.eQueueKindConcurrent: + actual_kind_string = "Concurrent queue" + self.assertTrue( + queue.GetKind() == kind, + "queue %s is expected to be a %s but it is actually a %s" % + (queue.GetName(), + expected_kind_string, + actual_kind_string)) + + def check_queues_threads_match_queue(self, queue): + for idx in range(0, queue.GetNumThreads()): + t = queue.GetThreadAtIndex(idx) + self.assertTrue( + t.IsValid(), "Queue %s's thread #%d must be valid" % + (queue.GetName(), idx)) + self.assertTrue( + t.GetQueueID() == queue.GetQueueID(), + "Queue %s has a QueueID of %d but its thread #%d has a QueueID of %d" % + (queue.GetName(), + queue.GetQueueID(), + idx, + t.GetQueueID())) + self.assertTrue( + t.GetQueueName() == queue.GetName(), + "Queue %s has a QueueName of %s but its thread #%d has a QueueName of %s" % + (queue.GetName(), + queue.GetName(), + idx, + t.GetQueueName())) + self.assertTrue( + t.GetQueue().GetQueueID() == queue.GetQueueID(), + "Thread #%d's Queue's QueueID of %d is not the same as the QueueID of its owning queue %d" % + (idx, + t.GetQueue().GetQueueID(), + queue.GetQueueID())) + + 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) + process = target.LaunchSimple( + [], 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.inferior_process = process + + 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": + queue_submittor_1 = q + if q.GetName() == "com.apple.work_performer_1": + queue_performer_1 = q + if q.GetName() == "com.apple.work_performer_2": + queue_performer_2 = q + if q.GetName() == "com.apple.work_performer_3": + queue_performer_3 = q + + self.assertTrue( + queue_submittor_1.IsValid() and queue_performer_1.IsValid() and queue_performer_2.IsValid() and queue_performer_3.IsValid(), + "Got all four expected queues: %s %s %s %s" % + (queue_submittor_1.IsValid(), + queue_performer_1.IsValid(), + queue_performer_2.IsValid(), + queue_performer_3.IsValid())) + + self.check_queue_for_valid_queue_id(queue_submittor_1) + self.check_queue_for_valid_queue_id(queue_performer_1) + self.check_queue_for_valid_queue_id(queue_performer_2) + self.check_queue_for_valid_queue_id(queue_performer_3) + + self.check_number_of_threads_owned_by_queue(queue_submittor_1, 1) + self.check_number_of_threads_owned_by_queue(queue_performer_1, 1) + self.check_number_of_threads_owned_by_queue(queue_performer_2, 1) + self.check_number_of_threads_owned_by_queue(queue_performer_3, 4) + + self.check_queue_kind(queue_submittor_1, lldb.eQueueKindSerial) + self.check_queue_kind(queue_performer_1, lldb.eQueueKindSerial) + self.check_queue_kind(queue_performer_2, lldb.eQueueKindSerial) + self.check_queue_kind(queue_performer_3, lldb.eQueueKindConcurrent) + + self.check_queues_threads_match_queue(queue_submittor_1) + self.check_queues_threads_match_queue(queue_performer_1) + self.check_queues_threads_match_queue(queue_performer_2) + self.check_queues_threads_match_queue(queue_performer_3) + + # We have threads running with all the different dispatch QoS service + # levels - find those threads and check that we can get the correct + # QoS name for each of them. + + user_initiated_thread = lldb.SBThread() + user_interactive_thread = lldb.SBThread() + utility_thread = lldb.SBThread() + unspecified_thread = lldb.SBThread() + background_thread = lldb.SBThread() + for th in process.threads: + if th.GetName() == "user initiated QoS": + user_initiated_thread = th + if th.GetName() == "user interactive QoS": + user_interactive_thread = th + if th.GetName() == "utility QoS": + utility_thread = th + if th.GetName() == "unspecified QoS": + unspecified_thread = th + if th.GetName() == "background QoS": + background_thread = th + + self.assertTrue( + user_initiated_thread.IsValid(), + "Found user initiated QoS thread") + self.assertTrue( + user_interactive_thread.IsValid(), + "Found user interactive QoS thread") + self.assertTrue(utility_thread.IsValid(), "Found utility QoS thread") + self.assertTrue( + unspecified_thread.IsValid(), + "Found unspecified QoS thread") + self.assertTrue( + background_thread.IsValid(), + "Found background QoS thread") + + stream = lldb.SBStream() + self.assertTrue( + user_initiated_thread.GetInfoItemByPathAsString( + "requested_qos.printable_name", + stream), + "Get QoS printable string for user initiated QoS thread") + self.assertTrue( + stream.GetData() == "User Initiated", + "user initiated QoS thread name is valid") + stream.Clear() + self.assertTrue( + user_interactive_thread.GetInfoItemByPathAsString( + "requested_qos.printable_name", + stream), + "Get QoS printable string for user interactive QoS thread") + self.assertTrue( + stream.GetData() == "User Interactive", + "user interactive QoS thread name is valid") + stream.Clear() + self.assertTrue( + utility_thread.GetInfoItemByPathAsString( + "requested_qos.printable_name", + stream), + "Get QoS printable string for utility QoS thread") + self.assertTrue( + stream.GetData() == "Utility", + "utility QoS thread name is valid") + stream.Clear() + self.assertTrue( + unspecified_thread.GetInfoItemByPathAsString( + "requested_qos.printable_name", + stream), + "Get QoS printable string for unspecified QoS thread") + qosName = stream.GetData() + self.assertTrue( + qosName == "User Initiated" or qosName == "Default", + "unspecified QoS thread name is valid") + stream.Clear() + self.assertTrue( + background_thread.GetInfoItemByPathAsString( + "requested_qos.printable_name", + stream), + "Get QoS printable string for background QoS thread") + self.assertTrue( + stream.GetData() == "Background", + "background QoS thread name is valid") + + @skipIfDarwin # rdar://50379398 + def queues_with_libBacktraceRecording(self): + """Test queues inspection SB APIs with libBacktraceRecording present.""" + exe = self.getBuildArtifact("a.out") + + if not os.path.isfile( + '/Applications/Xcode.app/Contents/Developer/usr/lib/libBacktraceRecording.dylib'): + self.skipTest( + "Skipped because libBacktraceRecording.dylib was present on the system.") + + if not os.path.isfile( + '/usr/lib/system/introspection/libdispatch.dylib'): + self.skipTest( + "Skipped because introspection libdispatch dylib is not present.") + + 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) + + # 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" + + process = target.LaunchSimple( + [], + [ + '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.inferior_process = process + + 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( + process.GetNumQueues() >= 4, + "Found the correct number of queues.") + + 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 "LLDB_COMMAND_TRACE" in os.environ: + print("Queue with id %s has name %s" % (q.GetQueueID(), q.GetName())) + if q.GetName() == "com.apple.work_submittor_1": + queue_submittor_1 = q + if q.GetName() == "com.apple.work_performer_1": + queue_performer_1 = q + if q.GetName() == "com.apple.work_performer_2": + queue_performer_2 = q + if q.GetName() == "com.apple.work_performer_3": + queue_performer_3 = q + if q.GetName() == "com.apple.main-thread": + if q.GetNumThreads() == 0: + print("Cannot get thread <=> queue associations") + return + + self.assertTrue( + queue_submittor_1.IsValid() and queue_performer_1.IsValid() and queue_performer_2.IsValid() and queue_performer_3.IsValid(), + "Got all four expected queues: %s %s %s %s" % + (queue_submittor_1.IsValid(), + queue_performer_1.IsValid(), + queue_performer_2.IsValid(), + queue_performer_3.IsValid())) + + self.check_queue_for_valid_queue_id(queue_submittor_1) + self.check_queue_for_valid_queue_id(queue_performer_1) + self.check_queue_for_valid_queue_id(queue_performer_2) + self.check_queue_for_valid_queue_id(queue_performer_3) + + self.check_running_and_pending_items_on_queue(queue_submittor_1, 1, 0) + self.check_running_and_pending_items_on_queue(queue_performer_1, 1, 3) + self.check_running_and_pending_items_on_queue( + queue_performer_2, 1, 9999) + self.check_running_and_pending_items_on_queue(queue_performer_3, 4, 0) + + self.check_number_of_threads_owned_by_queue(queue_submittor_1, 1) + self.check_number_of_threads_owned_by_queue(queue_performer_1, 1) + self.check_number_of_threads_owned_by_queue(queue_performer_2, 1) + self.check_number_of_threads_owned_by_queue(queue_performer_3, 4) + + self.check_queue_kind(queue_submittor_1, lldb.eQueueKindSerial) + self.check_queue_kind(queue_performer_1, lldb.eQueueKindSerial) + self.check_queue_kind(queue_performer_2, lldb.eQueueKindSerial) + self.check_queue_kind(queue_performer_3, lldb.eQueueKindConcurrent) + + self.check_queues_threads_match_queue(queue_submittor_1) + self.check_queues_threads_match_queue(queue_performer_1) + self.check_queues_threads_match_queue(queue_performer_2) + self.check_queues_threads_match_queue(queue_performer_3) + + self.assertTrue(queue_performer_2.GetPendingItemAtIndex( + 0).IsValid(), "queue 2's pending item #0 is valid") + self.assertTrue(queue_performer_2.GetPendingItemAtIndex(0).GetAddress().GetSymbol( + ).GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2") + self.assertTrue( + queue_performer_2.GetNumPendingItems() == 9999, + "verify that queue 2 still has 9999 pending items") + self.assertTrue(queue_performer_2.GetPendingItemAtIndex( + 9998).IsValid(), "queue 2's pending item #9998 is valid") + self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9998).GetAddress().GetSymbol( + ).GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2") + self.assertTrue(queue_performer_2.GetPendingItemAtIndex( + 9999).IsValid() == False, "queue 2's pending item #9999 is invalid") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/main.c b/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/main.c new file mode 100644 index 00000000000..3978b92bff1 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/macosx/queues/main.c @@ -0,0 +1,151 @@ +#include <stdatomic.h> +#include <string.h> +#include <unistd.h> +#include <dispatch/dispatch.h> +#include <pthread.h> + +atomic_int finished_enqueueing_work = 0; +atomic_int thread_count = 0; + +void +doing_the_work_1(void *in) +{ + // This is only counted once because the first job in the queue + // starves all the others. + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (1); +} + +void +submit_work_1a(void *in) +{ + dispatch_queue_t *work_performer_1 = (dispatch_queue_t*) in; + dispatch_async_f (*work_performer_1, NULL, doing_the_work_1); + dispatch_async_f (*work_performer_1, NULL, doing_the_work_1); +} + +void +submit_work_1b(void *in) +{ + dispatch_queue_t *work_performer_1 = (dispatch_queue_t*) in; + dispatch_async_f (*work_performer_1, NULL, doing_the_work_1); + dispatch_async_f (*work_performer_1, NULL, doing_the_work_1); + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (1); +} + +void +doing_the_work_2(void *in) +{ + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (1); +} + +void +submit_work_2(void *in) +{ + dispatch_queue_t *work_performer_2 = (dispatch_queue_t*) in; + int i = 0; + while (i++ < 5000) + { + dispatch_async_f (*work_performer_2, NULL, doing_the_work_2); + dispatch_async_f (*work_performer_2, NULL, doing_the_work_2); + } + atomic_fetch_add(&finished_enqueueing_work, 1); +} + + +void +doing_the_work_3(void *in) +{ + // This counts four times, since the queue is marked as CONCURRENT. + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (1); +} + +void +submit_work_3(void *in) +{ + dispatch_queue_t *work_performer_3 = (dispatch_queue_t*) in; + dispatch_async_f (*work_performer_3, NULL, doing_the_work_3); + dispatch_async_f (*work_performer_3, NULL, doing_the_work_3); + dispatch_async_f (*work_performer_3, NULL, doing_the_work_3); + dispatch_async_f (*work_performer_3, NULL, doing_the_work_3); +} + + +void +stopper () +{ + while (1) + sleep (1); +} + + +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"); + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (10); + }); + dispatch_async (dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{ + pthread_setname_np ("user interactive QoS"); + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (10); + }); + dispatch_async (dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0), ^{ + pthread_setname_np ("default QoS"); + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (10); + }); + dispatch_async (dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{ + pthread_setname_np ("utility QoS"); + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (10); + }); + dispatch_async (dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), ^{ + pthread_setname_np ("background QoS"); + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (10); + }); + dispatch_async (dispatch_get_global_queue(QOS_CLASS_UNSPECIFIED, 0), ^{ + pthread_setname_np ("unspecified QoS"); + atomic_fetch_add(&thread_count, 1); + while (1) + sleep (10); + }); + + // Unfortunately there is no pthread_barrier on darwin. + while ((atomic_load(&thread_count) < 13) || (finished_enqueueing_work == 0)) + sleep (1); + + stopper (); +} |