Add a call benchmark (#6)

A call is a frame, an argument list bound to parameters, a body and a
return value handed back. Methods, comprehensions, generators and every
dunder in the object model are that sequence with something wrapped around
it, so whatever a call costs is a floor under all of them.

Three shapes, because they cost differently and a regression in one should
not hide behind the other two: two positional arguments straight into two
registers, a keyword argument that has to be matched against the parameter
list, and arguments collected into a tuple for a `*args`.

It found something immediately. kohebi was at 0.28s against CPython's 0.08s
for 700,000 calls while beating it on the same loop with the call inlined,
which turned out to be four heap allocations per call. Three of them are
gone in tamnd/kohebi#97 and it is at 0.11s now.

Author: tamnd

README.md

@@ -58,7 +58,7 @@ Agreement itself is decided in [tamnd/kohebi-compat](https://github.com/tamnd/ko
 
 | Directory | Contents |
 | --- | --- |
-| `benchmarks/tier0/` | Integer and float loops, branch dispatch, string operators, list growth |
+| `benchmarks/tier0/` | Integer and float loops, branch dispatch, string operators, list growth, indexing, iteration, calls |
 | `benchmarks/micro/` | Attribute dispatch, integer arithmetic, method calls, homogeneous lists, string building |
 | `benchmarks/apps/` | JSON round-tripping, interpreter startup |
 
@@ -68,9 +68,9 @@ The micro benchmarks are chosen to isolate the specific bets in kohebi's design:
 
 ## The tier zero suite, which is the part kohebi can run today
 
-`benchmarks/tier0/` exists because a comparison you cannot run is not a comparison. The tier zero interpreter has assignment, arithmetic, comparison, the boolean operators, `if`, `while`, `break`, `continue`, container displays, `in`, and `print`. It does not have functions, `for` loops, attributes, subscripting, iteration or imports yet, so the five programs in there are written entirely with what exists.
+`benchmarks/tier0/` exists because a comparison you cannot run is not a comparison. The tier zero interpreter has assignment, arithmetic, comparison, the boolean operators, `if`, `while`, `break`, `continue`, container displays, `in`, `print`, subscripting, slicing, `for` loops over every builtin container, and functions. It does not have attributes, classes, exceptions or imports yet, so the programs in there are written entirely with what exists.
 
-That makes them a little strange to read. Collatz is inlined rather than called, buckets are five separate names rather than a list, and a list is grown with `items += [i]` because there are no method calls. Every one of them was diffed against CPython 3.14 and PyPy before it went in, so all three runtimes print the same bytes, and none of them is doing less work than the others.
+That makes some of them a little strange to read. Buckets are five separate names rather than a list, and a list is grown with `items += [i]` because there are no method calls. The older ones inline what would be a call, which was the only option when they were written and is now a useful contrast against `call.py`. Every one of them was diffed against CPython 3.14 and PyPy before it went in, so all three runtimes print the same bytes, and none of them is doing less work than the others.
 
 These are temporary. When kohebi can run `micro/int_arithmetic.py` as a person would write it, `tier0/int_loop.py` has done its job and comes out. What it buys in the meantime is a real number every week instead of a promise, and the first one already said something useful, which is in `results/`.
 

benchmarks/tier0/call.py

@@ -0,0 +1,55 @@
+"""Calling a function, which is the operation everything else is built on.
+
+A call is a frame, an argument list bound to parameters, a body, and a return
+value handed back. Methods, comprehensions, generators and every dunder in the
+object model are that same sequence with something wrapped around it, so
+whatever a call costs is a floor under all of them.
+
+The three shapes here are the three that cost differently. `add` is the cheap
+one: two positional arguments straight into two registers, nothing to search.
+`described` is what a keyword argument costs, which is a name matched against
+the parameter list before anything can be bound. `sum_of` is a call whose
+arguments have to be collected into a tuple first. Splitting them apart means a
+regression in one does not hide behind the other two.
+
+The bodies are deliberately trivial. This is not a benchmark about arithmetic
+and any real work inside them would only dilute what it is measuring.
+
+Written without imports, because tier zero has none yet.
+"""
+
+
+def add(a, b):
+    return a + b
+
+
+def described(value, scale=1, offset=0):
+    return value * scale + offset
+
+
+def sum_of(*values):
+    total = 0
+    for value in values:
+        total += value
+    return total
+
+
+plain = 0
+i = 0
+while i < 400_000:
+    plain = add(plain, 1)
+    i += 1
+
+keyword = 0
+i = 0
+while i < 200_000:
+    keyword = described(keyword, offset=1)
+    i += 1
+
+collected = 0
+i = 0
+while i < 100_000:
+    collected += sum_of(1, 2, 3)
+    i += 1
+
+print(plain, keyword, collected)