Python TranslationContext.buildflowgraph方法代码示例

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_wrong_startblock_incref():
    class B(object):
        pass
    def g(b):
        while True:
            b.x -= 10
            if b.x < 0:
                return b.x
    def f(n):
        b = B()
        b.x = n
        return g(b)

    # XXX obscure: remove the first empty block in the graph of 'g'
    t = TranslationContext()
    graph = t.buildflowgraph(g)
    assert graph.startblock.operations == []
    graph.startblock = graph.startblock.exits[0].target
    from pypy.objspace.flow.model import checkgraph
    checkgraph(graph)
    t._prebuilt_graphs[g] = graph

    fn = compile_func(f, [int], t)
    res = fn(112)
    assert res == -8

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_simple_loop():
    def snippet_fn(x, y):
        while y > 0:
            y -= x
        return y
    t = TranslationContext()
    graph = t.buildflowgraph(snippet_fn)
    if option.view:
        t.view()
    loops = find_inner_loops(graph)
    assert len(loops) == 1
    loop = loops[0]
    assert loop.headblock.operations[0].opname == 'gt'
    assert len(loop.links) == 2
    assert loop.links[0] in loop.headblock.exits
    assert loop.links[1] in loop.links[0].target.exits
    assert loop.links[1].target is loop.headblock

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_detect_list_comprehension():
    def f1(l):
        return [x*17 for x in l]

    t = TranslationContext(list_comprehension_operations=True)
    graph = t.buildflowgraph(f1)
    if conftest.option.view:
        graph.show()
    assert summary(graph) == {
        'newlist': 1,
        'iter': 1,
        'next': 1,
        'mul':  1,
        'getattr': 1,
        'simple_call': 1,
        'hint': 2,
        }

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_simple_compute_reachability():
    def f(x):
        if x < 0:
            if x == -1:
                return x+1
            else:
                return x+2
        else:
            if x == 1:
                return x-1
            else:
                return x-2
    t = TranslationContext()
    g = t.buildflowgraph(f)
    reach = compute_reachability(g)
    assert len(reach[g.startblock]) == 7
    assert len(reach[g.startblock.exits[0].target]) == 3
    assert len(reach[g.startblock.exits[1].target]) == 3

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_nested_loops():
    def snippet_fn(x, z):
        y = 0
        while y <= 10:
            while z < y:
                z += y
            y += 1
        return z
    t = TranslationContext()
    graph = t.buildflowgraph(snippet_fn)
    if option.view:
        t.view()
    loops = find_inner_loops(graph)
    assert len(loops) == 1
    loop = loops[0]
    assert loop.headblock.operations[0].opname == 'lt'
    assert len(loop.links) == 2
    assert loop.links[0] in loop.headblock.exits
    assert loop.links[1] in loop.links[0].target.exits
    assert loop.links[1].target is loop.headblock

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_two_loops():
    def snippet_fn(x, y):
        while y > 0:
            y -= x
        while y < 0:
            y += x
        return y
    t = TranslationContext()
    graph = t.buildflowgraph(snippet_fn)
    if option.view:
        t.view()
    loops = find_inner_loops(graph)
    assert len(loops) == 2
    assert loops[0].headblock is not loops[1].headblock
    for loop in loops:
        assert loop.headblock.operations[0].opname in ('gt', 'lt')
        assert len(loop.links) == 2
        assert loop.links[0] in loop.headblock.exits
        assert loop.links[1] in loop.links[0].target.exits
        assert loop.links[1].target is loop.headblock

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_SSI_to_SSA():
    def snippet_fn(v1, v2, v3):
        if v1:                             # v4 = is_true(v1)
            while v3:                      # v5 = is_true(v3)
                pass
            passed_over = 0
        else:
            v6 = snippet_fn(v3, v2, v1)    # v6 = simple_call(v3, v2, v1)
            passed_over = v6
        v7 = passed_over                   # v7 = inputarg
        return v7+v1                       # v8 = add(v7, v1)

    t = TranslationContext()
    graph = t.buildflowgraph(snippet_fn)
    SSI_to_SSA(graph)
    allvars = []
    for block in graph.iterblocks():
            allvars += [v.name for v in block.getvariables()]
    # see comments above for where the 8 remaining variables are expected to be
    assert len(dict.fromkeys(allvars)) == 8

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
    def test_compile_array_access(self):
        def access_array(index):
            my_array = numpy.array([3,99,2])
            my_array[0] = 1
            return my_array[index]

        fn = self.compile(access_array, [int])
        assert fn(0) == 1
        assert fn(1) == 99
        
        t = TranslationContext()
        t.buildannotator().build_types(access_array, [int])
        t.buildrtyper().specialize()
        graph = t.buildflowgraph(access_array)
        
        from pypy.translator.tool.make_dot import make_dot
        filename = make_dot('access_array', graph)

        from pypy.translator.c.genc import CExtModuleBuilder
        b = CExtModuleBuilder(t, access_array)
        filename = b.generate_source()

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
 def test_measure_median_execution_cost(self):
     def f(x):
         x += 1
         x += 1
         x += 1
         while True:
             x += 1
             x += 1
             x += 1
             if x: break
             x += 1
             x += 1
             x += 1
             x += 1
             x += 1
         x += 1
         return x
     t = TranslationContext()
     graph = t.buildflowgraph(f)
     res = measure_median_execution_cost(graph)
     assert round(res, 5) == round(32.333333333, 5)

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_data_flow_families():
    def snippet_fn(xx, yy):
        while yy > 0:
            if 0 < xx:
                yy = yy - xx
            else:
                yy = yy + xx
        return yy
    t = TranslationContext()
    graph = t.buildflowgraph(snippet_fn)
    operations = []
    for block in graph.iterblocks():
        operations += block.operations

    variable_families = DataFlowFamilyBuilder(graph).get_variable_families()

    # we expect to find xx only once:
    v_xx = variable_families.find_rep(graph.getargs()[0])
    found = 0
    for op in operations:
        if op.opname in ('add', 'sub', 'lt'):
            assert variable_families.find_rep(op.args[1]) == v_xx
            found += 1
    assert found == 3

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
def test_example():
    t = TranslationContext(simplifying=True)
    t.buildflowgraph(example)

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
 def check(self, f1, expected):
     t = TranslationContext(list_comprehension_operations=True)
     graph = t.buildflowgraph(f1)
     if conftest.option.view:
         graph.show()
     assert summary(graph) == expected

