nilm
/
nilmdb
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 64 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
768 Commits
3 Branches
3.2 MiB
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
nilmdb/tests/test_threadsafety.py

test_threadsafety.py 2.7 KiB
Raw Permalink Normal View History

Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
​
​
​
​
​
​
​
​
​
​
​
​
Improve serializer_proxy and verify_thread_proxy These functions can now take an object or a type (class). If given an object, they will wrap subsequent calls to that object. If given a type, they will return an object that can be instantiated to create a new object, and all calls including __init__ will be covered by the serialization or thread verification.
10 years ago
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
​
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
​
​
​
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
​
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
​
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
​
​
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
​
​
​
​
​
​
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
​
​
​
​
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
​
​
​
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
​
​
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
Improve serializer_proxy and verify_thread_proxy These functions can now take an object or a type (class). If given an object, they will wrap subsequent calls to that object. If given a type, they will return an object that can be instantiated to create a new object, and all calls including __init__ will be covered by the serialization or thread verification.
10 years ago
Add some thread safety tests We don't actually use nilmdb.utils.threadsafety.verify_proxy in the main NilmDB code, but it's useful for finding errors. It found an issue with __getattr__ in SerializerProxy which (1) can't be avoided? (2) is now commented in the code (3) shouldn't matter in real use
3 years ago
​
​
​
​
​
​
​
Improve serializer_proxy and verify_thread_proxy These functions can now take an object or a type (class). If given an object, they will wrap subsequent calls to that object. If given a type, they will return an object that can be instantiated to create a new object, and all calls including __init__ will be covered by the serialization or thread verification.
10 years ago
​
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
10 years ago
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
10 years ago
​
​
​
​
​
 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596 
  1. import nilmdb

  2. from nilmdb.utils.printf import *

  3. 

  4. import nose

  5. from nose.tools import *

  6. from nose.tools import assert_raises

  7. 

  8. from testutil.helpers import *

  9. import threading

  10. 

  11. class Thread(threading.Thread):

  12.     def __init__(self, target):

  13.         self.target = target

  14.         threading.Thread.__init__(self)

  15. 

  16.     def run(self):

  17.         try:

  18.             self.target()

  19.         except AssertionError as e:

  20.             self.error = e

  21.         else:

  22.             self.error = None

  23. 

  24. class Test():

  25.     def __init__(self):

  26.         self.test = 1234

  27. 

  28.     @classmethod

  29.     def asdf(cls):

  30.         pass

  31. 

  32.     def foo(self, exception = False, reenter = False):

  33.         if exception:

  34.             raise Exception()

  35.         self.bar(reenter)

  36. 

  37.     def bar(self, reenter):

  38.         if reenter:

  39.             self.foo()

  40.         return 123

  41. 

  42.     def baz_threaded(self, target):

  43.         t = Thread(target)

  44.         t.start()

  45.         t.join()

  46.         return t

  47. 

  48.     def baz(self, target):

  49.         target()

  50. 

  51. class TestThreadSafety(object):

  52.     def tryit(self, c, threading_ok, concurrent_ok):

  53.         eq_(c.test, 1234)

  54.         c.foo()

  55.         t = Thread(c.foo)

  56.         t.start()

  57.         t.join()

  58.         if threading_ok and t.error:

  59.             raise Exception("got unexpected error: " + str(t.error))

  60.         if not threading_ok and not t.error:

  61.             raise Exception("failed to get expected error")

  62.         try:

  63.             c.baz(c.foo)

  64.         except AssertionError as e:

  65.             if concurrent_ok:

  66.                 raise Exception("got unexpected error: " + str(e))

  67.         else:

  68.             if not concurrent_ok:

  69.                 raise Exception("failed to get expected error")

  70.         t = c.baz_threaded(c.foo)

  71.         if (concurrent_ok and threading_ok) and t.error:

  72.             raise Exception("got unexpected error: " + str(t.error))

  73.         if not (concurrent_ok and threading_ok) and not t.error:

  74.             raise Exception("failed to get expected error")

  75. 

  76.     def test(self):

  77.         proxy = nilmdb.utils.threadsafety.verify_proxy

  78.         self.tryit(Test(), True, True)

  79.         self.tryit(proxy(Test(), True, True), False, False)

  80.         self.tryit(proxy(Test(), True, False), False, True)

  81.         self.tryit(proxy(Test(), False, True), True, False)

  82.         self.tryit(proxy(Test(), False, False), True, True)

  83.         self.tryit(proxy(Test, True, True)(), False, False)

  84.         self.tryit(proxy(Test, True, False)(), False, True)

  85.         self.tryit(proxy(Test, False, True)(), True, False)

  86.         self.tryit(proxy(Test, False, False)(), True, True)

  87. 

  88.         proxy(proxy(proxy(Test))()).foo()

  89. 

  90.         c = proxy(Test())

  91.         c.foo()

  92.         try:

  93.             c.foo(exception = True)

  94.         except Exception:

  95.             pass

  96.         c.foo()