check.py: derive the pypy ratio floor from the ceiling, and arm it only on measurable baselines

pyre/bench/synth/arith_int_bool.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=381
-# pyre-check: min-pypy-ratio=26
 # Merged synth parity smoke suite: independent feature-level hot loops, each
 # kept verbatim from its former standalone file with module-level names prefixed
 # by the source name. Bug-repro / resume / kept-stack tests are NOT merged (they

pyre/bench/synth/attr_cache_invalidation.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=28
-# pyre-check: min-pypy-ratio=3.25
 N = 100000
 
 

pyre/bench/synth/attr_instance_shadows_class.py

@@ -1,9 +1,7 @@
 # pyre-check: max-pypy-ratio=265
-# pyre-check: min-pypy-ratio=14
 # pypy's exec time is pinned to the startup-subtraction floor here, so the
 # ratio is not a measurement: the ceiling is twice the slowest ratio the CI
-# runners observe (131.0x), rounded up, and the floor is half the fastest
-# (29.0x) — a derived floor of ceiling/5 would sit above it.
+# runners observe (131.0x), rounded up.
 # An instance attribute shadows a same-named non-data-descriptor class
 # attribute on builtin-type subclasses (tuple/int/str), while a data descriptor
 # still wins over a competing instance-dict entry (injected directly, since the

pyre/bench/synth/attr_store_add_transition.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=5
-# pyre-check: min-pypy-ratio=0.55
 # STORE_ATTR that ADDS an attribute not yet in the instance's map: the
 # `map -> PlainAttribute` transition plus the grow-by-one storage rewrite
 # (mapdict.py:942-959 `_set_mapdict_increase_storage1`).  The values are

pyre/bench/synth/bases_reassign_cache.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=6.6
-# pyre-check: min-pypy-ratio=1.05
 # Reassigning type.__bases__ recomputes the MRO of the type and every
 # subclass and invalidates the method/attribute lookup cache, so a method or
 # class attribute that was resolved before the swap resolves through the new

pyre/bench/synth/binary_int_overflow_local_resume.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=31
-# pyre-check: min-pypy-ratio=1.85
 # Overflowing integer operations must resume with the values that were loaded
 # from local slots, including values produced by recursive calls and unpacking.
 

pyre/bench/synth/binary_slice_index.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=115
-# pyre-check: min-pypy-ratio=5.35
 # Slice bounds are evaluated through __index__ in both lowering paths:
 #   * a dynamic slice `seq[a:b]` compiles to BINARY_SLICE, handled by
 #     `binary_slice_values`;

pyre/bench/synth/bound_method_builtin_fold.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=48
-# pyre-check: min-pypy-ratio=4.68
 # `lst.append(x)` on a builtin receiver: the name resolves to a builtin-code
 # function on the type, so LOAD_ATTR's method fast path declines (it only
 # pushes `[descr, self]` for `flag_method_descriptor` types) and `getattr`

pyre/bench/synth/break_except_live_local.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=22
-# pyre-check: min-pypy-ratio=3.48
 MODULUS = 1_000_003
 
 

pyre/bench/synth/bridge_branchy_callee.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=10
-# pyre-check: min-pypy-ratio=0.85
 # A branch inside an inlined callee (gh#343). `compute_branch` guard-fails on the
 # rare arm (`x % 7 == 0`); without a compiled bridge for the inlined callee's
 # continuation every crossing deopts to the blackhole (~34x slower on the native

pyre/bench/synth/bridge_global_fold_invalidate_hot.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=36
-# pyre-check: min-pypy-ratio=2.75
 # A read-only module global read on a COLD arm (a branch, a genexpr, or a
 # function that gets rebound) compiles as a bridge that const-folds the global
 # via a quasi-immutable fold. A mid-loop same-key reassignment (or a function

pyre/bench/synth/bridge_recursion_overflow.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=14
-# pyre-check: min-pypy-ratio=2.45
 # Parity fixture for the depth-1 bridge self-recursive inline lift
 # (#704). `f` is a tail-recursive
 # exact-integer callee whose `acc * 2 + 1` crosses the machine-int boundary