# 需要导入模块: from pypy.translator.translator import TranslationContext [as 别名]
# 或者: from pypy.translator.translator.TranslationContext import buildflowgraph [as 别名]
class Translation(object):

    def __init__(self, entry_point, argtypes=None, **kwds):
        self.driver = driver.TranslationDriver(overrides=DEFAULTS)
        self.config = self.driver.config

        self.entry_point = entry_point
        self.context = TranslationContext(config=self.config)

        # hook into driver events
        driver_own_event = self.driver._event
        def _event(kind, goal, func):
            self.driver_event(kind, goal, func)
            driver_own_event(kind, goal, func)
        self.driver._event = _event
        self.driver_setup = False

        self.update_options(argtypes, kwds)
        # for t.view() to work just after construction
        graph = self.context.buildflowgraph(entry_point)
        self.context._prebuilt_graphs[entry_point] = graph

    def view(self):
        self.context.view()

    def viewcg(self):
        self.context.viewcg()

    def driver_event(self, kind, goal, func):
        if kind == 'pre':
             #print goal
             self.ensure_setup()
        elif kind == 'post':
            pass
            
    def ensure_setup(self, argtypes=None, policy=None, standalone=False):
        if not self.driver_setup:
            if standalone:
                assert argtypes is None
            else:
                if argtypes is None:
                    argtypes = []
            self.driver.setup(self.entry_point, argtypes, policy,
                              empty_translator=self.context)
            self.ann_argtypes = argtypes
            self.ann_policy = policy
            self.driver_setup = True
        else:
            # check consistency
            if standalone:
                assert argtypes is None
                assert self.ann_argtypes is None
            elif argtypes is not None and argtypes != self.ann_argtypes:
                raise Exception("inconsistent argtype supplied")
            if policy is not None and policy != self.ann_policy:
                raise Exception("inconsistent annotation polish supplied")

    def update_options(self, argtypes, kwds):
        if argtypes or kwds.get('policy') or kwds.get('standalone'):
            self.ensure_setup(argtypes, kwds.get('policy'),
                                        kwds.get('standalone'))
        kwds.pop('policy', None)
        kwds.pop('standalone', None)
        gc = kwds.pop('gc', None)
        if gc: self.config.translation.gc = gc
        self.config.translation.set(**kwds)

    def ensure_opt(self, name, value=None, fallback=None):
        if value is not None:
            self.update_options(None, {name: value})
            return value
        val = getattr(self.config.translation, name, None)
        if fallback is not None and val is None:
            self.update_options(None, {name: fallback})
            return fallback
        if val is not None:
            return val
        raise Exception(
                    "the %r option should have been specified at this point" %name)

    def ensure_type_system(self, type_system=None):
        if self.config.translation.backend is not None:
            return self.ensure_opt('type_system')
        return self.ensure_opt('type_system', type_system, 'lltype')
        
    def ensure_backend(self, backend=None):
        backend = self.ensure_opt('backend', backend)
        self.ensure_type_system()
        return backend

    # disable some goals (steps)
    def disable(self, to_disable):
        self.driver.disable(to_disable)

    def set_backend_extra_options(self, **extra_options):
        for name in extra_options:
            backend, option = name.split('_', 1)
            self.ensure_backend(backend)
        self.driver.set_backend_extra_options(extra_options)

#.........这里部分代码省略.........