def translate(self, func, sig):
t = TranslationContext()
t.buildannotator().build_types(func, sig)
t.buildrtyper().specialize()
if option.view:
t.view()
return t, RaiseAnalyzer(t)
def test_memoryerror(self):
def f(x):
return [x, 42]
t, ra = self.translate(f, [int])
result = ra.analyze_direct_call(graphof(t, f))
assert result
#
ra = RaiseAnalyzer(t)
ra.do_ignore_memory_error()
result = ra.analyze_direct_call(graphof(t, f))
assert not result
#
def g(x):
try:
return f(x)
except:
raise
t, ra = self.translate(g, [int])
ra.do_ignore_memory_error()
result = ra.analyze_direct_call(graphof(t, g))
assert not result
#
def h(x):
return {5:6}[x]
t, ra = self.translate(h, [int])
ra.do_ignore_memory_error() # but it's potentially a KeyError
result = ra.analyze_direct_call(graphof(t, h))
assert result
def simple_inline_function(translator, inline_func, graph):
inliner = Inliner(translator,
graph,
inline_func,
translator.rtyper.lltype_to_classdef_mapping(),
raise_analyzer=RaiseAnalyzer(translator))
return inliner.inline_all()
def __init__(self, cpu=None, jitdrivers_sd=[]):
assert isinstance(jitdrivers_sd, list) # debugging
self.cpu = cpu
self.jitdrivers_sd = jitdrivers_sd
self.jitcodes = {} # map {graph: jitcode}
self.unfinished_graphs = [] # list of graphs with pending jitcodes
self.callinfocollection = CallInfoCollection()
if hasattr(cpu, 'rtyper'): # for tests
self.rtyper = cpu.rtyper
translator = self.rtyper.annotator.translator
self.raise_analyzer = RaiseAnalyzer(translator)
self.raise_analyzer_ignore_memoryerror = RaiseAnalyzer(translator)
self.raise_analyzer_ignore_memoryerror.do_ignore_memory_error()
self.readwrite_analyzer = ReadWriteAnalyzer(translator)
self.virtualizable_analyzer = VirtualizableAnalyzer(translator)
self.quasiimmut_analyzer = QuasiImmutAnalyzer(translator)
self.randomeffects_analyzer = RandomEffectsAnalyzer(translator)
self.collect_analyzer = CollectAnalyzer(translator)
self.seen_rw = DependencyTracker(self.readwrite_analyzer)
self.seen_gc = DependencyTracker(self.collect_analyzer)
#
for index, jd in enumerate(jitdrivers_sd):
jd.index = index
def __init__(self, translator, inline=False):
self.translator = translator
self.seen_graphs = set()
self.prepared = False
self.minimal_transform = set()
if translator:
self.mixlevelannotator = MixLevelHelperAnnotator(translator.rtyper)
else:
self.mixlevelannotator = None
self.inline = inline
if translator and inline:
self.lltype_to_classdef = translator.rtyper.lltype_to_classdef_mapping()
self.raise_analyzer = RaiseAnalyzer(translator)
self.graphs_to_inline = {}
self.graph_dependencies = {}
self.ll_finalizers_ptrs = []
if self.MinimalGCTransformer:
self.minimalgctransformer = self.MinimalGCTransformer(self)
else:
self.minimalgctransformer = None
def inline_helpers(self, graph):
if not self.prepared:
raise Exception("Need to call prepare_inline_helpers first")
if self.inline:
raise_analyzer = RaiseAnalyzer(self.translator)
to_enum = self.graph_dependencies.get(graph, self.graphs_to_inline)
must_constfold = False
for inline_graph in to_enum:
try:
inline.inline_function(self.translator,
inline_graph,
graph,
self.lltype_to_classdef,
raise_analyzer,
cleanup=False)
must_constfold = True
except inline.CannotInline, e:
print 'CANNOT INLINE:', e
print '\t%s into %s' % (inline_graph, graph)
cleanup_graph(graph)
if must_constfold:
constant_fold_graph(graph)
def inline_helpers(self, graphs):
from rpython.translator.backendopt.inline import iter_callsites
raise_analyzer = RaiseAnalyzer(self.translator)
for graph in graphs:
to_enum = []
for called, block, i in iter_callsites(graph, None):
if called in self.graphs_to_inline:
to_enum.append(called)
must_constfold = False
for inline_graph in to_enum:
try:
inline.inline_function(self.translator,
inline_graph,
graph,
self.lltype_to_classdef,
raise_analyzer,
cleanup=False)
must_constfold = True
except inline.CannotInline, e:
print 'CANNOT INLINE:', e
print '\t%s into %s' % (inline_graph, graph)
cleanup_graph(graph)
if must_constfold:
constant_fold_graph(graph)
def auto_inlining(translator, threshold=None,
callgraph=None,
call_count_pred=None,
heuristic=inlining_heuristic):
assert threshold is not None and threshold != 1
to_cleanup = {}
from heapq import heappush, heappop, heapreplace, heapify
callers = {} # {graph: {graphs-that-call-it}}
callees = {} # {graph: {graphs-that-it-calls}}
if callgraph is None:
callgraph = inlinable_static_callers(translator.graphs)
for graph1, graph2 in callgraph:
callers.setdefault(graph2, {})[graph1] = True
callees.setdefault(graph1, {})[graph2] = True
# the -len(callers) change is OK
heap = [(0.0, -len(callers[graph]), graph) for graph in callers]
valid_weight = {}
try_again = {}
lltype_to_classdef = translator.rtyper.lltype_to_classdef_mapping()
raise_analyzer = RaiseAnalyzer(translator)
count = 0
while heap:
weight, _, graph = heap[0]
if not valid_weight.get(graph):
if always_inline(graph):
weight, fixed = 0.0, True
else:
weight, fixed = heuristic(graph)
# Don't let 'weight' be NaN past this point. If we do,
# then heapify() might (sometimes, rarely) not do its job
# correctly. I suspect it's because the algorithm gets
# confused by the fact that both 'a < b' and 'b < a' are
# false. A concrete example: [39.0, 0.0, 33.0, nan, nan]
# heapifies to [33.0, nan, 39.0, nan, 0.0], but 33.0 is
# not the smallest item.
if not (weight < 1e9):
weight = 1e9
#print ' + cost %7.2f %50s' % (weight, graph.name)
heapreplace(heap, (weight, -len(callers[graph]), graph))
valid_weight[graph] = True
if not fixed:
try_again[graph] = 'initial'
continue
if weight >= threshold:
# finished... unless some graphs not in valid_weight would now
# have a weight below the threshold. Re-insert such graphs
# at the start of the heap
finished = True
for i in range(len(heap)):
graph = heap[i][2]
if not valid_weight.get(graph):
heap[i] = (0.0, heap[i][1], graph)
finished = False
if finished:
break
else:
heapify(heap)
continue
heappop(heap)
if callers[graph]:
if translator.config.translation.verbose:
log.inlining('%7.2f %50s' % (weight, graph.name))
else:
log.dot()
for parentgraph in callers[graph]:
if parentgraph == graph:
continue
subcount = 0
try:
subcount = inline_function(translator, graph, parentgraph,
lltype_to_classdef, raise_analyzer,
call_count_pred, cleanup=False)
to_cleanup[parentgraph] = True
res = bool(subcount)
except CannotInline as e:
try_again[graph] = str(e)
res = CannotInline
if res is True:
count += subcount
# the parentgraph should now contain all calls that were
# done by 'graph'
for graph2 in callees.get(graph, {}):
callees[parentgraph][graph2] = True
callers[graph2][parentgraph] = True
if parentgraph in try_again:
# the parentgraph was previously uninlinable, but it has
# been modified. Maybe now we can inline it into further
# parents?
del try_again[parentgraph]
heappush(heap, (0.0, -len(callers[parentgraph]), parentgraph))
valid_weight[parentgraph] = False
invalid = [(graph, msg) for graph, msg in try_again.items()
if always_inline(graph) is True]
if invalid:
message = '\n'.join([
"%s has _always_inline_=True but inlining failed:\n\t%s" %
(graph, msg) for (graph, msg) in invalid])
raise CannotInline(message)
for graph in to_cleanup:
cleanup_graph(graph)
return count
def auto_inlining(translator,
threshold=None,
callgraph=None,
call_count_pred=None,
heuristic=inlining_heuristic):
assert threshold is not None and threshold != 1
to_cleanup = {}
from heapq import heappush, heappop, heapreplace, heapify
callers = {} # {graph: {graphs-that-call-it}}
callees = {} # {graph: {graphs-that-it-calls}}
if callgraph is None:
callgraph = inlinable_static_callers(translator.graphs)
for graph1, graph2 in callgraph:
callers.setdefault(graph2, {})[graph1] = True
callees.setdefault(graph1, {})[graph2] = True
# the -len(callers) change is OK
heap = [(0.0, -len(callers[graph]), graph) for graph in callers]
valid_weight = {}
try_again = {}
lltype_to_classdef = translator.rtyper.lltype_to_classdef_mapping()
raise_analyzer = RaiseAnalyzer(translator)
count = 0
while heap:
weight, _, graph = heap[0]
if not valid_weight.get(graph):
if always_inline(graph):
weight, fixed = 0.0, True
else:
weight, fixed = heuristic(graph)
#print ' + cost %7.2f %50s' % (weight, graph.name)
heapreplace(heap, (weight, -len(callers[graph]), graph))
valid_weight[graph] = True
if not fixed:
try_again[graph] = 'initial'
continue
if weight >= threshold:
# finished... unless some graphs not in valid_weight would now
# have a weight below the threshold. Re-insert such graphs
# at the start of the heap
finished = True
for i in range(len(heap)):
graph = heap[i][2]
if not valid_weight.get(graph):
heap[i] = (0.0, heap[i][1], graph)
finished = False
if finished:
break
else:
heapify(heap)
continue
heappop(heap)
if callers[graph]:
if translator.config.translation.verbose:
log.inlining('%7.2f %50s' % (weight, graph.name))
else:
log.dot()
for parentgraph in callers[graph]:
if parentgraph == graph:
continue
subcount = 0
try:
subcount = inline_function(translator,
graph,
parentgraph,
lltype_to_classdef,
raise_analyzer,
call_count_pred,
cleanup=False)
to_cleanup[parentgraph] = True
res = bool(subcount)
except CannotInline, e:
try_again[graph] = str(e)
res = CannotInline
if res is True:
count += subcount
# the parentgraph should now contain all calls that were
# done by 'graph'
for graph2 in callees.get(graph, {}):
callees[parentgraph][graph2] = True
callers[graph2][parentgraph] = True
if parentgraph in try_again:
# the parentgraph was previously uninlinable, but it has
# been modified. Maybe now we can inline it into further
# parents?
del try_again[parentgraph]
heappush(heap,
(0.0, -len(callers[parentgraph]), parentgraph))
valid_weight[parentgraph] = False