pyre/bench/synth/build_class_surrogate_namespace.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=7.8
-# pyre-check: min-pypy-ratio=1.25
 # A __prepare__ namespace whose keys include a lone surrogate must be read back
 # into the class without assuming the keys are valid UTF-8 (the class-statement
 # / __build_class__ gather and the metaclass replay both iterate the keys).

pyre/bench/synth/build_container_return_resume.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=16
-# pyre-check: min-pypy-ratio=1.68
 # Builds a container (tuple / list / set / dict / str) AFTER a hot loop and
 # returns it.  The loop-exit guard failure resumes via the blackhole, which
 # then walks the forward path through the container-build residual

pyre/bench/synth/build_set_hashability.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=105
-# pyre-check: min-pypy-ratio=9.08
 # BUILD_SET (the {...} set literal) hashes every element through
 # space.hash_w, so an unhashable element — a list, or an instance whose
 # __hash__ is None / raises / returns a non-int — raises instead of silently

pyre/bench/synth/bytes_split_whitespace_maxsplit.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=65
-# pyre-check: min-pypy-ratio=3.48
 # bytes/bytearray split/rsplit on whitespace (sep=None) with a positive
 # maxsplit keeps the surrounding whitespace of the final remainder field,
 # matching str. Output verified against CPython/PyPy.

pyre/bench/synth/ca_bridge_multiframe_resume_double_call.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=14
-# pyre-check: min-pypy-ratio=1.45
 # A CALL_ASSEMBLER guard failure whose bridge resume spans two frames: the
 # walk runs the resumed region to the callee's return, executing the recursive
 # calls inside it concretely, and the walk's result completes the callee. If

pyre/bench/synth/call_loop_local_function.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=8
-# pyre-check: min-pypy-ratio=1.28
 # A loop that defines a function in its own body and calls it.
 #
 # `pyopcode.py:1457 MAKE_FUNCTION` runs `function.py:47-57 Function.__init__`

pyre/bench/synth/call_star_forms_inlined_callee.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=18
-# pyre-check: min-pypy-ratio=2.62
 # CALL_KW and CALL_FUNCTION_EX inside a callee that is inlined into the hot
 # loop.  Both opcodes used to emit abort_permanent and decline the callee's
 # jitcode; the residual port lets them compile.  Guards output correctness and

pyre/bench/synth/callable_iterator_type.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=24
-# pyre-check: min-pypy-ratio=3.85
 # iter(callable, sentinel) yields a properly-registered iterator type: type(it)
 # is a real type object, the iterator is an object instance, and __iter__
 # returns self. The concrete type name differs across implementations, so only

pyre/bench/synth/calls_closures.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=109
-# pyre-check: min-pypy-ratio=7.95
 # Merged synth parity smoke suite: independent feature-level hot loops, each
 # kept verbatim from its former standalone file with module-level names prefixed
 # by the source name. Bug-repro / resume / kept-stack tests are NOT merged (they

pyre/bench/synth/class_attrs_methods.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=15
-# pyre-check: min-pypy-ratio=1.15
 N = 600000
 
 

pyre/bench/synth/class_reassign_hot.py

@@ -1,5 +1,7 @@
-# pyre-check: max-pypy-ratio=47
-# pyre-check: min-pypy-ratio=5.38
+# pyre-check: max-pypy-ratio=100
+# The ceiling is twice the slowest ratio the CI runners observe (49.3x on the
+# linux runner's cranelift), rounded up. It read 218 before a later tightening
+# fitted it to a single run's numbers.
 # Reassigning obj.__class__ inside a hot loop must actually re-root the
 # instance's type, so method lookup and type() follow the new class.  The
 # STORE_ATTR mapdict inline cache (store_attr_slowpath) used to classify

pyre/bench/synth/closure_freevar_branch_resume.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=28
-# pyre-check: min-pypy-ratio=3.92
 # gh#498 guard: a branch resume must keep the current closure-call result
 # local, across the three freevar flavours.
 #

