1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
from rpython.annotator import model as annmodel
from rpython.rtyper.llannotation import SomePtr, lltype_to_annotation
from rpython.rtyper.annlowlevel import (
cast_instance_to_gcref, cast_gcref_to_instance, llstr)
from rpython.rtyper.extregistry import ExtRegistryEntry
from rpython.rtyper.lltypesystem import llmemory, lltype
from rpython.flowspace.model import Constant
def register_helper(s_result):
def wrapper(helper):
class Entry(ExtRegistryEntry):
_about_ = helper
def compute_result_annotation(self, *args):
if (isinstance(s_result, annmodel.SomeObject) or
s_result is None):
return s_result
return lltype_to_annotation(s_result)
def specialize_call(self, hop):
from rpython.rtyper.lltypesystem import lltype
c_func = hop.inputconst(lltype.Void, helper)
c_name = hop.inputconst(lltype.Void, 'access_helper')
args_v = [hop.inputarg(arg, arg=i)
for i, arg in enumerate(hop.args_r)]
hop.exception_cannot_occur()
return hop.genop('jit_marker', [c_name, c_func] + args_v,
resulttype=hop.r_result)
return helper
return wrapper
def _cast_to_box(llref):
from rpython.jit.metainterp.history import AbstractValue
return cast_gcref_to_instance(AbstractValue, llref)
def _cast_to_resop(llref):
from rpython.jit.metainterp.resoperation import AbstractResOp
return cast_gcref_to_instance(AbstractResOp, llref)
_cast_to_gcref = cast_instance_to_gcref
def emptyval():
return lltype.nullptr(llmemory.GCREF.TO)
@register_helper(SomePtr(llmemory.GCREF))
def resop_new(no, llargs, llres):
from rpython.jit.metainterp.history import ResOperation
args = [_cast_to_box(llargs[i]) for i in range(len(llargs))]
if llres:
res = _cast_to_box(llres)
else:
res = None
return _cast_to_gcref(ResOperation(no, args, res))
@register_helper(annmodel.SomeInteger())
def resop_getopnum(llop):
return _cast_to_resop(llop).getopnum()
@register_helper(annmodel.SomeString(can_be_None=True))
def resop_getopname(llop):
return llstr(_cast_to_resop(llop).getopname())
@register_helper(SomePtr(llmemory.GCREF))
def resop_getarg(llop, no):
return _cast_to_gcref(_cast_to_resop(llop).getarg(no))
@register_helper(annmodel.s_None)
def resop_setarg(llop, no, llbox):
_cast_to_resop(llop).setarg(no, _cast_to_box(llbox))
@register_helper(annmodel.SomeInteger())
def box_getint(llbox):
return _cast_to_box(llbox).getint()
@register_helper(SomePtr(llmemory.GCREF))
def box_clone(llbox):
return _cast_to_gcref(_cast_to_box(llbox).clonebox())
@register_helper(SomePtr(llmemory.GCREF))
def box_constbox(llbox):
return _cast_to_gcref(_cast_to_box(llbox).constbox())
@register_helper(SomePtr(llmemory.GCREF))
def box_nonconstbox(llbox):
return _cast_to_gcref(_cast_to_box(llbox).nonconstbox())
@register_helper(annmodel.SomeBool())
def box_isconst(llbox):
from rpython.jit.metainterp.history import Const
return isinstance(_cast_to_box(llbox), Const)
@register_helper(annmodel.SomeBool())
def box_isint(llbox):
from rpython.jit.metainterp.history import INT
return _cast_to_box(llbox).type == INT
# ------------------------- stats interface ---------------------------
@register_helper(annmodel.SomeBool())
def stats_set_debug(warmrunnerdesc, flag):
return warmrunnerdesc.metainterp_sd.cpu.set_debug(flag)
@register_helper(annmodel.SomeInteger())
def stats_get_counter_value(warmrunnerdesc, no):
return warmrunnerdesc.metainterp_sd.profiler.get_counter(no)
@register_helper(annmodel.SomeFloat())
def stats_get_times_value(warmrunnerdesc, no):
return warmrunnerdesc.metainterp_sd.profiler.get_times(no)
LOOP_RUN_CONTAINER = lltype.GcArray(lltype.Struct('elem',
('type', lltype.Char),
('number', lltype.Signed),
('counter', lltype.Signed)))
@register_helper(lltype.Ptr(LOOP_RUN_CONTAINER))
def stats_get_loop_run_times(warmrunnerdesc):
return warmrunnerdesc.metainterp_sd.cpu.get_all_loop_runs()
@register_helper(annmodel.SomeInteger(unsigned=True))
def stats_asmmemmgr_allocated(warmrunnerdesc):
return warmrunnerdesc.metainterp_sd.cpu.asmmemmgr.get_stats()[0]
@register_helper(annmodel.SomeInteger(unsigned=True))
def stats_asmmemmgr_used(warmrunnerdesc):
return warmrunnerdesc.metainterp_sd.cpu.asmmemmgr.get_stats()[1]
@register_helper(None)
def stats_memmgr_release_all(warmrunnerdesc):
warmrunnerdesc.memory_manager.release_all_loops()
# ---------------------- jitcell interface ----------------------
def _new_hook(name, resulttype):
def hook(name, *greenkey):
raise Exception("need to run translated")
hook.__name__ = name
class GetJitCellEntry(ExtRegistryEntry):
_about_ = hook
def compute_result_annotation(self, s_name, *args_s):
assert s_name.is_constant()
return resulttype
def specialize_call(self, hop):
c_jitdriver = Constant(hop.args_s[0].const, concretetype=lltype.Void)
c_name = Constant(name, concretetype=lltype.Void)
hop.exception_cannot_occur()
args_v = [hop.inputarg(arg, arg=i + 1)
for i, arg in enumerate(hop.args_r[1:])]
return hop.genop('jit_marker', [c_name, c_jitdriver] + args_v,
resulttype=hop.r_result)
return hook
get_jitcell_at_key = _new_hook('get_jitcell_at_key', SomePtr(llmemory.GCREF))
trace_next_iteration = _new_hook('trace_next_iteration', None)
dont_trace_here = _new_hook('dont_trace_here', None)
mark_as_being_traced = _new_hook('mark_as_being_traced', None)
trace_next_iteration_hash = _new_hook('trace_next_iteration_hash', None)
|
