Maps, Unrolling, and Dynamic Frame Size

.codeclimate.yml

@@ -27,3 +27,4 @@ exclude_paths:
  - "repository/*"
  - "scripts/**/*"
  - "scripts/*"
+

rsqueakvm/constants.py

@@ -127,42 +127,42 @@
 SO_JIT_HOOK_RCVR = 59 # really selectorTrap
 
 constant_objects_in_special_object_table = {
- "nil": (SO_NIL, "POINTERS"),
- "true": (SO_TRUE, "POINTERS"),
- "false": (SO_FALSE, "POINTERS"),
+ "nil": (SO_NIL, "FIXED"),
+ "true": (SO_TRUE, "FIXED"),
+ "false": (SO_FALSE, "FIXED"),
  "charactertable": (SO_CHARACTER_TABLE_ARRAY, "POINTERS"),
- "schedulerassociationpointer": (SO_SCHEDULERASSOCIATIONPOINTER, "POINTERS"),
+ "schedulerassociationpointer": (SO_SCHEDULERASSOCIATIONPOINTER, "FIXED"),
  "special_selectors": (SO_SPECIAL_SELECTORS_ARRAY, "POINTERS"),
- "smalltalkdict": (SO_SMALLTALK, "POINTERS"),
+ "smalltalkdict": (SO_SMALLTALK, "FIXED"),
  "doesNotUnderstand": (SO_DOES_NOT_UNDERSTAND, "BYTES"),
  "mustBeBoolean": (SO_MUST_BE_BOOLEAN, "BYTES"),
  "runWithIn": (SO_RUN_WITH_IN, "BYTES"),
  "cannotReturn": (SO_CANNOT_RETURN, "BYTES"),
  # classes
- "Bitmap": (SO_BITMAP_CLASS, "POINTERS"),
- "SmallInteger": (SO_SMALLINTEGER_CLASS, "POINTERS"),
- "String": (SO_STRING_CLASS, "POINTERS"),
- "Array": (SO_ARRAY_CLASS, "POINTERS"),
- "Float": (SO_FLOAT_CLASS, "POINTERS"),
- "MethodContext": (SO_METHODCONTEXT_CLASS, "POINTERS"),
- "BlockContext": (SO_BLOCKCONTEXT_CLASS, "POINTERS"),
- "BlockClosure": (SO_BLOCKCLOSURE_CLASS, "POINTERS"),
- "Point": (SO_POINT_CLASS, "POINTERS"),
- "LargePositiveInteger": (SO_LARGEPOSITIVEINTEGER_CLASS, "POINTERS"),
- "Message": (SO_MESSAGE_CLASS, "POINTERS"),
- "CompiledMethod": (SO_COMPILEDMETHOD_CLASS, "POINTERS"),
- "Semaphore": (SO_SEMAPHORE_CLASS, "POINTERS"),
- "Character": (SO_CHARACTER_CLASS, "POINTERS"),
- "ByteArray": (SO_BYTEARRAY_CLASS, "POINTERS"),
- "Process": (SO_PROCESS_CLASS, "POINTERS"),
-# "PseudoContext" : (SO_PSEUDOCONTEXT_CLASS, "POINTERS"),
-# "TranslatedMethod" : (SO_TRANSLATEDMETHOD_CLASS, "POINTERS"),
- "LargeNegativeInteger" : (SO_LARGENEGATIVEINTEGER_CLASS, "POINTERS"),
+ "Bitmap": (SO_BITMAP_CLASS, "FIXED"),
+ "SmallInteger": (SO_SMALLINTEGER_CLASS, "FIXED"),
+ "String": (SO_STRING_CLASS, "FIXED"),
+ "Array": (SO_ARRAY_CLASS, "FIXED"),
+ "Float": (SO_FLOAT_CLASS, "FIXED"),
+ "MethodContext": (SO_METHODCONTEXT_CLASS, "FIXED"),
+ "BlockContext": (SO_BLOCKCONTEXT_CLASS, "FIXED"),
+ "BlockClosure": (SO_BLOCKCLOSURE_CLASS, "FIXED"),
+ "Point": (SO_POINT_CLASS, "FIXED"),
+ "LargePositiveInteger": (SO_LARGEPOSITIVEINTEGER_CLASS, "FIXED"),
+ "Message": (SO_MESSAGE_CLASS, "FIXED"),
+ "CompiledMethod": (SO_COMPILEDMETHOD_CLASS, "FIXED"),
+ "Semaphore": (SO_SEMAPHORE_CLASS, "FIXED"),
+ "Character": (SO_CHARACTER_CLASS, "FIXED"),
+ "ByteArray": (SO_BYTEARRAY_CLASS, "FIXED"),
+ "Process": (SO_PROCESS_CLASS, "FIXED"),
+# "PseudoContext" : (SO_PSEUDOCONTEXT_CLASS, "FIXED"),
+# "TranslatedMethod" : (SO_TRANSLATEDMETHOD_CLASS, "FIXED"),
+ "LargeNegativeInteger" : (SO_LARGENEGATIVEINTEGER_CLASS, "FIXED"),
  # ours, not in the table, but we'd like it to
- "ClassBinding": (SPECIAL_OBJECTS_SIZE + 30, "POINTERS"),
- "Metaclass": (SPECIAL_OBJECTS_SIZE + 31, "POINTERS"),
- "Processor": (SPECIAL_OBJECTS_SIZE + 32, "POINTERS"),
- "ByteSymbol": (SPECIAL_OBJECTS_SIZE + 33, "POINTERS")
+ "ClassBinding": (SPECIAL_OBJECTS_SIZE + 30, "FIXED"),
+ "Metaclass": (SPECIAL_OBJECTS_SIZE + 31, "FIXED"),
+ "Processor": (SPECIAL_OBJECTS_SIZE + 32, "FIXED"),
+ "ByteSymbol": (SPECIAL_OBJECTS_SIZE + 33, "FIXED")
 }
 
 variables_in_special_object_table = {

rsqueakvm/interpreter.py

@@ -126,9 +126,17 @@ def __init__(self, s_new_context, forced=False):
  ContextSwitchException.__init__(self, s_new_context)
  self.forced = forced
 
+class Optargs(object):
+ _attrs_ = ["max_squeak_unroll_count", "squeak_unroll_trace_limit"]
+ _immutable_fields_ = ["max_squeak_unroll_count", "squeak_unroll_trace_limit"]
+ def __init__(self):
+ self.max_squeak_unroll_count = 2
+ self.squeak_unroll_trace_limit = 32000
+
+
 UNROLLING_BYTECODE_RANGES = unroll.unrolling_iterable(interpreter_bytecodes.BYTECODE_RANGES)
 
-def get_printable_location(pc, self, method, w_class, blockmethod):
+def get_printable_location(pc, jump_back_pc, unrollings, frame_size, self, method, w_class, blockmethod):
  bc = ord(method.bytes[pc])
  name = method.safe_identifier_string()
  classname = "???"
@@ -143,8 +151,8 @@ def get_printable_location(pc, self, method, w_class, blockmethod):
  blockname = blockmethod.safe_identifier_string()
  return '%s(%s): (%s) [%d]: <%s>%s' % (classname, name, blockname, pc, hex(bc), interpreter_bytecodes.BYTECODE_NAMES[bc])
 
-def resume_get_printable_location(pc, self, method, w_class):
- return "resume: %s" % get_printable_location(pc, self, method, w_class, None)
+def resume_get_printable_location(pc, frame_size, self, method, w_class):
+ return "resume: %s" % get_printable_location(pc, 0, 0, frame_size, self, method, w_class, None)
 
 # def confirm_enter_jit(pc, self, method, w_class, s_context):
 # print get_printable_location(pc, self, method, w_class)
@@ -161,11 +169,13 @@ class Interpreter(object):
  "evented",
  "interrupts",
  "trace_important",
- "trace"]
+ "trace",
+ "optargs"]
 
  jit_driver = jit.JitDriver(
  name=jit_driver_name,
- greens=['pc', 'self', 'method', 'w_class', 'blockmethod'],
+ greens=['pc', 'jump_back_pc', 'unrollings', 'frame_size', 'self',
+ 'method', 'w_class', 'blockmethod'],
  reds=['s_context'],
  virtualizables=['s_context'],
  get_printable_location=get_printable_location,
@@ -174,15 +184,15 @@ class Interpreter(object):
 
  resume_driver = jit.JitDriver(
  name=jit_driver_name + "_resume",
- greens=['pc', 'self', 'method', 'w_class'],
+ greens=['pc', 'frame_size', 'self', 'method', 'w_class'],
  reds=['s_context'],
  # virtualizables=['s_context'],
  get_printable_location=resume_get_printable_location,
  is_recursive=True
  )
 
  def __init__(self, space, image=None, trace_important=False,
- trace=False, evented=True, interrupts=True):
+ trace=False, evented=True, interrupts=True, optargs=None):
  # === Initialize immutable variables
  self.space = space
  self.image = image
