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)
