[pypy-commit] pypy s390x-backend: removed test files that where moved to gcstress-hypothesis
plan_rich
pypy.commits at gmail.com
Wed Mar 2 16:14:34 EST 2016
Author: Richard Plangger <planrichi at gmail.com>
Branch: s390x-backend
Changeset: r82667:178b2f4db5aa
Date: 2016-03-02 22:13 +0100
http://bitbucket.org/pypy/pypy/changeset/178b2f4db5aa/
Log: removed test files that where moved to gcstress-hypothesis
diff --git a/rpython/jit/backend/llsupport/tl/__init__.py b/rpython/jit/backend/llsupport/tl/__init__.py
deleted file mode 100644
diff --git a/rpython/jit/backend/llsupport/tl/code.py b/rpython/jit/backend/llsupport/tl/code.py
deleted file mode 100644
--- a/rpython/jit/backend/llsupport/tl/code.py
+++ /dev/null
@@ -1,216 +0,0 @@
-
-import struct
-
-class ByteCode(object):
- def encode(self, ctx):
- ctx.append_byte(self.BYTE_CODE)
-
- @classmethod
- def create_from(self, draw, get_strategy_for):
- pt = getattr(self.__init__, '_param_types', [])
- return self(*[draw(get_strategy_for(t)) for t in pt])
-
-_c = 0
-
-LIST_TYP = 'l'
-INT_TYP = 'i'
-OBJ_TYP = 'o'
-STR_TYP = 's'
-VAL_TYP = 'v' # either one of the earlier
-
-all_types = [INT_TYP, LIST_TYP, STR_TYP] # TODO OBJ_TYP
-
-SHORT_TYP = 'h'
-BYTE_TYP = 'b'
-COND_TYP = 'c'
-IDX_TYP = 'x'
-
-
-def unique_code():
- global _c
- v = _c
- _c = v + 1
- return v
-
-class Context(object):
- def __init__(self):
- self.consts = {}
- self.const_idx = 0
- self.bytecode = []
-
- def append_byte(self, byte):
- self.bytecode.append(('b', byte))
-
- def get_byte(self, i):
- typ, byte = self.bytecode[i]
- assert typ == 'b'
- return byte
-
- def get_short(self, i):
- typ, int = self.bytecode[i]
- assert typ == 'h'
- return int
-
- def append_short(self, byte):
- self.bytecode.append(('h', byte))
-
- def append_int(self, byte):
- self.bytecode.append(('i', byte))
-
- def const_str(self, str):
- self.consts[self.const_idx] = str
- self.append_short(self.const_idx)
- self.const_idx += 1
-
- def to_string(self):
- code = []
- for typ, nmr in self.bytecode:
- code.append(struct.pack(typ, nmr))
- return ''.join(code)
-
- def transform(self, code_objs):
- for code_obj in code_objs:
- code_obj.encode(self)
-
- return self.to_string(), self.consts
-
-
-def requires_stack(*types):
- def method(clazz):
- clazz._stack_types = tuple(types)
- return clazz
- return method
-
-def leaves_on_stack(*types):
- def method(clazz):
- clazz._return_on_stack_types = tuple(types)
- return clazz
- return method
-
-
-def requires_param(*types):
- def method(m):
- m._param_types = tuple(types)
- return m
- return method
-
- at requires_stack()
- at leaves_on_stack(INT_TYP)
-class PutInt(ByteCode):
- BYTE_CODE = unique_code()
- @requires_param(INT_TYP)
- def __init__(self, value):
- self.integral = value
- def encode(self, ctx):
- ctx.append_byte(self.BYTE_CODE)
- ctx.append_int(self.integral)
-
- at requires_stack(INT_TYP, INT_TYP)
- at leaves_on_stack(INT_TYP)
-class CompareInt(ByteCode):
- BYTE_CODE = unique_code()
- def __init__(self):
- pass
-
- at requires_stack()
- at leaves_on_stack(STR_TYP)
-class LoadStr(ByteCode):
- BYTE_CODE = unique_code()
- @requires_param(STR_TYP)
- def __init__(self, string):
- self.string = string
- def encode(self, ctx):
- ctx.append_byte(self.BYTE_CODE)
- ctx.const_str(self.string)
-
- at requires_stack(STR_TYP, STR_TYP)
- at leaves_on_stack(STR_TYP)
-class AddStr(ByteCode):
- BYTE_CODE = unique_code()
- def __init__(self):
- pass
-
- at requires_stack(LIST_TYP, LIST_TYP)
- at leaves_on_stack(LIST_TYP)
-class AddList(ByteCode):
- BYTE_CODE = unique_code()
- def __init__(self):
- pass
-
- at requires_stack()
- at leaves_on_stack(LIST_TYP)
-class CreateList(ByteCode):
- BYTE_CODE = unique_code()
- @requires_param(BYTE_TYP)
- def __init__(self, size=8):
- self.size = size
- def encode(self, ctx):
- ctx.append_byte(self.BYTE_CODE)
- ctx.append_short(self.size)
-
- at requires_stack(LIST_TYP, IDX_TYP, INT_TYP) # TODO VAL_TYP
- at leaves_on_stack(LIST_TYP)
-class InsertList(ByteCode):
- BYTE_CODE = unique_code()
- def __init__(self):
- pass
-
- at requires_stack(LIST_TYP, IDX_TYP)
- at leaves_on_stack(LIST_TYP)
-class DelList(ByteCode):
- BYTE_CODE = unique_code()
- def __init__(self):
- pass
-
- at requires_stack(LIST_TYP, INT_TYP) # TODO VAL_TYP)
- at leaves_on_stack(LIST_TYP)
-class AppendList(ByteCode):
- BYTE_CODE = unique_code()
- def __init__(self):
- pass
-
-
-# remove comment one by one!
-
-#@requires_stack()
-#@leaves_on_stack(INT_TYP)
-#class CondJump(ByteCode):
-# BYTE_CODE = unique_code()
-#
-# COND_EQ = 0
-# COND_LT = 1
-# COND_GT = 2
-# COND_LE = 3
-# COND_GE = 4
-#
-# @requires_param(COND_TYP)
-# def __init__(self, cond):
-# self.cond = cond
-#
-# def encode(self, ctx):
-# ctx.append_byte(self.BYTE_CODE)
-# ctx.append_byte(self.cond)
-#
-#@requires_stack()
-#@leaves_on_stack()
-#class Jump(ByteCode):
-# BYTE_CODE = unique_code()
-# def __init__(self):
-# pass
-#
-
-#@requires_stack(LIST_TYP)
-#@leaves_on_stack(LIST_TYP, INT_TYP)
-#class LenList(ByteCode):
-# BYTE_CODE = unique_code()
-# def __init__(self):
-# pass
-#
-#
-#@requires_stack(INT_TYP) # TODO VAL_TYP)
-#@leaves_on_stack()
-#class ReturnFrame(ByteCode):
-# BYTE_CODE = unique_code()
-# def __init__(self):
-# pass
-#
diff --git a/rpython/jit/backend/llsupport/tl/interp.py b/rpython/jit/backend/llsupport/tl/interp.py
deleted file mode 100644
--- a/rpython/jit/backend/llsupport/tl/interp.py
+++ /dev/null
@@ -1,126 +0,0 @@
-from rpython.rlib.rstruct.runpack import runpack
-from rpython.rlib.objectmodel import specialize, always_inline
-from rpython.jit.backend.llsupport.tl import code
-from rpython.jit.backend.llsupport.tl.stack import Stack
-from rpython.rlib import rstring
-
-class W_Root(object):
- pass
-
-class W_ListObject(W_Root):
- def __init__(self, items):
- self.items = items
-
- def concat(self, space, w_lst):
- assert isinstance(w_lst, W_ListObject)
- return space.wrap(self.items + w_lst.items)
-
-class W_IntObject(W_Root):
- def __init__(self, value):
- self.value = value
-
- def compare(self, space, w_int):
- assert isinstance(w_int, W_IntObject)
- return space.wrap(self.value - w_int.value)
-
- def concat(self, space, w_obj):
- raise NotImplementedError("cannot concat int with object")
-
-class W_StrObject(W_Root):
- def __init__(self, value):
- self.value = value
-
- def concat(self, space, w_str):
- assert isinstance(w_str, W_StrObject)
- return space.wrap(self.value + w_str.value)
-
-class Space(object):
- @specialize.argtype(1)
- def wrap(self, val):
- if isinstance(val, W_Root):
- return val
- if isinstance(val, int):
- return W_IntObject(val)
- if isinstance(val, str):
- return W_StrObject(val)
- if isinstance(val, unicode):
- return W_StrObject(val.encode('utf-8'))
- if isinstance(val, list):
- return W_ListObject(val)
- raise NotImplementedError("cannot handle: " + str(val))
-
-def _read_all_from_file(file):
- with open(file, 'rb') as fd:
- return fd.read()
-
-_read_bytecode_from_file = _read_all_from_file
-
-def _read_consts_from_file(file):
- consts = []
- bytestring = _read_all_from_file(file)
- for line in bytestring.splitlines():
- consts.append(rstring.replace(line, "\\n", "\n"))
- return consts
-
-def entry_point(argv):
- bytecode = _read_bytecode_from_file(argv[1])
- consts = _read_consts_from_file(argv[2])
- print(bytecode)
- print(consts)
- pc = 0
- end = len(bytecode)
- stack = Stack(16)
- space = Space()
- while pc < end:
- pc = dispatch_once(space, pc, bytecode, consts, stack)
- return 0
-
- at always_inline
-def dispatch_once(space, i, bytecode, consts, stack):
- opcode = ord(bytecode[i])
- if opcode == code.PutInt.BYTE_CODE:
- integral = runpack('i', bytecode[i+1:i+5])
- stack.append(space.wrap(integral))
- i += 4
- elif opcode == code.CompareInt.BYTE_CODE:
- w_int2 = stack.pop()
- w_int1 = stack.pop()
- stack.append(w_int1.compare(space, w_int2))
- elif opcode == code.LoadStr.BYTE_CODE:
- pos = runpack('h', bytecode[i+1:i+3])
- w_str = space.wrap(consts[pos])
- stack.append(w_str)
- i += 2
- elif opcode == code.AddStr.BYTE_CODE:
- w_str2 = stack.pop()
- w_str1 = stack.pop()
- stack.append(w_str1.concat(space, w_str2))
- elif opcode == code.AddList.BYTE_CODE:
- w_lst2 = stack.pop()
- w_lst1 = stack.pop()
- stack.append(w_lst1.concat(space, w_lst2))
- elif opcode == code.CreateList.BYTE_CODE:
- size = runpack('h', bytecode[i+1:i+3])
- stack.append(space.wrap([None] * size))
- i += 2
- elif opcode == code.AppendList.BYTE_CODE:
- w_val = stack.pop()
- w_lst = stack.peek(0)
- w_lst.items.append(w_val)
- elif opcode == code.InsertList.BYTE_CODE:
- w_val = stack.pop()
- w_idx = stack.pop()
- assert isinstance(w_idx, W_IntObject)
- w_lst = stack.peek(0)
- w_lst.items[w_idx.value] = w_val
- # index error, just crash here!
- elif opcode == code.DelList.BYTE_CODE:
- w_idx = stack.pop()
- assert isinstance(w_idx, W_IntObject)
- w_lst = stack.peek(0)
- del w_lst.items[w_idx.value]
- # index error, just crash the machine!!
- else:
- print("opcode %d is not implemented" % opcode)
- raise NotImplementedError
- return i + 1
diff --git a/rpython/jit/backend/llsupport/tl/stack.py b/rpython/jit/backend/llsupport/tl/stack.py
deleted file mode 100644
--- a/rpython/jit/backend/llsupport/tl/stack.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from rpython.rlib.jit import JitDriver, hint, dont_look_inside, promote
-
-class Stack(object):
- _virtualizable_ = ['stackpos', 'stack[*]']
-
- def __init__(self, size):
- self = hint(self, access_directly=True, fresh_virtualizable=True)
- self.stack = [None] * size
- self.stackpos = 0 # always store a known-nonneg integer here
-
- def size(self):
- return self.stackpos
-
- def append(self, elem):
- while len(self.stack) <= self.stackpos:
- self.stack.append(None)
- self.stack[self.stackpos] = elem
- self.stackpos += 1
-
- def peek(self, i):
- stackpos = self.stackpos - i - 1
- if stackpos < 0:
- raise IndexError
- return self.stack[stackpos]
-
- def pop(self):
- stackpos = self.stackpos - 1
- if stackpos < 0:
- raise IndexError
- self.stackpos = stackpos # always store a known-nonneg integer here
- return self.stack[stackpos]
-
- def pick(self, i):
- n = self.stackpos - i - 1
- assert n >= 0
- self.append(self.stack[n])
-
- def put(self, i):
- elem = self.pop()
- n = self.stackpos - i - 1
- assert n >= 0
- self.stack[n] = elem
-
- @dont_look_inside
- def roll(self, r):
- if r < -1:
- i = self.stackpos + r
- if i < 0:
- raise IndexError
- n = self.stackpos - 1
- assert n >= 0
- elem = self.stack[n]
- for j in range(self.stackpos - 2, i - 1, -1):
- assert j >= 0
- self.stack[j + 1] = self.stack[j]
- self.stack[i] = elem
- elif r > 1:
- i = self.stackpos - r
- if i < 0:
- raise IndexError
- elem = self.stack[i]
- for j in range(i, self.stackpos - 1):
- self.stack[j] = self.stack[j + 1]
- n = self.stackpos - 1
- assert n >= 0
- self.stack[n] = elem
diff --git a/rpython/jit/backend/llsupport/tl/test/__init__.py b/rpython/jit/backend/llsupport/tl/test/__init__.py
deleted file mode 100644
diff --git a/rpython/jit/backend/llsupport/tl/test/code_strategies.py b/rpython/jit/backend/llsupport/tl/test/code_strategies.py
deleted file mode 100644
--- a/rpython/jit/backend/llsupport/tl/test/code_strategies.py
+++ /dev/null
@@ -1,75 +0,0 @@
-from hypothesis import strategies as st
-from hypothesis.control import assume
-from hypothesis.strategies import defines_strategy, composite
-from rpython.jit.backend.llsupport.tl import code, interp, stack
-from rpython.jit.backend.llsupport.tl.code import (all_types,
- INT_TYP, STR_TYP, LIST_TYP, SHORT_TYP, BYTE_TYP,
- COND_TYP, IDX_TYP)
-from hypothesis.searchstrategy.strategies import OneOfStrategy
-from hypothesis.searchstrategy.collections import TupleStrategy
-
-def get_strategy_for(typ):
- if typ == INT_TYP:
- return st.integers(min_value=-2**31, max_value=2**31-1)
- elif typ == IDX_TYP:
- return st.integers(min_value=-2**31, max_value=2**31-1)
- elif typ == SHORT_TYP:
- return st.integers(min_value=-2**15, max_value=2**15-1)
- elif typ == BYTE_TYP:
- return st.integers(min_value=-2**7, max_value=2**7-1)
- elif typ == COND_TYP:
- return st.integers(min_value=0, max_value=4)
- elif typ == STR_TYP:
- return st.text()
- elif typ == LIST_TYP:
- return st.lists(elements=st.one_of(st.integers())) # TODO must be recursive
- else:
- raise NotImplementedError("type: " + str(typ))
-
-STD_SPACE = interp.Space()
-
- at composite
-def runtime_stack(draw, clazz):
- strats = [get_strategy_for(t) for t in clazz._stack_types]
- stack_obj = stack.Stack(len(strats))
- for i,strat in enumerate(strats):
- if clazz._stack_types[i] == IDX_TYP:
- # it is only valid to access a list with a valid index!
- w_list = stack_obj.peek(i-1)
- l = len(w_list.items)
- assume(l > 0)
- integrals = st.integers(min_value=0, max_value=l-1)
- stack_obj.append(STD_SPACE.wrap(draw(integrals)))
- continue
- stack_obj.append(STD_SPACE.wrap(draw(strat)))
- return stack_obj
-
-def byte_code_classes():
- for name, clazz in code.__dict__.items():
- if hasattr(clazz, 'BYTE_CODE'):
- yield clazz
-
-def get_byte_code_class(num):
- for clazz in byte_code_classes():
- if clazz.BYTE_CODE == num:
- return clazz
- return None
-
- at composite
-def single_bytecode(draw,
- clazzes=st.sampled_from(byte_code_classes()),
- integrals=st.integers(), texts=st.text()):
- clazz = draw(clazzes)
- inst = clazz.create_from(draw, get_strategy_for)
- bytecode, consts = code.Context().transform([inst])
- _stack = draw(runtime_stack(clazz))
- return bytecode, consts, _stack
-
- at composite
-def bytecode_block(draw,
- clazzes=st.sampled_from(byte_code_classes()),
- integrals=st.integers(), texts=st.text()):
- clazz = draw(clazzes)
- inst = clazz.create_from(draw, get_strategy_for)
- bytecode, consts = code.Context().transform([inst])
- return bytecode, consts
diff --git a/rpython/jit/backend/llsupport/tl/test/test_tl_interp.py b/rpython/jit/backend/llsupport/tl/test/test_tl_interp.py
deleted file mode 100644
--- a/rpython/jit/backend/llsupport/tl/test/test_tl_interp.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import py
-from hypothesis import given
-from rpython.jit.backend.llsupport.tl import code, interp
-from rpython.jit.backend.llsupport.tl.stack import Stack
-from rpython.jit.backend.llsupport.tl.test import code_strategies as st
-
-class TestByteCode(object):
- def test_load_str(self):
- c = code.Context()
- code.LoadStr("hello world").encode(c)
- assert c.consts[0] == "hello world"
- assert c.get_byte(0) == code.LoadStr.BYTE_CODE
- assert c.get_short(1) == 0
-
- def test_str_add(self):
- c = code.Context()
- code.LoadStr("hello").encode(c)
- code.LoadStr("world").encode(c)
- code.AddStr().encode(c)
- assert len(c.consts) == 2
- assert c.get_byte(4) == code.AddStr.BYTE_CODE
- assert c.get_short(3) == 1
-
-class TestInterp(object):
- @given(st.single_bytecode())
- def test_consume_stack(self, args):
- bytecode, consts, stack = args
- space = interp.Space()
- i = interp.dispatch_once(space, 0, bytecode, consts, stack)
- assert i == len(bytecode)
- clazz = code.get_byte_code_class(ord(bytecode[0]))
- assert stack.size() == len(clazz._return_on_stack_types)
-
- @given(st.bytecode_block())
- def test_execute_bytecode_block(self, args):
- bytecode, consts = args
- space = interp.Space()
- stack = Stack(16)
- pc = 0
- end = len(bytecode)
- while pc < end:
- pc = interp.dispatch_once(space, pc, bytecode, consts, stack)
- assert pc == len(bytecode)
diff --git a/rpython/jit/backend/llsupport/tl/test/zrpy_gc_hypo_test.py b/rpython/jit/backend/llsupport/tl/test/zrpy_gc_hypo_test.py
deleted file mode 100644
--- a/rpython/jit/backend/llsupport/tl/test/zrpy_gc_hypo_test.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import py
-from hypothesis import given
-from rpython.tool.udir import udir
-from rpython.jit.metainterp.optimize import SpeculativeError
-from rpython.annotator.listdef import s_list_of_strings
-from rpython.translator.translator import TranslationContext
-from rpython.translator.c import genc
-from rpython.jit.backend.llsupport.tl import interp
-from rpython.jit.backend.llsupport.tl.test import code_strategies as st
-
-def persist(type, contents):
- dir = udir.ensure(type)
- print "written", type, "to", dir
- with open(dir.strpath, 'wb') as fd:
- fd.write(contents)
- return dir.strpath
-
-def persist_constants(consts):
- contents = ""
- for string in consts:
- contents += string.replace("\n", "\\n") + "\n"
- return persist('constants', contents)
-
-def persist_bytecode(bc):
- return persist('bytecode', bc)
-
-class GCHypothesis(object):
- builder = None
- def setup_method(self, name):
- if self.builder:
- return
-
- t = TranslationContext()
- t.config.translation.gc = "incminimark"
- t.config.translation.gcremovetypeptr = True
- ann = t.buildannotator()
- ann.build_types(interp.entry_point, [s_list_of_strings], main_entry_point=True)
- rtyper = t.buildrtyper()
- rtyper.specialize()
-
- cbuilder = genc.CStandaloneBuilder(t, interp.entry_point, t.config)
- cbuilder.generate_source(defines=cbuilder.DEBUG_DEFINES)
- cbuilder.compile()
- # prevent from rebuilding the c object!
- self.builder = cbuilder
-
- def execute(self, bytecode, consts):
- exe = self.builder.executable_name
- bc_file = persist_bytecode(bytecode)
- consts_file = persist_constants(consts)
- args = [bc_file, consts_file]
- env = {}
- res = self.builder.translator.platform.execute(exe, args, env=env)
- return res.returncode, res.out, res.err
-
- @given(st.bytecode_block())
- def test_execute_single_bytecode(self, program):
- bytecode, consts = program
- result, out, err = self.execute(bytecode, consts)
- if result != 0:
- raise Exception(("could not run program. returned %d"
- " stderr:\n%s\nstdout:\n%s\n") % (result, err, out))
diff --git a/rpython/jit/backend/x86/test/test_zrpy_gc_hypo.py b/rpython/jit/backend/x86/test/test_zrpy_gc_hypo.py
deleted file mode 100644
--- a/rpython/jit/backend/x86/test/test_zrpy_gc_hypo.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from rpython.jit.backend.llsupport.tl.test.zrpy_gc_hypo_test import GCHypothesis
-
-class TestGCHypothesis(GCHypothesis):
- # runs ../../llsupport/tl/test/zrpy_gc_hypo_test.py
- gcrootfinder = "shadowstack"
- gc = "incminimark"
More information about the pypy-commit
mailing list