def make_guards(self, box):
guards = []
level = self.getlevel()
if level == LEVEL_CONSTANT:
op = ResOperation(rop.GUARD_VALUE, [box, self.box], None)
guards.append(op)
elif level == LEVEL_KNOWNCLASS:
op = ResOperation(rop.GUARD_NONNULL_CLASS, [box, self.known_class],
None)
guards.append(op)
else:
if level == LEVEL_NONNULL:
op = ResOperation(rop.GUARD_NONNULL, [box], None)
guards.append(op)
if self.lenbound:
lenbox = BoxInt()
if self.lenbound.mode == MODE_ARRAY:
op = ResOperation(rop.ARRAYLEN_GC, [box], lenbox,
self.lenbound.descr)
elif self.lenbound.mode == MODE_STR:
op = ResOperation(rop.STRLEN, [box], lenbox,
self.lenbound.descr)
elif self.lenbound.mode == MODE_UNICODE:
op = ResOperation(rop.UNICODELEN, [box], lenbox,
self.lenbound.descr)
else:
debug_print("Unknown lenbound mode")
assert False
guards.append(op)
self.lenbound.bound.make_guards(lenbox, guards)
return guards
def f():
state.data = []
state.datalen1 = 0
state.datalen2 = 0
state.datalen3 = 0
state.datalen4 = 0
state.threadlocals = my_gil_threadlocals
state.threadlocals.setup_threads(space)
subident = thread.start_new_thread(bootstrap, ())
mainident = thread.get_ident()
runme(True)
still_waiting = 3000
while len(state.data) < 2 * N:
debug_print(len(state.data))
if not still_waiting:
raise ValueError("time out")
still_waiting -= 1
if not we_are_translated(): gil.before_external_call()
time.sleep(0.01)
if not we_are_translated(): gil.after_external_call()
debug_print("leaving!")
i1 = i2 = 0
for tid, i in state.data:
if tid == mainident:
assert i == i1
i1 += 1
elif tid == subident:
assert i == i2
i2 += 1
else:
assert 0
assert i1 == N + skew
assert i2 == N - skew
return len(state.data)
def evaluateTerms(codes, scope):
result = NullObject
for code in codes:
result = evaluateWithTraces(code, scope)
if result is None:
debug_print("Evaluation returned None!")
return result
def debug_print(self, hdr='', bad=None):
if bad is None:
bad = {}
debug_print(hdr + "VirtualState():")
seen = {}
for s in self.state:
s.debug_print(" ", seen, bad)
def disable_noninlinable_function(self, greenkey):
cell = self.JitCell.ensure_jit_cell_at_key(greenkey)
cell.flags |= JC_DONT_TRACE_HERE
debug_start("jit-disableinlining")
loc = self.get_location_str(greenkey)
debug_print("disabled inlining", loc)
debug_stop("jit-disableinlining")
def _do(self, goal, func, *args, **kwds):
title = func.task_title
if goal in self.done:
self.log.info("already done: %s" % title)
return
else:
self.log.info("%s..." % title)
debug_start('translation-task')
debug_print('starting', goal)
self.timer.start_event(goal)
try:
instrument = False
try:
if goal in PROFILE:
res = self._profile(goal, func)
else:
res = func()
except Instrument:
instrument = True
if not func.task_idempotent:
self.done[goal] = True
if instrument:
self.proceed('compile')
assert False, 'we should not get here'
finally:
try:
debug_stop('translation-task')
self.timer.end_event(goal)
except (KeyboardInterrupt, SystemExit):
raise
except:
pass
#import gc; gc.dump_rpy_heap('rpyheap-after-%s.dump' % goal)
return res
def runUntilDone(vatManager, uv_loop, recorder):
# This may take a while.
anyVatHasTurns = vatManager.anyVatHasTurns()
while anyVatHasTurns or ruv.loopAlive(uv_loop):
for vat in vatManager.vats:
if vat.hasTurns():
with scopedVat(vat) as vat:
with recorder.context("Time spent in vats"):
vat.takeSomeTurns()
if ruv.loopAlive(uv_loop):
with recorder.context("Time spent in I/O"):
ruv.cleanup()
try:
if anyVatHasTurns:
# More work to be done, so don't block.
ruv.run(uv_loop, ruv.RUN_NOWAIT)
else:
# No more work to be done, so blocking is fine.
ruv.run(uv_loop, ruv.RUN_ONCE)
except CompilerFailed as cf:
debug_print("Caught fatal exception while reacting:",
cf.formatError())
raise
except UserException as ue:
debug_print("Caught exception while reacting:",
ue.formatError())
anyVatHasTurns = vatManager.anyVatHasTurns()
def runUntilDone(vatManager, uv_loop, recorder):
# This may take a while.
anyVatHasTurns = vatManager.anyVatHasTurns()
while anyVatHasTurns or ruv.loopAlive(uv_loop):
for vat in vatManager.vats:
if vat.hasTurns():
with scopedVat(vat) as vat:
with recorder.context("Time spent in vats"):
vat.takeSomeTurns()
if ruv.loopAlive(uv_loop):
with recorder.context("Time spent in I/O"):
ruv.cleanup()
try:
if anyVatHasTurns:
# More work to be done, so don't block.
ruv.run(uv_loop, ruv.RUN_NOWAIT)
else:
# No more work to be done, so blocking is fine.
ruv.run(uv_loop, ruv.RUN_ONCE)
except CompilerFailed as cf:
debug_print("Caught fatal exception while reacting:",
cf.formatError())
raise
except UserException as ue:
debug_print("Caught exception while reacting:",
ue.formatError())
anyVatHasTurns = vatManager.anyVatHasTurns()
def malloc(self, TYPE, n=None):
addr = self.gc.malloc(self.get_type_id(TYPE), n)
debug_print(self.gc)
obj_ptr = llmemory.cast_adr_to_ptr(addr, lltype.Ptr(TYPE))
if not self.gc.malloc_zero_filled:
zero_gc_pointers_inside(obj_ptr, TYPE)
return obj_ptr
def invalidate(self, descr_repr=None):
debug_start("jit-invalidate-quasi-immutable")
# When this is called, all the loops that we record become
# invalid: all GUARD_NOT_INVALIDATED in these loops (and
# in attached bridges) must now fail.
if self.looptokens_wrefs is None:
# can't happen, but helps compiled tests
return
wrefs = self.looptokens_wrefs
self.looptokens_wrefs = []
invalidated = 0
for wref in wrefs:
looptoken = wref()
if looptoken is not None:
invalidated += 1
looptoken.invalidated = True
self.cpu.invalidate_loop(looptoken)
# NB. we must call cpu.invalidate_loop() even if
# looptoken.invalidated was already set to True.
# It's possible to invalidate several times the
# same looptoken; see comments in jit.backend.model
# in invalidate_loop().
if not we_are_translated():
self.cpu.stats.invalidated_token_numbers.add(
looptoken.number)
debug_print("fieldname", descr_repr or "<unknown>", "invalidated",
invalidated)
debug_stop("jit-invalidate-quasi-immutable")
def get_L2cache_linux2_sparc():
debug_start("gc-hardware")
cpu = 0
L2cache = sys.maxint
while True:
try:
fd = os.open('/sys/devices/system/cpu/cpu' + assert_str0(str(cpu))
+ '/l2_cache_size', os.O_RDONLY, 0644)
try:
line = os.read(fd, 4096)
finally:
os.close(fd)
end = len(line) - 1
assert end > 0
number = int(line[:end])
except OSError:
break
if number < L2cache:
L2cache = number
cpu += 1
debug_print("L2cache =", L2cache)
debug_stop("gc-hardware")
if L2cache < sys.maxint:
return L2cache
else:
# Print a top-level warning even in non-debug builds
llop.debug_print(lltype.Void,
"Warning: cannot find your CPU L2 cache size in "
"/sys/devices/system/cpu/cpuX/l2_cache_size")
return -1
def f(x):
debug_start("mycat")
debug_print("foo", 2, "bar", x)
debug_stop("mycat")
debug_flush() # does nothing
debug_offset() # should not explode at least
return have_debug_prints()
def connectCB(connect, status):
status = intmask(status)
stream = connect.c_handle
try:
vat, resolvers = ruv.unstashStream(stream)
fountResolver, drainResolver = unwrapList(resolvers)
assert isinstance(fountResolver, LocalResolver)
assert isinstance(drainResolver, LocalResolver)
with scopedVat(vat):
if status >= 0:
debug_print("Made connection!")
fountResolver.resolve(StreamFount(stream, vat))
drainResolver.resolve(StreamDrain(stream, vat))
else:
error = "Connection failed: " + ruv.formatError(status)
debug_print(error)
fountResolver.smash(StrObject(error.decode("utf-8")))
drainResolver.smash(StrObject(error.decode("utf-8")))
# Done with stream.
ruv.closeAndFree(stream)
except:
if not we_are_translated():
raise
def get_total_memory_linux(filename):
debug_start("gc-hardware")
result = -1.0
try:
fd = os.open(filename, os.O_RDONLY, 0644)
try:
buf = os.read(fd, 4096)
finally:
os.close(fd)
except OSError:
pass
else:
if buf.startswith('MemTotal:'):
start = _skipspace(buf, len('MemTotal:'))
stop = start
while stop < len(buf) and buf[stop].isdigit():
stop += 1
if start < stop:
result = float(buf[start:stop]) * 1024.0 # assume kB
if result < 0.0:
debug_print("get_total_memory() failed")
result = addressable_size
else:
debug_print("memtotal =", result)
if result > addressable_size:
result = addressable_size
debug_stop("gc-hardware")
return result
def get_L2cache_linux2_sparc():
debug_start("gc-hardware")
cpu = 0
L2cache = sys.maxint
while True:
try:
fd = os.open(
'/sys/devices/system/cpu/cpu' + assert_str0(str(cpu)) +
'/l2_cache_size', os.O_RDONLY, 0644)
try:
line = os.read(fd, 4096)
finally:
os.close(fd)
end = len(line) - 1
assert end > 0
number = int(line[:end])
except OSError:
break
if number < L2cache:
L2cache = number
cpu += 1
debug_print("L2cache =", L2cache)
debug_stop("gc-hardware")
if L2cache < sys.maxint:
return L2cache
else:
# Print a top-level warning even in non-debug builds
llop.debug_print(
lltype.Void, "Warning: cannot find your CPU L2 cache size in "
"/sys/devices/system/cpu/cpuX/l2_cache_size")
return -1
def connectStreamCB(connect, status):
status = intmask(status)
stream = connect.c_handle
try:
vat, resolvers = ruv.unstashStream(stream)
sourceResolver, sinkResolver = unwrapList(resolvers)
assert isinstance(sourceResolver, LocalResolver)
assert isinstance(sinkResolver, LocalResolver)
with scopedVat(vat):
if status >= 0:
debug_print("Made connection!")
wrappedStream = ruv.wrapStream(stream, 2)
sourceResolver.resolve(StreamSource(wrappedStream, vat))
sinkResolver.resolve(StreamSink(wrappedStream, vat))
else:
error = "Connection failed: " + ruv.formatError(status)
debug_print(error)
sourceResolver.smash(StrObject(error.decode("utf-8")))
sinkResolver.smash(StrObject(error.decode("utf-8")))
# Done with stream.
ruv.closeAndFree(stream)
except:
if not we_are_translated():
raise
def dump(self, memo):
if have_debug_prints():
debug_start("jit-log-exported-state")
debug_print("[" + ", ".join([x.repr_short(memo) for x in self.next_iteration_args]) + "]")
for box in self.short_boxes:
debug_print(" " + box.repr(memo))
debug_stop("jit-log-exported-state")
def get_L2cache_linux2_cpuinfo(filename="/proc/cpuinfo", label='cache size'):
debug_start("gc-hardware")
L2cache = sys.maxint
try:
fd = os.open(filename, os.O_RDONLY, 0644)
try:
data = []
while True:
buf = os.read(fd, 4096)
if not buf:
break
data.append(buf)
finally:
os.close(fd)
except OSError:
pass
else:
data = ''.join(data)
linepos = 0
while True:
start = _findend(data, '\n' + label, linepos)
if start < 0:
break # done
linepos = _findend(data, '\n', start)
if linepos < 0:
break # no end-of-line??
# *** data[start:linepos] == " : 2048 KB\n"
start = _skipspace(data, start)
if data[start] != ':':
continue
# *** data[start:linepos] == ": 2048 KB\n"
start = _skipspace(data, start + 1)
# *** data[start:linepos] == "2048 KB\n"
end = start
while '0' <= data[end] <= '9':
end += 1
# *** data[start:end] == "2048"
if start == end:
continue
number = int(data[start:end])
# *** data[end:linepos] == " KB\n"
end = _skipspace(data, end)
if data[end] not in ('K', 'k'): # assume kilobytes for now
continue
number = number * 1024
# for now we look for the smallest of the L2 caches of the CPUs
if number < L2cache:
L2cache = number
debug_print("L2cache =", L2cache)
debug_stop("gc-hardware")
if L2cache < sys.maxint:
return L2cache
else:
# Print a top-level warning even in non-debug builds
llop.debug_print(
lltype.Void,
"Warning: cannot find your CPU L2 cache size in /proc/cpuinfo")
return -1
def f():
state.data = []
state.datalen1 = 0
state.datalen2 = 0
state.datalen3 = 0
state.datalen4 = 0
state.threadlocals = gil.GILThreadLocals()
state.threadlocals.setup_threads(space)
thread.gc_thread_prepare()
subident = thread.start_new_thread(bootstrap, ())
mainident = thread.get_ident()
runme(True)
still_waiting = 3000
while len(state.data) < 2*N:
debug_print(len(state.data))
if not still_waiting:
raise ValueError("time out")
still_waiting -= 1
if not we_are_translated(): gil.before_external_call()
time.sleep(0.01)
if not we_are_translated(): gil.after_external_call()
debug_print("leaving!")
i1 = i2 = 0
for tid, i in state.data:
if tid == mainident:
assert i == i1; i1 += 1
elif tid == subident:
assert i == i2; i2 += 1
else:
assert 0
assert i1 == N + skew
assert i2 == N - skew
return len(state.data)
def malloc(self, TYPE, n=None):
addr = self.gc.malloc(self.get_type_id(TYPE), n)
debug_print(self.gc)
obj_ptr = llmemory.cast_adr_to_ptr(addr, lltype.Ptr(TYPE))
if not self.gc.malloc_zero_filled:
zero_gc_pointers_inside(obj_ptr, TYPE)
return obj_ptr
def get_L2cache_linux2_cpuinfo_s390x(filename="/proc/cpuinfo", label='cache3'):
debug_start("gc-hardware")
L2cache = sys.maxint
try:
fd = os.open(filename, os.O_RDONLY, 0644)
try:
data = []
while True:
buf = os.read(fd, 4096)
if not buf:
break
data.append(buf)
finally:
os.close(fd)
except OSError:
pass
else:
data = ''.join(data)
linepos = 0
while True:
start = _findend(data, '\n' + label, linepos)
if start < 0:
break # done
linepos = _findend(data, '\n', start)
if linepos < 0:
break # no end-of-line??
# *** data[start:linepos] == " : level=2 type=Instruction scope=Private size=2048K ..."
start = _skipspace(data, start)
if data[start] != ':':
continue
# *** data[start:linepos] == ": level=2 type=Instruction scope=Private size=2048K ..."
start = _skipspace(data, start + 1)
# *** data[start:linepos] == "level=2 type=Instruction scope=Private size=2048K ..."
start += 44
end = start
while '0' <= data[end] <= '9':
end += 1
# *** data[start:end] == "2048"
if start == end:
continue
number = int(data[start:end])
# *** data[end:linepos] == " KB\n"
end = _skipspace(data, end)
if data[end] not in ('K', 'k'): # assume kilobytes for now
continue
number = number * 1024
# for now we look for the smallest of the L2 caches of the CPUs
if number < L2cache:
L2cache = number
debug_print("L2cache =", L2cache)
debug_stop("gc-hardware")
if L2cache < sys.maxint:
return L2cache
else:
# Print a top-level warning even in non-debug builds
llop.debug_print(lltype.Void,
"Warning: cannot find your CPU L2 cache size in /proc/cpuinfo")
return -1
def disable_noninlinable_function(self, greenkey):
cell = self.jit_cell_at_key(greenkey)
cell.dont_trace_here = True
debug_start("jit-disableinlining")
loc = self.get_location_str(greenkey)
debug_print("disabled inlining", loc)
debug_stop("jit-disableinlining")
def load_linklet_from_fasl(file_name, set_version=False):
from pycket.fasl import Fasl
from pycket.env import w_version
from pycket.util import console_log
from pycket.ast_vs_sexp import deserialize_loop
debug_start("loading-linklet")
debug_print("Loading linklet from fasl -- %s" % file_name)
sexp = Fasl().to_sexp_from_file(file_name)
version_sexp, linklet_sexp = W_String.make(""), None
if set_version:
version_sexp = sexp.car()
linklet_sexp = sexp.cdr()
else:
linklet_sexp = sexp
linklet = None
if "zo" in file_name:
linklet = deserialize_loop(linklet_sexp)
else:
console_log("Run pycket with --make-linklet-zos to make the compiled zo files for bootstrap linklets", 1)
compile_linklet = get_primitive("compile-linklet")
linklet = compile_linklet.call_interpret([linklet_sexp, W_Symbol.make("linkl"), w_false, w_false, w_false])
if set_version:
ver = version_sexp.as_str_ascii()
console_log("Setting the version to %s" % ver)
w_version.set_version(ver)
debug_stop("loading-linklet")
return linklet, version_sexp
def debug_print(self, indent, seen, bad, metainterp_sd=None):
mark = ''
if self in bad:
mark = '*'
if self.level == LEVEL_UNKNOWN:
l = "Unknown"
elif self.level == LEVEL_NONNULL:
l = "NonNull"
elif self.level == LEVEL_KNOWNCLASS:
addr = self.known_class.getaddr()
if metainterp_sd:
name = metainterp_sd.get_name_from_address(addr)
else:
name = "?"
l = "KnownClass(%s)" % name
else:
assert self.level == LEVEL_CONSTANT
const = self.constbox
if isinstance(const, ConstInt):
l = "ConstInt(%s)" % (const.value, )
elif isinstance(const, ConstPtr):
if const.value:
l = "ConstPtr"
else:
l = "ConstPtr(null)"
else:
assert isinstance(const, ConstFloat)
l = "ConstFloat(%s)" % const.getfloat()
lb = ''
if self.lenbound:
lb = ', ' + self.lenbound.bound.__repr__()
debug_print(indent + mark + 'NotVirtualInfo(%d' % self.position +
', ' + l + ', ' + self.intbound.__repr__() + lb + ')')
def make_guards(self, box):
guards = []
if self.level == LEVEL_CONSTANT:
op = ResOperation(rop.GUARD_VALUE, [box, self.box], None)
guards.append(op)
elif self.level == LEVEL_KNOWNCLASS:
op = ResOperation(rop.GUARD_NONNULL, [box], None)
guards.append(op)
op = ResOperation(rop.GUARD_CLASS, [box, self.known_class], None)
guards.append(op)
else:
if self.level == LEVEL_NONNULL:
op = ResOperation(rop.GUARD_NONNULL, [box], None)
guards.append(op)
self.intbound.make_guards(box, guards)
if self.lenbound:
lenbox = BoxInt()
if self.lenbound.mode == MODE_ARRAY:
op = ResOperation(rop.ARRAYLEN_GC, [box], lenbox, self.lenbound.descr)
elif self.lenbound.mode == MODE_STR:
op = ResOperation(rop.STRLEN, [box], lenbox, self.lenbound.descr)
elif self.lenbound.mode == MODE_UNICODE:
op = ResOperation(rop.UNICODELEN, [box], lenbox, self.lenbound.descr)
else:
debug_print("Unknown lenbound mode")
assert False
guards.append(op)
self.lenbound.bound.make_guards(lenbox, guards)
return guards
def _do(self, goal, func, *args, **kwds):
title = func.task_title
if goal in self.done:
self.log.info("already done: %s" % title)
return
else:
self.log.info("%s..." % title)
debug_start('translation-task')
debug_print('starting', goal)
self.timer.start_event(goal)
try:
instrument = False
try:
if goal in PROFILE:
res = self._profile(goal, func)
else:
res = func()
except Instrument:
instrument = True
if not func.task_idempotent:
self.done[goal] = True
if instrument:
self.proceed('compile')
assert False, 'we should not get here'
finally:
try:
debug_stop('translation-task')
self.timer.end_event(goal)
except (KeyboardInterrupt, SystemExit):
raise
except:
pass
#import gc; gc.dump_rpy_heap('rpyheap-after-%s.dump' % goal)
return res
def f():
state.data = []
state.datalen1 = 0
state.datalen2 = 0
state.datalen3 = 0
state.datalen4 = 0
state.threadlocals = my_gil_threadlocals
state.threadlocals.setup_threads(space)
subident = thread.start_new_thread(bootstrap, ())
mainident = thread.get_ident()
runme(True)
still_waiting = 3000
while len(state.data) < 2*N:
debug_print(len(state.data))
if not still_waiting:
llop.debug_print(lltype.Void, "timeout. progress: "
"%d of 2*N (= %f%%)" % \
(len(state.data), 2*N, 100*len(state.data)/(2.0*N)))
raise ValueError("time out")
still_waiting -= 1
if not we_are_translated(): rgil.release()
time.sleep(0.1)
if not we_are_translated(): rgil.acquire()
debug_print("leaving!")
i1 = i2 = 0
for tid, i in state.data:
if tid == mainident:
assert i == i1; i1 += 1
elif tid == subident:
assert i == i2; i2 += 1
else:
assert 0
assert i1 == N + skew
assert i2 == N - skew
return len(state.data)
def f(x):
debug_start("mycat")
debug_print("foo", 2, "bar", x)
debug_stop("mycat")
debug_flush() # does nothing
debug_offset() # should not explode at least
return have_debug_prints()
def can_be_packed(self, lnode, rnode, origin_pack, forward):
""" Check to ensure that two nodes might be packed into a Pair.
"""
if isomorphic(lnode.getoperation(), rnode.getoperation()):
# even if a guard depends on the previous it is able to
lop = lnode.getoperation()
independent = lnode.independent(rnode)
if independent:
if forward and origin_pack.is_accumulating():
# in this case the splitted accumulator must
# be combined. This case is not supported
debug_print("splitted accum must be flushed here (not supported)")
raise NotAVectorizeableLoop
#
if self.contains_pair(lnode, rnode):
return None
#
if origin_pack is None:
op = lnode.getoperation()
if rop.is_primitive_load(op.opnum):
return Pair(lnode, rnode)
else:
return Pair(lnode, rnode)
if self.profitable_pack(lnode, rnode, origin_pack, forward):
return Pair(lnode, rnode)
else:
if self.contains_pair(lnode, rnode):
return None
if origin_pack is not None:
return self.accumulates_pair(lnode, rnode, origin_pack)
return None
def compile_trace(metainterp, resumekey):
"""Try to compile a new bridge leading from the beginning of the history
to some existing place.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
#
# Attempt to use optimize_bridge(). This may return None in case
# it does not work -- i.e. none of the existing old_loop_tokens match.
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
if isinstance(resumekey, ResumeAtPositionDescr):
inline_short_preamble = False
else:
inline_short_preamble = True
inputargs = metainterp.history.inputargs[:]
operations = metainterp.history.operations
label = ResOperation(rop.LABEL, inputargs)
jitdriver_sd = metainterp.jitdriver_sd
enable_opts = jitdriver_sd.warmstate.enable_opts
call_pure_results = metainterp.call_pure_results
if operations[-1].getopnum() == rop.JUMP:
data = BridgeCompileData(label, operations[:],
call_pure_results=call_pure_results,
enable_opts=enable_opts,
inline_short_preamble=inline_short_preamble)
else:
data = SimpleCompileData(label, operations[:],
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
info, newops = optimize_trace(metainterp_sd, jitdriver_sd,
data, metainterp.box_names_memo)
except InvalidLoop:
#pdb.post_mortem(sys.exc_info()[2])
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
debug_print('InvalidLoop in compile_new_bridge')
return None
new_trace = create_empty_loop(metainterp)
new_trace.operations = newops
if info.quasi_immutable_deps:
new_trace.quasi_immutable_deps = info.quasi_immutable_deps
if info.final():
new_trace.inputargs = info.inputargs
target_token = new_trace.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, new_trace, inputargs)
record_loop_or_bridge(metainterp_sd, new_trace)
return target_token
new_trace.inputargs = info.renamed_inputargs
metainterp.retrace_needed(new_trace, info)
return None
def load_linklet_from_fasl(file_name, set_version=False):
from pycket.fasl import Fasl
from pycket.env import w_version
from pycket.util import console_log
from pycket.ast_vs_sexp import deserialize_loop
debug_start("loading-linklet")
debug_print("Loading linklet from fasl -- %s" % file_name)
sexp = Fasl().to_sexp_from_file(file_name)
version_sexp, linklet_sexp = W_String.make(""), None
if set_version:
version_sexp = sexp.car()
linklet_sexp = sexp.cdr()
else:
linklet_sexp = sexp
linklet = None
if "zo" in file_name:
linklet = deserialize_loop(linklet_sexp)
else:
console_log("Run pycket with --make-linklet-zos to make the compiled zo files for bootstrap linklets", 1)
compile_linklet = get_primitive("compile-linklet")
linklet = compile_linklet.call_interpret([linklet_sexp, W_Symbol.make("linkl"), w_false, w_false, w_false])
if set_version:
ver = version_sexp.as_str_ascii()
console_log("Setting the version to %s" % ver)
w_version.set_version(ver)
debug_stop("loading-linklet")
return linklet, version_sexp
def evaluateTerms(codes, scope):
result = NullObject
for code in codes:
result = evaluateWithTraces(code, scope)
if result is None:
debug_print("Evaluation returned None!")
return result
def errorWithSpan(self, problem, span):
"""
Throw a fatal error with span information.
"""
debug_print(problem.encode("utf-8"))
raise CompilerFailed(problem, span)
def debug_print(self, hdr="", bad=None, metainterp_sd=None):
if bad is None:
bad = {}
debug_print(hdr + "VirtualState():")
seen = {}
for s in self.state:
s.debug_print(" ", seen, bad, metainterp_sd)
def dump(self, memo):
if have_debug_prints():
debug_start("jit-log-exported-state")
debug_print("[" + ", ".join([x.repr_short(memo) for x in self.next_iteration_args]) + "]")
for box in self.short_boxes:
debug_print(" " + box.repr(memo))
debug_stop("jit-log-exported-state")
def compiling_a_bridge(self):
self.cpu.tracker.total_compiled_bridges += 1
self.bridges_count += 1
debug_start("jit-mem-looptoken-alloc")
debug_print("allocating Bridge #", self.bridges_count, "of Loop #",
self.number)
debug_stop("jit-mem-looptoken-alloc")
def debug_print(self, hdr='', bad=None, metainterp_sd=None):
if bad is None:
bad = {}
debug_print(hdr + "VirtualState():")
seen = {}
for s in self.state:
s.debug_print(" ", seen, bad, metainterp_sd)
def disable_noninlinable_function(self, greenkey):
cell = self.JitCell.ensure_jit_cell_at_key(greenkey)
cell.flags |= JC_DONT_TRACE_HERE
debug_start("jit-disableinlining")
loc = self.get_location_str(greenkey)
debug_print("disabled inlining", loc)
debug_stop("jit-disableinlining")
def get_total_memory_linux(filename):
debug_start("gc-hardware")
result = -1.0
try:
fd = os.open(filename, os.O_RDONLY, 0644)
try:
buf = os.read(fd, 4096)
finally:
os.close(fd)
except OSError:
pass
else:
if buf.startswith('MemTotal:'):
start = _skipspace(buf, len('MemTotal:'))
stop = start
while stop < len(buf) and buf[stop].isdigit():
stop += 1
if start < stop:
result = float(buf[start:stop]) * 1024.0 # assume kB
if result < 0.0:
debug_print("get_total_memory() failed")
result = addressable_size
else:
debug_print("memtotal =", result)
if result > addressable_size:
result = addressable_size
debug_stop("gc-hardware")
return result
def optimize_bridge(self, trace, runtime_boxes, call_pure_results,
inline_short_preamble, box_names_memo, resumestorage):
from rpython.jit.metainterp.optimizeopt.bridgeopt import deserialize_optimizer_knowledge
frontend_inputargs = trace.inputargs
trace = trace.get_iter()
self.optunroll._check_no_forwarding([trace.inputargs])
if resumestorage:
deserialize_optimizer_knowledge(self, resumestorage,
frontend_inputargs,
trace.inputargs)
info, ops = self.propagate_all_forward(trace, call_pure_results, False)
jump_op = info.jump_op
cell_token = jump_op.getdescr()
assert isinstance(cell_token, JitCellToken)
if not inline_short_preamble or len(cell_token.target_tokens) == 1:
self.jump_to_preamble(cell_token, jump_op)
return info, self._newoperations[:]
# force all the information that does not go to the short
# preamble at all
self.flush()
for a in jump_op.getarglist():
self.force_box_for_end_of_preamble(a)
try:
vs = self.optunroll.jump_to_existing_trace(jump_op,
None,
runtime_boxes,
force_boxes=False)
except InvalidLoop:
self.jump_to_preamble(cell_token, jump_op)
return info, self._newoperations[:]
if vs is None:
return info, self._newoperations[:]
warmrunnerdescr = self.metainterp_sd.warmrunnerdesc
limit = warmrunnerdescr.memory_manager.retrace_limit
if cell_token.retraced_count < limit:
cell_token.retraced_count += 1
debug_print('Retracing (%d/%d)' %
(cell_token.retraced_count, limit))
else:
# Try forcing boxes to avoid jumping to the preamble
try:
vs = self.optunroll.jump_to_existing_trace(jump_op,
None,
runtime_boxes,
force_boxes=True)
except InvalidLoop:
pass
if vs is None:
return info, self._newoperations[:]
debug_print("Retrace count reached, jumping to preamble")
self.jump_to_preamble(cell_token, jump_op)
return info, self._newoperations[:]
exported_state = self.optunroll.export_state(info.jump_op.getarglist(),
info.inputargs,
runtime_boxes,
box_names_memo)
exported_state.quasi_immutable_deps = self.quasi_immutable_deps
self._clean_optimization_info(self._newoperations)
return exported_state, self._newoperations
def compile_trace(metainterp, resumekey, runtime_boxes):
"""Try to compile a new bridge leading from the beginning of the history
to some existging place.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
#
# Attempt to use optimize_bridge(). This may return None in case
# it does not work -- i.e. none of the existing old_loop_tokens match.
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
if isinstance(resumekey, ResumeAtPositionDescr):
inline_short_preamble = False
else:
inline_short_preamble = True
inputargs = metainterp.history.inputargs[:]
trace = metainterp.history.trace
jitdriver_sd = metainterp.jitdriver_sd
enable_opts = jitdriver_sd.warmstate.enable_opts
call_pure_results = metainterp.call_pure_results
if metainterp.history.ends_with_jump:
data = BridgeCompileData(trace, runtime_boxes,
call_pure_results=call_pure_results,
enable_opts=enable_opts,
inline_short_preamble=inline_short_preamble)
else:
data = SimpleCompileData(trace,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
info, newops = optimize_trace(metainterp_sd, jitdriver_sd,
data, metainterp.box_names_memo)
except InvalidLoop:
#pdb.post_mortem(sys.exc_info()[2])
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
debug_print('InvalidLoop in compile_new_bridge')
return None
new_trace = create_empty_loop(metainterp)
new_trace.operations = newops
if info.quasi_immutable_deps:
new_trace.quasi_immutable_deps = info.quasi_immutable_deps
if info.final():
new_trace.inputargs = info.inputargs
target_token = new_trace.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, new_trace, inputargs)
record_loop_or_bridge(metainterp_sd, new_trace)
return target_token
new_trace.inputargs = info.renamed_inputargs
metainterp.retrace_needed(new_trace, info)
return None
def _instantiate_linklet(file_name_for_log, linkl):
debug_start("instantiating-linklet")
debug_print("Instantiating : %s" % file_name_for_log)
instantiate_linklet = get_primitive("instantiate-linklet")
linkl_instance = instantiate_linklet.call_interpret([linkl, w_null, w_false, w_false])
debug_print("DONE Instantiating %s ...." % file_name_for_log)
debug_stop("instantiating-linklet")
return linkl_instance
def evaluateWithTraces(code, scope):
try:
machine = SmallCaps.withDictScope(code, scope)
machine.run()
return machine.pop()
except UserException as ue:
debug_print("Caught exception:", ue.formatError())
return None
def evaluateWithTraces(code, scope):
try:
machine = SmallCaps.withDictScope(code, scope)
machine.run()
return machine.pop()
except UserException as ue:
debug_print("Caught exception:", ue.formatError())
return None
def _instantiate_linklet(file_name_for_log, linkl):
debug_start("instantiating-linklet")
debug_print("Instantiating : %s" % file_name_for_log)
instantiate_linklet = get_primitive("instantiate-linklet")
linkl_instance = instantiate_linklet.call_interpret([linkl, w_null, w_false, w_false])
debug_print("DONE Instantiating %s ...." % file_name_for_log)
debug_stop("instantiating-linklet")
return linkl_instance
def debug_print(self, logops):
if 0:
debug_start('jit-short-boxes')
for box, op in self.short_boxes.items():
if op:
debug_print(logops.repr_of_arg(box) + ': ' + logops.repr_of_resop(op))
else:
debug_print(logops.repr_of_arg(box) + ': None')
debug_stop('jit-short-boxes')
def debug_print(self, logops):
if 0:
debug_start('jit-short-boxes')
for box, op in self.short_boxes.items():
if op:
debug_print(logops.repr_of_arg(box) + ': ' + logops.repr_of_resop(op))
else:
debug_print(logops.repr_of_arg(box) + ': None')
debug_stop('jit-short-boxes')
def _check_rawsize_alloced(self, size_estimate):
self.large_objects_collect_trigger -= size_estimate
if self.large_objects_collect_trigger < 0:
debug_start("gc-rawsize-collect")
debug_print("allocated", (self._initial_trigger -
self.large_objects_collect_trigger),
"bytes, triggering full collection")
self.semispace_collect()
debug_stop("gc-rawsize-collect")
def log_loop_from_trace(self, trace, memo):
if not have_debug_prints():
return
inputargs, ops = self._unpack_trace(trace)
debug_start("jit-log-noopt")
debug_print("# Traced loop or bridge with", len(ops), "ops")
logops = self._log_operations(inputargs, ops, None, memo)
debug_stop("jit-log-noopt")
return logops
def debug_print(self, logops):
if 0:
debug_start("jit-short-boxes")
for box, op in self.short_boxes.items():
if op:
debug_print(logops.repr_of_arg(box) + ": " + logops.repr_of_resop(op))
else:
debug_print(logops.repr_of_arg(box) + ": None")
debug_stop("jit-short-boxes")
def finalizer_trigger(self):
from rpython.rlib.debug import debug_print
while True:
a = self.next_dead()
if a is None:
break
debug_print("DEL:", a.key)
assert age_of(a.key) == -1
set_age_of(a.key, state.time)
state.progress = True
def finalizer_trigger(self):
from rpython.rlib.debug import debug_print
while True:
a = self.next_dead()
if a is None:
break
debug_print("DEL:", a.key)
assert age_of(a.key) == -1
set_age_of(a.key, state.time)
state.progress = True
def _check_rawsize_alloced(self, size_estimate):
self.large_objects_collect_trigger -= size_estimate
if self.large_objects_collect_trigger < 0:
debug_start("gc-rawsize-collect")
debug_print(
"allocated",
(self._initial_trigger - self.large_objects_collect_trigger),
"bytes, triggering full collection")
self.semispace_collect()
debug_stop("gc-rawsize-collect")
def _invalid_write(self, message, offset, length, descr, value):
debug_start('jit-log-rawbuffer')
debug_print('Invalid write: %s' % message)
debug_print(" offset: %d" % offset)
debug_print(" length: %d" % length)
debug_print(" descr: %s" % self._repr_of_descr(descr))
debug_print(" value: %s" % self._repr_of_value(value))
self._dump_to_log()
debug_stop('jit-log-rawbuffer')
raise InvalidRawWrite
def optimize_vector(trace, metainterp_sd, jitdriver_sd, warmstate,
loop_info, loop_ops, jitcell_token=None):
""" Enter the world of SIMD. Bails if it cannot transform the trace. """
user_code = not jitdriver_sd.vec and warmstate.vec_all
e = len(loop_ops)-1
assert e > 0
assert rop.is_final(loop_ops[e].getopnum())
loop = VectorLoop(loop_info.label_op, loop_ops[:e], loop_ops[-1])
if user_code and user_loop_bail_fast_path(loop, warmstate):
return loop_info, loop_ops
# the original loop (output of optimize_unroll)
info = LoopVersionInfo(loop_info)
version = info.snapshot(loop)
loop.setup_vectorization()
try:
debug_start("vec-opt-loop")
metainterp_sd.logger_noopt.log_loop([], loop.finaloplist(label=True), -2, None, None, "pre vectorize")
metainterp_sd.profiler.count(Counters.OPT_VECTORIZE_TRY)
#
start = time.clock()
opt = VectorizingOptimizer(metainterp_sd, jitdriver_sd, warmstate.vec_cost)
index_vars = opt.run_optimization(info, loop)
gso = GuardStrengthenOpt(index_vars)
gso.propagate_all_forward(info, loop, user_code)
end = time.clock()
#
metainterp_sd.profiler.count(Counters.OPT_VECTORIZED)
metainterp_sd.logger_noopt.log_loop([], loop.finaloplist(label=True), -2, None, None, "post vectorize")
nano = int((end-start)*10.0**9)
debug_print("# vecopt factor: %d opcount: (%d -> %d) took %dns" % \
(opt.unroll_count+1, len(version.loop.operations), len(loop.operations), nano))
debug_stop("vec-opt-loop")
#
info.label_op = loop.label
return info, loop.finaloplist(jitcell_token=jitcell_token, reset_label_token=False)
except NotAVectorizeableLoop:
debug_stop("vec-opt-loop")
# vectorization is not possible
return loop_info, version.loop.finaloplist()
except NotAProfitableLoop:
debug_stop("vec-opt-loop")
# cost model says to skip this loop
return loop_info, version.loop.finaloplist()
except Exception as e:
debug_stop("vec-opt-loop")
debug_print("failed to vectorize loop. THIS IS A FATAL ERROR!")
if we_are_translated():
from rpython.rtyper.lltypesystem import lltype
from rpython.rtyper.lltypesystem.lloperation import llop
llop.debug_print_traceback(lltype.Void)
else:
raise
finally:
loop.teardown_vectorization()
return loop_info, loop_ops
def debug_print(self, indent, seen, bad, metainterp_sd):
mark = ""
if self in bad:
mark = "*"
self.debug_header(indent + mark)
if self not in seen:
seen[self] = True
for s in self.fieldstate:
s.debug_print(indent + " ", seen, bad, metainterp_sd)
else:
debug_print(indent + " ...")