lldb/test/API/functionalities/thread/concurrent_events/TestConcurrentManyBreakpoints.py


import unittest2

from lldbsuite.test.decorators import *
from lldbsuite.test.concurrent_base import ConcurrentEventsBase
from lldbsuite.test.lldbtest import TestBase


@skipIfWindows
class ConcurrentManyBreakpoints(ConcurrentEventsBase):

    mydir = ConcurrentEventsBase.compute_mydir(__file__)

    # Atomic sequences are not supported yet for MIPS in LLDB.
    @skipIf(triple='^mips')
    @skipIfOutOfTreeDebugserver
    @expectedFailureAll(archs=["aarch64"], oslist=["freebsd"],
                        bugnumber="llvm.org/pr49433")
    def test(self):
        """Test 100 breakpoints from 100 threads."""
        self.build()
        self.do_thread_actions(num_breakpoint_threads=100)
Breakup TestConcurrentEvents.py into separate test subdirs per test method This change breaks up the monolithic TestConcurrentEvents.py into a separate subdir per test method. This allows them to run concurrently, reduces the chance of a timeout occurring during normal operation, and allows us to home in on any test methods that may be locking up. This is step one in the process of squashing timeouts in these test methods. The reason for breaking each test method into its own file is to make it very clear to us if there are a subset of the tests that do in fact lock up frequently. This will limit how much hunting we need to do to recreate it. The reason for putting each file in a separate subdirectory is so that our concurrent test runner can run multiple test files at the same time. The unit of serialization in the LLDB test suite is the test directory, so moving them into separate directories enables the test runner to do more at the same time. This change introduces usage of VPATH from gnu make. I use that to facilitate keeping a single copy of the main.cpp in the parent concurrent_events directory. Initially I had tried specifying the source file as ../main.cpp, but our current makefile rules get confused by that and then also build the output into the parent directory, which defeats the ability to run each of the test methods concurrently. In the event that not all systems support VPATH, I can do a bit of surgery on the Makefile rules and attempt to make it smarter with regards to relative paths to source files used in the build. llvm-svn: 276478 2016-07-22 21:50:55 +00:00
			`import unittest2`

			`from lldbsuite.test.decorators import *`
			`from lldbsuite.test.concurrent_base import ConcurrentEventsBase`
			`from lldbsuite.test.lldbtest import TestBase`


			`@skipIfWindows`
			`class ConcurrentManyBreakpoints(ConcurrentEventsBase):`

			`mydir = ConcurrentEventsBase.compute_mydir(__file__)`

			`# Atomic sequences are not supported yet for MIPS in LLDB.`
[LLDB][MIPS] Skip some test case which were causing LLDB to go into infinite loop Reviewers: clayborg, labath Subscribers: jaydeep, bhushan, slthakur, llvm-commits Differential Revision: https://reviews.llvm.org/D24549 llvm-svn: 283732 2016-10-10 10:02:09 +00:00			`@skipIf(triple='^mips')`
[CMake] Copy over the system debugserver when using LLDB_USE_SYSTEM_DEBUGSERVER r366433 broke support for the system debugserver. Although the change was well-intended, it (presumably) unintentionally removed the logic to copy over the debugserver. As a result, even with LLDB_USE_SYSTEM_DEBUGSERVER enabled, we ended up building, signing and using the just-built debugserver. This patch partially recovers the old behavior: when LLDB_USE_SYSTEM_DEBUGSERVER is set we don't build debugserver and just copy over the system one. Differential revision: https://reviews.llvm.org/D67991 llvm-svn: 372786 2019-09-24 22:39:04 +00:00			`@skipIfOutOfTreeDebugserver`
[lldb] [test] Update XFAILs for FreeBSD/aarch64 2021-03-03 15:57:51 +01:00			`@expectedFailureAll(archs=["aarch64"], oslist=["freebsd"],`
			`bugnumber="llvm.org/pr49433")`
Use shorter names in TestConcurrentEvents tests Otherwise, they tend to generate filename too long errors. They already contain the same test name in the directory, file, and class names, so no information is really lost here. llvm-svn: 284987 2016-10-24 16:20:43 +00:00			`def test(self):`
Breakup TestConcurrentEvents.py into separate test subdirs per test method This change breaks up the monolithic TestConcurrentEvents.py into a separate subdir per test method. This allows them to run concurrently, reduces the chance of a timeout occurring during normal operation, and allows us to home in on any test methods that may be locking up. This is step one in the process of squashing timeouts in these test methods. The reason for breaking each test method into its own file is to make it very clear to us if there are a subset of the tests that do in fact lock up frequently. This will limit how much hunting we need to do to recreate it. The reason for putting each file in a separate subdirectory is so that our concurrent test runner can run multiple test files at the same time. The unit of serialization in the LLDB test suite is the test directory, so moving them into separate directories enables the test runner to do more at the same time. This change introduces usage of VPATH from gnu make. I use that to facilitate keeping a single copy of the main.cpp in the parent concurrent_events directory. Initially I had tried specifying the source file as ../main.cpp, but our current makefile rules get confused by that and then also build the output into the parent directory, which defeats the ability to run each of the test methods concurrently. In the event that not all systems support VPATH, I can do a bit of surgery on the Makefile rules and attempt to make it smarter with regards to relative paths to source files used in the build. llvm-svn: 276478 2016-07-22 21:50:55 +00:00			`"""Test 100 breakpoints from 100 threads."""`
[lldb] Remove lldbtest.getBuildFlags It was being used only in some very old tests (which pass even without it) and its implementation is highly questionable. These days we have different mechanisms for requesting a build with a particular kind of c++ library (USE_LIB(STD)CPP in the makefile). 2021-12-30 11:22:26 +01:00			`self.build()`
Breakup TestConcurrentEvents.py into separate test subdirs per test method This change breaks up the monolithic TestConcurrentEvents.py into a separate subdir per test method. This allows them to run concurrently, reduces the chance of a timeout occurring during normal operation, and allows us to home in on any test methods that may be locking up. This is step one in the process of squashing timeouts in these test methods. The reason for breaking each test method into its own file is to make it very clear to us if there are a subset of the tests that do in fact lock up frequently. This will limit how much hunting we need to do to recreate it. The reason for putting each file in a separate subdirectory is so that our concurrent test runner can run multiple test files at the same time. The unit of serialization in the LLDB test suite is the test directory, so moving them into separate directories enables the test runner to do more at the same time. This change introduces usage of VPATH from gnu make. I use that to facilitate keeping a single copy of the main.cpp in the parent concurrent_events directory. Initially I had tried specifying the source file as ../main.cpp, but our current makefile rules get confused by that and then also build the output into the parent directory, which defeats the ability to run each of the test methods concurrently. In the event that not all systems support VPATH, I can do a bit of surgery on the Makefile rules and attempt to make it smarter with regards to relative paths to source files used in the build. llvm-svn: 276478 2016-07-22 21:50:55 +00:00			`self.do_thread_actions(num_breakpoint_threads=100)`