pyre/bench/synth/closure_per_call.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=167
-# pyre-check: min-pypy-ratio=18
 # Regression guard for the per-call-created nested closure JIT hang.
 #
 # `add` is defined fresh on every `make` call, and `make` is driven from a

pyre/bench/synth/complex_real_imag.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=6
-# pyre-check: min-pypy-ratio=0.65
 # complex.real / complex.imag are read-only getset descriptors bound to the
 # complex type: they carry __objclass__ == complex and __name__, reject a
 # non-complex receiver with TypeError, and reject assignment with

pyre/bench/synth/comprehension_object_append_hot.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=41
-# pyre-check: min-pypy-ratio=5.28
 # An inlined list comprehension whose LIST_APPEND element lands in a list
 # Object-strategy (tuple / None / str / dict / f-string) folds through the #171
 # orthodox append. Its Object arm stores a GC ref and runs list_write_barrier,

pyre/bench/synth/const_arg_call_resume.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=34
-# pyre-check: min-pypy-ratio=4.15
 # pypy JITs these tiny list loops to a near-zero denominator, so the ratio is
 # dominated by measurement noise on the CI runner (measured 35-43x); the gate
 # is set above that band rather than tightened onto the collapsed baseline.

pyre/bench/synth/context_manager.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=29
-# pyre-check: min-pypy-ratio=4.52
 N = 75000
 
 

pyre/bench/synth/delete_negative_open_slice_hot.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=31
-# pyre-check: min-pypy-ratio=4.18
 # Two-argument BUILD_SLICE must pass the Python None singleton as its implicit
 # step.  Negative bounds make a malformed null step observable during slice
 # normalization, including on guard-failure blackhole resume.

pyre/bench/synth/dict_ctor_consume.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=61
-# pyre-check: min-pypy-ratio=4.65
 # dict.__new__ allocates and ignores its arguments; filling the instance is
 # __init__'s job. So dict(x) walks x exactly once: a mapping's keys() and
 # __getitem__ each run one time per key, a one-shot iterable is not re-entered,

pyre/bench/synth/dict_hash_protocol.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=25
-# pyre-check: min-pypy-ratio=2.82
 # dict.fromkeys fills a plain dict through the dict's own setitem, so a key
 # whose __hash__ raises propagates that exception instead of being stored
 # unhashed. Only the keys and items views are set-like and therefore

pyre/bench/synth/dict_set.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=58
-# pyre-check: min-pypy-ratio=6.18
 # Merged synth parity smoke suite: independent feature-level hot loops, each
 # kept verbatim from its former standalone file with module-level names prefixed
 # by the source name. Bug-repro / resume / kept-stack tests are NOT merged (they

pyre/bench/synth/dict_set_key_eq_operand_order.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=41
-# pyre-check: min-pypy-ratio=3.62
 # A dict/set bucket probe compares the key already stored against the incoming
 # one, in that order (`ll_dict_lookup` runs `keyeq(checkingkey, key)`).  The
 # order decides whose `__eq__` the comparison protocol reaches first, so it is

pyre/bench/synth/dict_update_hot.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=32
-# pyre-check: min-pypy-ratio=2.75
 # N/ITERS are kept small so the wasm backend finishes inside the synthetic
 # timeout: wasm runs every guard-exit re-entry through the not-yet-collected
 # interpreter allocation path, so the run's wall grows super-linearly in ITERS

pyre/bench/synth/dict_view_set_ops.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=25
-# pyre-check: min-pypy-ratio=3.8
 # A set operation on a dict view builds a set from the left operand and runs
 # the matching in-place set method against the right one, so the result is a
 # plain set. The reflected forms build the set from the other operand, keeping

pyre/bench/synth/dir_dict_class_attrs.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=4.8
-# pyre-check: min-pypy-ratio=0.22
 # util.py:80 _objectdir / objectobject.py:324 — dir() of a dict instance lists
 # the dict type's attributes (object.__dir__), NOT the dict's own keys.
 

