GitLab will be upgraded to the 12.10.14-ce.0 on 28 Sept 2020 at 2.00pm (AEDT) to 2.30pm (AEDT). During the update, GitLab and Mattermost services will not be available. If you have any concerns with this, please talk to us at N110 (b) CSIT building.

Commit 0a808fc9 authored by John Zhang's avatar John Zhang

Refactored tests.

parent 8080b7a6
from test_milestones import get_fncptr
from util import fncptr_from_c_script
def test_add():
fn = get_fncptr("test_add", "test_fnc")
fn, _ = fncptr_from_c_script("test_add.c", "test_fnc")
assert fn() == 9
def test_sub():
fn = get_fncptr("test_sub", "test_fnc")
fn, _ = fncptr_from_c_script("test_sub.c", "test_fnc")
assert fn() == 11
def test_mul():
fn = get_fncptr("test_mul", "test_fnc")
fn, _ = fncptr_from_c_script("test_mul.c", "test_fnc")
assert fn() == 0xf6
def test_sdiv():
fn = get_fncptr("test_sdiv", "test_fnc")
fn, _ = fncptr_from_c_script("test_sdiv.c", "test_fnc")
assert fn() == 0xf4
def test_urem():
fn = get_fncptr("test_urem", "test_fnc")
fn, _ = fncptr_from_c_script("test_urem.c", "test_fnc")
assert fn() == 5
def test_shl():
fn = get_fncptr("test_shl", "test_fnc")
fn, _ = fncptr_from_c_script("test_shl.c", "test_fnc")
assert fn() == 0x7e707560c92d5400
def test_lshr():
fn = get_fncptr("test_lshr", "test_fnc")
fn, _ = fncptr_from_c_script("test_lshr.c", "test_fnc")
assert fn() == 0x2367e707560c92
def test_and():
fn = get_fncptr("test_and", "test_fnc")
fn, _ = fncptr_from_c_script("test_and.c", "test_fnc")
assert fn() == 0x8588901c10004b14
def test_xor():
fn = get_fncptr("test_xor", "test_fnc")
fn, _ = fncptr_from_c_script("test_xor.c", "test_fnc")
assert fn() == 0x58376ec3e83fa0e1
from test_milestones import get_fncptr
from util import fncptr_from_c_script
def test_eq_int():
fn = get_fncptr("test_eq_int", "test_fnc")
fn, _ = fncptr_from_c_script("test_eq_int.c", "test_fnc")
assert fn() == 0
def test_eq_ref():
fn = get_fncptr("test_eq_ref", "test_fnc")
fn, _ = fncptr_from_c_script("test_eq_ref.c", "test_fnc")
assert fn() == 0
def test_ne_int():
fn = get_fncptr("test_ne_int", "test_fnc")
fn, _ = fncptr_from_c_script("test_ne_int.c", "test_fnc")
assert fn() == 1
def test_ne_ref():
fn = get_fncptr("test_ne_ref", "test_fnc")
fn, _ = fncptr_from_c_script("test_ne_ref.c", "test_fnc")
assert fn() == 1
def test_sge():
fn = get_fncptr("test_sge", "test_fnc")
fn, _ = fncptr_from_c_script("test_sge.c", "test_fnc")
assert fn() == 1
def test_sgt():
fn = get_fncptr("test_sgt", "test_fnc")
fn, _ = fncptr_from_c_script("test_sgt.c", "test_fnc")
assert fn() == 0
def test_sle():
fn = get_fncptr("test_sle", "test_fnc")
fn, _ = fncptr_from_c_script("test_sle.c", "test_fnc")
assert fn() == 1
def test_slt():
fn = get_fncptr("test_slt", "test_fnc")
fn, _ = fncptr_from_c_script("test_slt.c", "test_fnc")
assert fn() == 0
def test_ult():
fn = get_fncptr("test_ult", "test_fnc")
fn, _ = fncptr_from_c_script("test_ult.c", "test_fnc")
assert fn() == 0
from test_milestones import get_fncptr, compile_lib
from util import fncptr_from_c_script
import ctypes, ctypes.util
def test_branch():
fn = get_fncptr("test_branch", "test_fnc")
fn, _ = fncptr_from_c_script("test_branch.c", "test_fnc")
assert fn() == 30
def test_branch2():
fn = get_fncptr("test_branch2", "test_fnc", [ctypes.c_byte])
fn, _ = fncptr_from_c_script("test_branch2.c", "test_fnc", [ctypes.c_byte])
assert fn(1) == 30
assert fn(0) == 200
def test_ccall():
fn = get_fncptr("test_ccall", "test_ccall", [ctypes.c_ulonglong])
fn, _ = fncptr_from_c_script("test_ccall.c", "test_ccall", [ctypes.c_ulonglong])
assert fn(0x7e707560c92d5400) == 0x7e707560c92d5400
def test_extern_func():
# libc = ctypes.CDLL(ctypes.util.find_library('c'), ctypes.RTLD_GLOBAL)
fn = get_fncptr("test_extern_func", "test_write", [ctypes.c_void_p, ctypes.c_size_t], ctypes.c_int64)
fn, _ = fncptr_from_c_script("test_extern_func.c", "test_write", [ctypes.c_void_p, ctypes.c_size_t], ctypes.c_int64)
buf = ctypes.create_string_buffer('hello world!\n')
assert fn(ctypes.byref(buf), len(buf)) == len(buf)
from test_milestones import get_fncptr
from util import fncptr_from_c_script
def test_trunc():
fn = get_fncptr("test_trunc", "test_fnc")
fn, _ = fncptr_from_c_script("test_trunc.c", "test_fnc")
assert fn() == 0x58324b55
def test_sext():
fn = get_fncptr("test_sext", "test_fnc")
fn, _ = fncptr_from_c_script("test_sext.c", "test_fnc")
assert fn() == 0xffffffffa8324b55
def test_zext():
fn = get_fncptr("test_zext", "test_fnc")
fn, _ = fncptr_from_c_script("test_zext.c", "test_fnc")
assert fn() == 0x00000000a8324b55
from test_milestones import get_fncptr
from util import fncptr_from_c_script
import ctypes
def test_uptr_bytestore_load():
fn = get_fncptr("test_uptr_bytestore_load", "test_fnc",
argtypes=[ctypes.POINTER(ctypes.c_uint32)],
restype=ctypes.c_uint32)
fn, _ = fncptr_from_c_script("test_uptr_bytestore_load.c", "test_fnc",
argtypes=[ctypes.POINTER(ctypes.c_uint32)],
restype=ctypes.c_uint32)
# allocate memory through ctypes
ui32 = ctypes.c_uint32()
......
"""
Harness JIT tests using py.test framework
"""
import subprocess as subp
import os, sys
from util import fncptr_from_c_script
import ctypes
import py
CC = os.environ.get('CC', 'clang')
proj_dir = py.path.local(__file__).join('..', '..', '..')
test_jit_dir = proj_dir.join('tests', 'test_jit')
testsuite_dir = test_jit_dir.join('suite')
bin_dir = test_jit_dir.join('temp')
if not bin_dir.exists():
bin_dir.mkdir()
def compile_lib(testname):
src_c = testsuite_dir.join(testname + '.c')
bin_path = bin_dir.join(testname)
CFLAGS = [
"-std=c99",
"-I%(proj_dir)s/src/vm/api" % globals(),
"-L%(proj_dir)s/target/debug" % globals(),
"-lmu",
]
cmd = [CC] + CFLAGS + ['-o', str(bin_path)] + [str(src_c)]
# compile
p = subp.Popen(cmd, stdout=subp.PIPE, stderr=subp.PIPE, env=os.environ)
out, err = p.communicate()
if p.returncode != 0: # failed
sys.stdout.write(out + '\n')
sys.stderr.write(err + '\n')
raise subp.CalledProcessError(p.returncode, cmd)
os.environ['LD_LIBRARY_PATH'] = "%s:%s" % ("%(proj_dir)s/target/debug" % globals(),
os.environ['LD_LIBRARY_PATH'] if 'LD_LIBRARY_PATH' in os.environ else "")
# run
p = subp.Popen([str(bin_path)], stdout=subp.PIPE, stderr=subp.PIPE, cwd=str(bin_dir), env=os.environ)
out, err = p.communicate()
if p.returncode != 0: # failed
sys.stdout.write(out + '\n')
sys.stderr.write(err + '\n')
raise subp.CalledProcessError(p.returncode, bin_path)
return str(bin_dir.join('emit', testname + '.dylib'))
def get_fncptr(testname, entry_fnc, argtypes=[], restype=ctypes.c_ulonglong):
lib_path = compile_lib(testname)
lib = ctypes.CDLL(lib_path)
fncptr = getattr(lib, entry_fnc)
fncptr.restype = restype
fncptr.argtypes = argtypes
return fncptr
def test_constant_function():
fn = get_fncptr("test_constfunc", 'test_fnc')
fn, _ = fncptr_from_c_script("test_constfunc.c", 'test_fnc')
assert fn() == 0
def test_milsum():
fn = get_fncptr("test_milsum", "milsum", [ctypes.c_ulonglong])
fn, _ = fncptr_from_c_script("test_milsum.c", "milsum", [ctypes.c_ulonglong])
assert fn(1000000) == 500000500000
def test_factorial():
fn = get_fncptr("test_fac", "fac", [ctypes.c_ulonglong])
fn, _ = fncptr_from_c_script("test_fac.c", "fac", [ctypes.c_ulonglong])
assert fn(20) == 2432902008176640000
def test_fibonacci():
fn = get_fncptr("test_fib", "fib", [ctypes.c_ulonglong])
fn, _ = fncptr_from_c_script("test_fib.c", "fib", [ctypes.c_ulonglong])
assert fn(20) == 6765
def test_multifunc():
fn = get_fncptr("test_multifunc", "entry")
assert fn() == 6765
\ No newline at end of file
fn, _ = fncptr_from_c_script("test_multifunc.c", "entry")
assert fn() == 6765
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import rmu_fast as rmu
from rpython.translator.interactive import Translation
import ctypes, sys
from test_milestones import proj_dir
def getfncptr(entry_fnc, argtypes, **kwargs):
kwargs.setdefault('backend', 'mu')
kwargs.setdefault('muimpl', 'fast')
kwargs.setdefault('mucodegen', 'api')
kwargs.setdefault('mutestjit', True)
t = Translation(entry_fnc, argtypes, **kwargs)
if kwargs['backend'] == 'mu':
db, bdlgen, fnc_name = t.compile_mu()
bdlgen.mu.compile_to_sharedlib('libtesting.dylib', [])
lib = ctypes.CDLL('emit/libtesting.dylib')
fnp = getattr(lib, fnc_name)
return fnp
else:
libpath = t.compile_c()
return getattr(ctypes.CDLL(libpath.strpath), 'pypy_g_' + entry_fnc.__name__)
from util import fncptr_from_rpy_func, fncptr_from_py_script
import ctypes
def test_add():
def add(a, b):
return a + b
fn = getfncptr(add, [rffi.LONGLONG, rffi.LONGLONG])
fn, _ = fncptr_from_rpy_func(add, [rffi.LONGLONG, rffi.LONGLONG], rffi.LONGLONG)
assert fn(1, 2) == 3
......@@ -41,10 +21,13 @@ def test_find_min():
m = x
return m
fnc = getfncptr(find_min, [rffi.CArrayPtr(rffi.LONGLONG), rffi.UINTPTR_T])
fnc, _ = fncptr_from_rpy_func(find_min, [rffi.CArrayPtr(rffi.LONGLONG), rffi.INTPTR_T], rffi.LONGLONG)
arr = (ctypes.c_longlong * 5)(23, 100, 0, 78, -5)
assert fnc(ctypes.byref(arr), 5) == -5
with lltype.scoped_alloc(rffi.CArray(rffi.LONGLONG), 5) as arr:
lst = [23, 100, 0, 78, -5]
for i, n in enumerate(lst):
arr[i] = n
assert fnc(arr, 5) == -5
def rand_array_of(n):
......@@ -68,9 +51,7 @@ def test_arraysum():
sum += arr[i]
return sum
fnc = getfncptr(arraysum, [rffi.CArrayPtr(rffi.LONGLONG), rffi.SIZE_T])
# fnc = getfncptr(arraysum, [rffi.CArrayPtr(rffi.LONGLONG), rffi.SIZE_T],
# backend='c', jit=False, gc='none')
fnc, _ = fncptr_from_rpy_func(arraysum, [rffi.CArrayPtr(rffi.LONGLONG), rffi.SIZE_T], rffi.LONGLONG)
n = 1000000
arr, lst = rand_array_of(n)
......@@ -106,9 +87,7 @@ def test_quicksort():
quicksort(arr, start, p - 1)
quicksort(arr, p + 1, end)
# fnc = getfncptr(quicksort, [rffi.CArrayPtr(rffi.LONGLONG), rffi.UINTPTR_T, rffi.UINTPTR_T],
# backend='c', jit=False, gc='none')
fnc = getfncptr(quicksort, [rffi.CArrayPtr(rffi.LONGLONG), rffi.UINTPTR_T, rffi.UINTPTR_T])
fnc, _ = fncptr_from_rpy_func(quicksort, [rffi.CArrayPtr(rffi.LONGLONG), rffi.UINTPTR_T, rffi.UINTPTR_T], lltype.Void)
n = 1000000
arr, lst = rand_array_of(n)
......@@ -123,7 +102,7 @@ def test_quicksort():
lst_s = sorted(lst)
for i in range(n):
assert lst_s[i] == arr[i], "%d != %d" % (lst_s[i], arr[i])
# +(+(uptr<int<64>> %find_min_0.blk2.rtn_5 #257) = SHIFTIREF PTR +(+(uptr<@hybSigned_0(hybrid)> %find_min_0.blk2.rtn_4 #255) = GETVARPARTIREF PTR +(uptr<@hybSigned_0(hybrid)> %find_min_0.blk2.xs_2 #251)) +(int<64> %find_min_0.blk2.next_0 #249)))
def test_linkedlist_reversal():
def reverse_linkedlist(head):
......@@ -141,15 +120,7 @@ def test_linkedlist_reversal():
NodePtr = lltype.Ptr(Node)
Node.become(lltype.Struct("Node", ('val', rffi.CHAR), ('nxt', NodePtr)))
# RPython RFFI
t = Translation(reverse_linkedlist, [NodePtr],
backend='mu', muimpl='fast', mucodegen='api', mutestjit=True)
db, bdlgen, fnc_name = t.compile_mu()
bdlgen.mu.compile_to_sharedlib('libtesting.dylib', [])
c_fnc = rffi.llexternal('reverse_linkedlist', [NodePtr], NodePtr,
compilation_info=rffi.ExternalCompilationInfo(libraries=['libtesting.dylib'],
library_dirs=['emit']), _nowrapper=True)
fnc, _ = fncptr_from_rpy_func(reverse_linkedlist, [NodePtr], NodePtr)
# linked list: a -> b -> c -> d
with lltype.scoped_alloc(Node) as a:
......@@ -165,49 +136,13 @@ def test_linkedlist_reversal():
d.val = 'd'
d.nxt = lltype.nullptr(Node)
h = c_fnc(a)
h = fnc(a)
assert h.val == 'd'
assert h.nxt.val == 'c'
assert h.nxt.nxt.val == 'b'
assert h.nxt.nxt.nxt.val == 'a'
assert h.nxt.nxt.nxt.nxt == lltype.nullptr(Node)
# # ctypes
# fnc = getfncptr(reverse_linkedlist, [NodePtr])
#
# class cNode(ctypes.Structure):
# pass
# cNodePtr = ctypes.POINTER(cNode)
# cNode._fields_ = [('val', ctypes.c_char),
# ('nxt', cNodePtr)]
#
# # fnc.argtypes = [cNodePtr]
# # fnc.restype = [cNodePtr]
#
# # ctypes
# # linked list: a -> b -> c -> d
# a = cNode()
# a.val = 'a'
# b = cNode()
# b.val = 'b'
# a.nxt = ctypes.pointer(b)
# c = cNode()
# c.val = 'c'
# b.nxt = ctypes.pointer(c)
# d = cNode()
# d.val = 'd'
# c.nxt = ctypes.pointer(d)
# d.nxt = None
#
# h = fnc(a)
#
# assert h.val == 'd'
# assert h.nxt.val == 'c'
# assert h.nxt.nxt.val == 'b'
# assert h.nxt.nxt.nxt.val == 'a'
# assert h.nxt.nxt.nxt.nxt == None
def test_threadtran_fib():
def build_test_bundle(bldr, rmu):
"""
......@@ -307,16 +242,7 @@ def test_threadtran_fib():
"result_type": i64
}
mu = rmu.MuVM()
ctx = mu.new_context()
bldr = ctx.new_ir_builder()
id_dict = build_test_bundle(bldr, rmu)
bldr.load()
mu.compile_to_sharedlib('libtesting.dylib', [])
lib = ctypes.CDLL('emit/libtesting.dylib')
fnp = lib.fib
fnp, (mu, ctx, bldr) = fncptr_from_py_script(build_test_bundle, 'fib', [ctypes.c_longlong])
mu.current_thread_as_mu_thread(rmu.null(rmu.MuCPtr))
assert fnp(20) == 6765
......@@ -386,19 +312,10 @@ def test_new():
}
# load libmu before rffi so to load it with RTLD_GLOBAL
libmu = ctypes.CDLL(proj_dir.join('target', 'debug', 'libmu.dylib').strpath, ctypes.RTLD_GLOBAL)
mu = rmu.MuVM()
ctx = mu.new_context()
bldr = ctx.new_ir_builder()
id_dict = build_test_bundle(bldr, rmu)
bldr.load()
mu.compile_to_sharedlib('libtesting.dylib', [])
from util import libmu_path
libmu = ctypes.CDLL(libmu_path.strpath, ctypes.RTLD_GLOBAL)
lib = ctypes.CDLL('emit/libtesting.dylib')
fnp = lib.test_fnc
fnp, (mu, ctx, bldr) = fncptr_from_py_script(build_test_bundle, 'test_fnc')
mu.current_thread_as_mu_thread(rmu.null(rmu.MuCPtr))
assert fnp() == 1
......@@ -464,18 +381,10 @@ def test_new_cmpeq():
}
# load libmu before rffi so to load it with RTLD_GLOBAL
libmu = ctypes.CDLL(proj_dir.join('target', 'debug', 'libmu.dylib').strpath, ctypes.RTLD_GLOBAL)
mu = rmu.MuVM()
ctx = mu.new_context()
bldr = ctx.new_ir_builder()
id_dict = build_test_bundle(bldr, rmu)
bldr.load()
mu.compile_to_sharedlib('libtesting.dylib', [])
from util import libmu_path
libmu = ctypes.CDLL(libmu_path.strpath, ctypes.RTLD_GLOBAL)
lib = ctypes.CDLL('emit/libtesting.dylib')
fnp = lib.test_fnc
fnp, (mu, ctx, bldr) = fncptr_from_py_script(build_test_bundle, 'test_fnc')
mu.current_thread_as_mu_thread(rmu.null(rmu.MuCPtr))
assert fnp() == 0
......
import subprocess as subp
import os, sys
import ctypes
import py
CC = os.environ.get('CC', 'clang')
proj_dir = py.path.local(__file__).join('..', '..', '..')
test_jit_dir = proj_dir.join('tests', 'test_jit')
testsuite_dir = test_jit_dir.join('suite')
bin_dir = test_jit_dir.join('temp')
if not bin_dir.exists():
bin_dir.mkdir()
libmu_path = proj_dir.join('target', 'debug', 'libmu.dylib')
def compile_c_script(c_src_name):
testname = c_src_name[:-2]
src_c = testsuite_dir.join(c_src_name)
bin_path = bin_dir.join(testname)
CFLAGS = [
"-std=c11",
"-I%(proj_dir)s/src/vm/api" % globals(),
"-L" + libmu_path.dirname,
"-lmu",
]
cmd = [CC] + CFLAGS + ['-o', bin_path.strpath] + [src_c.strpath]
# compile
p = subp.Popen(cmd, stdout=subp.PIPE, stderr=subp.PIPE, env=os.environ)
out, err = p.communicate()
if p.returncode != 0: # failed
sys.stdout.write(out + '\n')
sys.stderr.write(err + '\n')
raise subp.CalledProcessError(p.returncode, cmd)
os.environ['LD_LIBRARY_PATH'] = "%s:%s" % ("%(proj_dir)s/target/debug" % globals(),
os.environ['LD_LIBRARY_PATH'] if 'LD_LIBRARY_PATH' in os.environ else "")
# run
p = subp.Popen([bin_path.strpath], stdout=subp.PIPE, stderr=subp.PIPE, cwd=str(bin_dir), env=os.environ)
out, err = p.communicate()
if p.returncode != 0: # failed
sys.stdout.write(out + '\n')
sys.stderr.write(err + '\n')
raise subp.CalledProcessError(p.returncode, bin_path)
return bin_dir.join('emit', '%(testname)s.dylib' % locals()).strpath
def fncptr_from_lib(lib, fnc_name, argtypes=[], restype=ctypes.c_longlong):
fnp = getattr(lib, fnc_name)
fnp.argtypes = argtypes
fnp.restype = restype
return fnp
def fncptr_from_c_script(c_src_name, name, argtypes=[], restype=ctypes.c_ulonglong):
lib_path = compile_c_script(c_src_name)
lib = ctypes.CDLL(lib_path)
return fncptr_from_lib(lib, name, argtypes, restype), lib
def fncptr_from_py_script(py_fnc, name, argtypes=[], restype=ctypes.c_longlong):
# NOTE: requires mu-client-pypy
from rpython.rlib import rmu_fast as rmu
mu = rmu.MuVM()
ctx = mu.new_context()
bldr = ctx.new_ir_builder()
id_dict = py_fnc(bldr, rmu)
bldr.load()
libname = 'lib%(name)s.dylib' % locals()
mu.compile_to_sharedlib(libname, [])
lib = ctypes.CDLL('emit/%(libname)s' % locals())
return fncptr_from_lib(lib, name, argtypes, restype), (mu, ctx, bldr)
def fncptr_from_rpy_func(rpy_fnc, llargtypes, llrestype, **kwargs):
# NOTE: requires mu-client-pypy
from rpython.rtyper.lltypesystem import rffi
from rpython.translator.interactive import Translation
kwargs.setdefault('backend', 'mu')
kwargs.setdefault('muimpl', 'fast')
kwargs.setdefault('mucodegen', 'api')
kwargs.setdefault('mutestjit', True)
t = Translation(rpy_fnc, llargtypes, **kwargs)
if kwargs['backend'] == 'mu':
db, bdlgen, fnc_name = t.compile_mu()
libname = 'lib%(fnc_name)s.dylib' % locals()
bdlgen.mu.compile_to_sharedlib(libname, [])
eci = rffi.ExternalCompilationInfo(libraries=[test_jit_dir.join('emit', libname).strpath])
extras = (db, bdlgen)
else:
libpath = t.compile_c()
fnc_name = 'pypy_g_' + rpy_fnc.__name__
eci = rffi.ExternalCompilationInfo(libraries=[libpath.strpath])
extras = None
return rffi.llexternal(fnc_name, llargtypes, llrestype, compilation_info=eci, _nowrapper=True), extras
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment