def test_complex_alternative_passing(self): Complex = Alternative("Complex", A={ 'a': str, 'b': int }, B={ 'a': str, 'c': int }, C={ 'a': str, 'd': lambda: Complex }) c = Complex.A(a="hi", b=20) c2 = Complex.C(a="hi", d=c) @Compiled def f(c: Complex): y = c return y self.assertEqual(f(c), c) self.assertEqual(f(c2), c2) self.assertEqual(_types.refcount(c), 2) self.assertEqual(_types.refcount(c2), 1)
def test_tuple_of_float(self): def f(x: TupleOf(float), y: TupleOf(float)) -> float: j = 0 res = 0.0 i = 0 while j < len(y): i = 0 while i < len(x): res = res + x[i] * y[j] i = i + 1 j = j + 1 return res aTupleOfFloat = TupleOf(float)(list(range(1000))) aTupleOfFloat2 = TupleOf(float)(list(range(1000))) self.assertEqual(_types.refcount(aTupleOfFloat), 1) t_py, t_fast = self.checkFunction(f, [(aTupleOfFloat, aTupleOfFloat2)]) self.assertEqual(_types.refcount(aTupleOfFloat), 1) # I get around 150x self.assertTrue(t_py / t_fast > 50.0) print(t_py / t_fast, " speedup")
def test_serialize_listof(self): T = ListOf(int) aList = T() aPopulatedList = T([1, 2, 3]) self.assertEqual(aList, deserialize(T, serialize(T, aList))) self.assertEqual(refcount(deserialize(T, serialize(T, aList))), 1) self.assertEqual(aPopulatedList, deserialize(T, serialize(T, aPopulatedList))) self.assertEqual(refcount(deserialize(T, serialize(T, aPopulatedList))), 1)
def test_tuple_of_adding(self): T = TupleOf(int) @Compiled def f(x: T, y: T) -> T: return x + y t1 = T((1, 2, 3)) t2 = T((3, 4)) res = f(t1, t2) self.assertEqual(_types.refcount(res), 1) self.assertEqual(_types.refcount(t1), 1) self.assertEqual(_types.refcount(t2), 1) self.assertEqual(res, t1 + t2)
def test_tuple_refcounting(self): @Function def f(x: TupleOf(int), y: TupleOf(int)) -> TupleOf(int): return x for compileIt in [False, True]: if compileIt: Runtime.singleton().compile(f) intTup = TupleOf(int)(list(range(1000))) self.assertEqual(_types.refcount(intTup), 1) res = f(intTup, intTup) self.assertEqual(_types.refcount(intTup), 2) res = None # noqa: F841 self.assertEqual(_types.refcount(intTup), 1)
def test_list_refcounting(self): @TypedFunction def f(x: ListOf(int), y: ListOf(int)) -> ListOf(int): return x for compileIt in [False, True]: if compileIt: Runtime.singleton().compile(f) intTup = ListOf(int)(list(range(1000))) self.assertEqual(_types.refcount(intTup), 1) res = f(intTup, intTup) self.assertEqual(_types.refcount(intTup), 2) res = None self.assertEqual(_types.refcount(intTup), 1)
def test_const_dict_copying(self): for dtype in dictTypes: @Compiled def copyInOut(x: dtype): y = x return x aDict = makeSomeValues(dtype) self.assertEqual(copyInOut(aDict), aDict) self.assertEqual(_types.refcount(aDict), 1)
def test_list_assign(self): @Compiled def f(x: ListOf(int)) -> ListOf(int): y = x return y t = ListOf(int)((1, 2, 3)) self.assertEqual(f(t), t) self.assertEqual(_types.refcount(t), 1)
def test_tuple_assign(self): @Compiled def f(x: TupleOf(int)) -> TupleOf(int): y = x return y t = TupleOf(int)((1, 2, 3)) self.assertEqual(f(t), t) self.assertEqual(_types.refcount(t), 1)
def test_one_of_with_refcounts(self): @Compiled def f(x: OneOf(None, TupleOf(int))) -> OneOf(None, TupleOf(int)): y = x return y self.assertIs(f(None), None) aTup = TupleOf(int)((1, 2, 3)) self.assertEqual(f(aTup), aTup) self.assertEqual(_types.refcount(aTup), 1)
def test_list_resize(self): l = ListOf(TupleOf(int))() l.resize(10) self.assertEqual(l.reserved(), 10) self.assertEqual(len(l), 10) emptyTup = TupleOf(int)() aTup = TupleOf(int)((1,2,3)) self.assertEqual(list(l), [emptyTup] * 10) l.resize(20, aTup) self.assertEqual(list(l), [emptyTup] * 10 + [aTup] * 10) self.assertEqual(_types.refcount(aTup), 11) self.assertEqual(l.pop(15), aTup) self.assertEqual(l.pop(5), emptyTup) self.assertEqual(_types.refcount(aTup), 10) l.resize(15) with self.assertRaises(IndexError): l.pop(100) self.assertEqual(_types.refcount(aTup), 7) #6 in the list because we popped at '5' l.pop() self.assertEqual(_types.refcount(aTup), 6) #this pops one of the empty tuples l.pop(-10) self.assertEqual(_types.refcount(aTup), 6) l.clear() self.assertEqual(len(l), 0)
def refcountsTest(self, instance): typeOfInstance = type(instance) @Compiled def rapidlyIncAndDecref(x: typeOfInstance): _ = x for _1 in range(1000000): _ = x return x thread_apply(rapidlyIncAndDecref, [(instance,)] * 10) self.assertEqual(_types.refcount(instance), 1)
def test_tuple_of_tuple_refcounting(self): T = TupleOf(int) TT = TupleOf(T) @Compiled def f(x: TT) -> TT: return x + x + x t1 = T((1, 2, 3)) t2 = T((4, 5, 5)) aTT = TT((t1, t2)) fRes = f(aTT) self.assertEqual(fRes, aTT + aTT + aTT) self.assertEqual(_types.refcount(aTT), 1) self.assertEqual(_types.refcount(fRes), 1) fRes = None aTT = None self.assertEqual(_types.refcount(t1), 1)
def test_class_set_attribute(self): a = AClass() aTupleOfInt = TupleOf(int)((1, 2, 3)) @Compiled def setX(a: AClass, x: int) -> None: a.x = x @Compiled def setY(a: AClass, y: float) -> None: a.y = y @Compiled def setZ(a: AClass, z: TupleOf(int)) -> None: a.z = z setX(a, 20) setY(a, 20.5) setZ(a, aTupleOfInt) self.assertEqual(a.x, 20) self.assertEqual(a.y, 20.5) self.assertEqual(a.z, aTupleOfInt) self.assertEqual(_types.refcount(aTupleOfInt), 2) a.z = (1, 2, 3, 4) self.assertEqual(_types.refcount(aTupleOfInt), 1) a.z = aTupleOfInt self.assertEqual(_types.refcount(aTupleOfInt), 2) a = None self.assertEqual(_types.refcount(aTupleOfInt), 1)
def test_list_resize(self): T = ListOf(TupleOf(int)) aTup = TupleOf(int)((1, 2, 3)) @Compiled def f(x: T, y: TupleOf(int)): x.resize(len(x) + 10, y) aList = T() aList.resize(10) f(aList, aTup) self.assertEqual(_types.refcount(aTup), 11)
def test_named_tuple_assignment_refcounting(self): class C(Class): x = Member(int) NT = NamedTuple(c=C) @Compiled def f(x: NT): y = x return y.c c = C(x=20) res = f(NT(c=c)) self.assertEqual(res.x, 20) self.assertEqual(_types.refcount(res), 2)
def test_serialize_classes(self): class AClass(Class): x = Member(int) y = Member(float) T = Tuple(AClass, AClass) a = AClass(x=10, y=20.0) a2, a2_copy = deserialize(T, serialize(T, (a, a))) self.assertEqual(a2.x, 10) a2.x = 300 self.assertEqual(a2_copy.x, 300) a2_copy = None self.assertEqual(refcount(a2), 1)
def test_string_split(self): @Compiled def c_split(s: str, sep: str, max: int) -> ListOf(str): r = ListOf(str)() s.split(r, s, sep, max) return r @Compiled def c_split_2(s: str) -> ListOf(str): r = ListOf(str)() s.split(r, s) return r @Compiled def c_split_3(s: str, sep: str) -> ListOf(str): r = ListOf(str)() s.split(r, s, sep) return r @Compiled def c_split_3max(s: str, max: int) -> ListOf(str): r = ListOf(str)() s.split(r, s, max) return r @Compiled def c_split_initialized(s: str, lst: ListOf(str)) -> ListOf(str): r = ListOf(str)(lst) s.split(r, s) return r # unexpected standard behavior: # " abc ".split(maxsplit=0) = "abc " *** not "abc" nor " abc " *** split_strings = [ " abc ", "ahjdfashjkdfsj ksdjkhsfhjdkf", "ahjdfashjkdfsj ksdjkhsfhjdkf" * 100, "", "a", " one two three \tfour \n\nfive\r\rsix\n", " one two three \tfour \n\nfive\r\rsix\n" * 100 ] for s in split_strings: result = callOrExceptNoType(c_split_2, s) if result[0] == "Normal": self.assertEqual(_types.refcount(result[1]), 1) baseline = callOrExceptNoType(lambda: s.split()) self.assertEqual(result, baseline, f"{s} -> {result}") result = callOrExceptNoType(c_split_initialized, s, ["a", "b", "c"]) if result[0] == "Normal": self.assertEqual(_types.refcount(result[1]), 1) self.assertEqual(result, baseline, "{} -> {}".format(s, result)) for m in range(-2, 10): result = callOrExceptNoType(c_split_3max, s, m) if result[0] == "Normal": self.assertEqual(_types.refcount(result[1]), 1) baseline = callOrExceptNoType(lambda: s.split(maxsplit=m)) self.assertEqual(result, baseline, f"{s},{m}-> {result}") for sep in ["", "j", "s", "d", "t", " ", "as", "jks"]: result = callOrExceptNoType(c_split_3, s, sep) if result[0] == "Normal": self.assertEqual(_types.refcount(result[1]), 1) baseline = callOrExceptNoType(lambda: s.split(sep)) self.assertEqual(result, baseline, f"{s},{sep}-> {result}") for m in range(-2, 10): result = callOrExceptNoType(c_split, s, sep, m) if result[0] == "Normal": self.assertEqual(_types.refcount(result[1]), 1) baseline = callOrExceptNoType(lambda: s.split(sep, m)) self.assertEqual(result, baseline, f"{s},{sep},{m}-> {result}") startusage = currentMemUsageMb() for i in range(100000): for s in split_strings: result = c_split_2(s) result = c_split(s, " ", 9) endusage = currentMemUsageMb() self.assertLess(endusage, startusage + 1) """
def test_class_uninitialized_attribute(self): @Compiled def set(ac: AClassWithAnotherClass, a: AClass) -> None: ac.ac = a @Compiled def get(ac: AClassWithAnotherClass) -> AClass: return ac.ac ac1 = AClass(x=1) ac2 = AClass(x=2) anAWithAClass = AClassWithAnotherClass(ac=ac1) self.assertEqual(_types.refcount(ac1), 2) self.assertEqual(_types.refcount(ac2), 1) self.assertEqual(anAWithAClass.ac.x, 1) set(anAWithAClass, ac2) self.assertEqual(_types.refcount(ac1), 1) self.assertEqual(_types.refcount(ac2), 2) self.assertEqual(anAWithAClass.ac.x, 2) anAWithAClass = AClassWithAnotherClass() self.assertEqual(_types.refcount(ac1), 1) self.assertEqual(_types.refcount(ac2), 1) with self.assertRaises(Exception): get(anAWithAClass) set(anAWithAClass, ac1) self.assertEqual(_types.refcount(ac1), 2) self.assertEqual(_types.refcount(ac2), 1) self.assertEqual(get(anAWithAClass).x, 1) self.assertEqual(get(anAWithAClass).x, 1) self.assertEqual(get(anAWithAClass).x, 1) self.assertEqual(get(anAWithAClass).x, 1) self.assertEqual(_types.refcount(ac1), 2) set(anAWithAClass, ac2) self.assertEqual(_types.refcount(ac1), 1) self.assertEqual(_types.refcount(ac2), 2) self.assertEqual(get(anAWithAClass).x, 2)