pyre/bench/synth/divmod_long_int_pair.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=18
-# pyre-check: min-pypy-ratio=2.38
 # `divmod(long, int)` at a traced call site. `_int_divmod` keeps the divisor
 # unwrapped and calls `rbigint.int_divmod`, whose rtyped return is a two-item
 # `GcStruct`: the walker emits one elidable call plus two `getfield_gc_r`, then

pyre/bench/synth/dunder_repr_str_errors.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=13
-# pyre-check: min-pypy-ratio=2.45
 # Exceptions raised by `__repr__`/`__str__` overrides propagate out of
 # `repr()`/`str()`/`format`/`%`/f-strings instead of being swallowed,
 # including builtin-leaf subclasses and through container recursion.

pyre/bench/synth/exc_bridge_entry_guard_not_removed.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=38
-# pyre-check: min-pypy-ratio=2.72
 # A residual callee raises for the extremes of a hot descending loop and
 # returns in the middle, so the loop trace's exception guard chronically fails
 # WITHOUT a pending exception and a no-exception bridge gets compiled.  That

pyre/bench/synth/exc_caught_in_callee_return_loop.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=55
-# pyre-check: min-pypy-ratio=9.08
 # A callee catches a residual-call exception in-frame and RETURNS a sentinel
 # into a JIT-hot outer loop.  When the callee gets hot enough that a bridge is
 # compiled for the exception-guard (GUARD_NO_EXCEPTION) failure on the

pyre/bench/synth/exc_in_loop_divzero_continue.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=6.6
-# pyre-check: min-pypy-ratio=0.78
 # A try/except INSIDE a hot loop whose body raises through a may-force
 # residual call (`//`, `%`, `int("z")`) on some iterations and is CAUGHT,
 # with the loop CONTINUING afterwards.  The raising op is int-specialized

pyre/bench/synth/except_star.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=3.8
-# pyre-check: min-pypy-ratio=0.48
 def m(label, value):
     print(label, "->", repr(value))
 

pyre/bench/synth/exception_args_virtual.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=21
-# pyre-check: min-pypy-ratio=1.95
 N = 250000
 
 

pyre/bench/synth/exception_as_cell_cleanup.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=22
-# pyre-check: min-pypy-ratio=2.05
 # An `except E as e:` handler whose exception variable `e` is captured by a
 # nested function makes `e` a cell variable, so the implicit handler cleanup
 # emits DELETE_DEREF (clear the cell contents) rather than DELETE_FAST. The

pyre/bench/synth/exception_bare_reraise_nested_outer.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=12
-# pyre-check: min-pypy-ratio=1.62
 # Bare `raise` inside a nested handler whose re-raise must reach the OUTER
 # handler, exercised under a bridge resume that lands inside the inner handler.
 #

pyre/bench/synth/exception_catching_frame_tb_node.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=18
-# pyre-check: min-pypy-ratio=2.28
 # The frame holding the `try` contributes its own traceback node, including
 # when its `except` is reached from inside its own compiled trace.
 #

pyre/bench/synth/exception_const_operand_resume.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=20
-# pyre-check: min-pypy-ratio=2.68
 # Exception-resume bridge (GuardException) with a CONSTANT pre-call operand.
 # Each `try` divides/indexes with a CONSTANT numerator/addend that lives on the
 # operand stack at the raising bytecode. The loop warms up exception-free

pyre/bench/synth/exception_escape_hot_callee_tb_node_once.py

@@ -1,11 +1,10 @@
 # pyre-check: max-pypy-ratio=73
-# pyre-check: min-pypy-ratio=3.22
 # A hot compiled CALLEE holding a try block the exception does not stay in used
 # to record its own traceback node TWICE.
 #
 # Every iteration of every driver raises and unwinds, so the ratio measures
 # exception throughput rather than the contract under test, and it varies 2.5x
-# across hosts -- hence the explicit floor beside the ceiling.
+# across hosts.
 #
 # N is 4000 because the witness needs the callee compiled: the duplicate node
 # first appears at N=2500 and never at N=1500, and 4000 reproduces every one of