@@ -199,6 +209,7 @@ def __init__(self, space, image=None, trace_important=False,
  self.interrupt_counter_size = constants.INTERRUPT_COUNTER_SIZE
  self.last_check = self.time_now()
  self.trace = trace
+ self.optargs = optargs or Optargs()
 
  # === Initialize mutable variables
  self.interrupt_check_counter = self.interrupt_counter_size
@@ -217,9 +228,11 @@ def loop(self, w_active_context):
  s_context = w_active_context.as_context_get_shadow(self.space)
  while True:
  method = s_context.w_method()
+ frame_size = method.frame_size()
  pc = s_context.pc()
  self.resume_driver.jit_merge_point(
  pc=pc,
+ frame_size=frame_size,
  self=self,
  method=method,
  w_class=self.getreceiverclass(s_context),
@@ -239,6 +252,7 @@ def loop(self, w_active_context):
  self.resume_driver.can_enter_jit(
  pc=pc,
  self=self,
+ frame_size=frame_size,
  method=method,
  w_class=self.getreceiverclass(s_context),
  s_context=s_context)
@@ -304,27 +318,60 @@ def getreceiverclass(self, s_context):
  return s_context.w_receiver().safe_getclass(self.space)
 
  def getblockmethod(self, s_context):
- return s_context.blockmethod
+ return s_context.blockmethod()
 
  def loop_bytecodes(self, s_context, may_context_switch=True):
  old_pc = 0
+ jump_back_pc = 0
+ unrollings = 0
  if not jit.we_are_jitted() and may_context_switch:
  self.quick_check_for_interrupt(s_context)
  method = s_context.w_method()
+ frame_size = method.frame_size()
  while True:
  pc = s_context.pc()
  if pc < old_pc:
- if jit.we_are_jitted():
- # Do the interrupt-check at the end of a loop, don't interrupt loops midway.
- self.jitted_check_for_interrupt(s_context)
- self.jit_driver.can_enter_jit(
- pc=pc, self=self, method=method,
- w_class=self.getreceiverclass(s_context),
- blockmethod=self.getblockmethod(s_context),
- s_context=s_context)
+ if jump_back_pc == old_pc:
+ if (unrollings < self.optargs.max_squeak_unroll_count and
+ jit.current_trace_length() < self.optargs.squeak_unroll_trace_limit):
+ unrollings += 1
+ else:
+ if jit.we_are_jitted():
+ # Do the interrupt-check at the end of a loop, don't
+ # interrupt loops midway.
+ self.jitted_check_for_interrupt(s_context)
+ if not s_context.has_overflow_stack():
+ self.jit_driver.can_enter_jit(
+ pc=pc,
+ jump_back_pc=jump_back_pc,
+ unrollings=unrollings,
+ frame_size=frame_size,
+ self=self, method=method,
+ w_class=self.getreceiverclass(s_context),
+ blockmethod=self.getblockmethod(s_context),
+ s_context=s_context)
+ else:
+ jump_back_pc = old_pc
+ unrollings = 1
+ # we jumped back from the end of a loop. Instead of allowing
+ # to enter the JIT here, we instead wait for the second time
+ # this loop runs and call can_enter_jit only then
+ # (effectively unrolling at least two iterations). This is
+ # because the way the Squeak compiler generates loop
+ # bytecodes: we get the branch condition in the header and a
+ # conditional jump forward in case it is false. Then the
+ # loop body and an unconditional jump back. In the case of 1
+ # to: 1 do: or other loops that run for exactly one
+ # iteration, we will still generate a call_assembler in that
+ # case, which we work around with this. There are indeed a
+ # few examples of loops that run exactly one iteration
  old_pc = pc
  self.jit_driver.jit_merge_point(
- pc=pc, self=self, method=method,
+ pc=pc,
+ jump_back_pc=jump_back_pc,
+ unrollings=unrollings,
+ frame_size=frame_size,
+ self=self, method=method,
  w_class=self.getreceiverclass(s_context),
  blockmethod=self.getblockmethod(s_context),
  s_context=s_context)

rsqueakvm/interpreter_bytecodes.py

@@ -365,7 +365,7 @@ def _sendSelfSelectorSpecial(self, selector, numargs, interp):
 
  @objectmodel.specialize.arg(3)
  def _sendSpecialSelector(self, interp, receiver, special_selector, w_args=[]):
- space = jit.promote(self.space)
+ space = self.space
  w_special_selector = getattr(space, "w_" + special_selector)
  s_class = receiver.class_shadow(space)