pyre/bench/synth/exception_group_type.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=5.2
-# pyre-check: min-pypy-ratio=0.32
 def m(label, value):
     print(label, "->", repr(value))
 

pyre/bench/synth/exception_inline_callee_tb_frames.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=31
-# pyre-check: min-pypy-ratio=3.42
 # An exception raised in an inlined callee and caught two or three frames up
 # must still attach a traceback node for every frame it passed through: one at
 # the raise instruction and one per callee->caller propagation.

pyre/bench/synth/exception_inlined_callee_caught.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=73
-# pyre-check: min-pypy-ratio=7.78
 N = 100000
 
 

pyre/bench/synth/exception_metadata_hot.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=12
-# pyre-check: min-pypy-ratio=1.72
 # Exception metadata observed from inside JIT-hot handlers: traceback
 # attachment and shape, __context__ / __cause__ chaining, sys.exc_info, handler
 # name clearing, and re-raise.

pyre/bench/synth/exception_metadata_jitstress.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=4
-# pyre-check: min-pypy-ratio=0.28
 # JIT-stress twin of exception_metadata_hot: `pypyjit.set_param` lowers the
 # trace/function thresholds to 1 so recording fires on the earliest iterations
 # of every section rather than only after the ~1600-iteration warmup. That

pyre/bench/synth/exception_multi_handler_warmup.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=17
-# pyre-check: min-pypy-ratio=2.62
 # Multi-except dispatch + counter-only handler bodies on the blackhole
 # guard-failure resume path. The loop warms up exception-free (so the trace
 # compiles the no-exception path), then raises ZeroDivisionError and

pyre/bench/synth/exception_oserror_fields.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=47
-# pyre-check: min-pypy-ratio=6.72
 N = 200000
 
 

pyre/bench/synth/exception_raise_caught_same_frame_tb.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=45
-# pyre-check: min-pypy-ratio=3.45
 # A frame that raises and catches in one body contributes EXACTLY ONE
 # traceback node, and it keeps that count once the loop is compiled.
 #

pyre/bench/synth/exception_reduce.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=32
-# pyre-check: min-pypy-ratio=3.38
 N = 50000
 
 

pyre/bench/synth/exception_reraise_tb_depth_hot.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=5.5
-# pyre-check: min-pypy-ratio=0.52
 # A bare re-raise caught in the same frame keeps the original traceback: no
 # node is attached at a re-raise coordinate (RaiseWithExplicitTraceback,
 # attach_tb=False). The module-level loop makes the recording iteration itself

pyre/bench/synth/exception_reraise_tb_depth_jitstress.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=4
-# pyre-check: min-pypy-ratio=0.22
 # JIT-stress twin of exception_reraise_tb_depth_hot: `pypyjit.set_param`
 # lowers the trace/function thresholds to 1 so trace recording fires on the
 # earliest iterations rather than only after the ~1600-iteration warmup. That

pyre/bench/synth/exception_residual_raise_caught_in_frame.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=34
-# pyre-check: min-pypy-ratio=2.12
 # A frame that catches an exception a residual call raised contributes its own
 # traceback node, including once its `except` is reached from inside its own
 # compiled trace.

pyre/bench/synth/exception_subclass_attrs.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=80
-# pyre-check: min-pypy-ratio=5.32
 N = 200000
 
 

pyre/bench/synth/exception_traceback_lineno_chain.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=22
-# pyre-check: min-pypy-ratio=2.48
 # Every traceback node keeps the line its frame was executing, including for
 # a frame the JIT compiled and exited with an uncaught exception.
 #

pyre/bench/synth/exception_traceback_loop_forms.py

@@ -1,5 +1,4 @@
 # pyre-check: max-pypy-ratio=36
-# pyre-check: min-pypy-ratio=4.6
 # Traceback nodes recorded by a compiled loop, driven by BOTH loop forms.
 #
 # The sibling exception-traceback fixtures all drive their workload with