perf(python): a dict lookup by a string key takes the string itself

get, get with a default, subscript read and store, and membership with
a key the typer knows to be a string go through zb_dict_*_str, which
hashes and compares the string without boxing it; a store boxes the
key only when it is new.

git-bug: 3c454b75f1d8516058d4f70a1d75c463106c456b11fdf6dfc69992396fb47050

Author: darmie

crates/zyntax_builtins/src/dicts.rs

@@ -322,6 +322,152 @@ fn dict(list_type: TypeId) -> Vec<Decl> {
     ));
     let insert = |k: Expr, v: Expr| expr(call("zb_dict_insert", vec![d.e(), k, v], unit()));
     out_decls.push(define("zb_dict_len", &[&d], i64(), vec![ret(count(d.e()))]));
+
+    // Lookups by a string that is not boxed, for a key the frontend
+    // knows to be one: hashed and compared as a string, so a key
+    // already present costs no box, and one stored is boxed then.
+    let s = borrowed("text", string());
+    let stored_text = |x: Expr| call("zb_box_get_str", vec![x], string());
+    // The text is read only once the box is known to hold one.
+    let when_stored_is = |stored: &Local, found: Expr| {
+        when(
+            eq(
+                call("zb_any_category", vec![stored.e()], i64()),
+                int(crate::dynamic::STR),
+            ),
+            vec![when(
+                call("zb_str_eq", vec![stored_text(stored.e()), s.e()], boolean()),
+                vec![ret(found)],
+            )],
+        )
+    };
+    out_decls.push(define(
+        "zb_dict_str_hash",
+        &[&s],
+        i64(),
+        vec![
+            h.decl(call("zb_str_hash", vec![s.e()], i64())),
+            when(eq(h.e(), int(0)), vec![h.set(int(1))]),
+            h.set(bitxor(h.e(), shr(h.e(), int(32)))),
+            h.set(mul(h.e(), int(-7_046_029_254_386_353_131))),
+            h.set(bitxor(h.e(), shr(h.e(), int(29)))),
+            ret(h.e()),
+        ],
+    ));
+    out_decls.push(define(
+        "zb_dict_find_hashed_str",
+        &[&d, &s, &h],
+        i64(),
+        vec![
+            index.decl(index_of(d.e())),
+            mask.decl(sub(len(index.e()), int(1))),
+            slot.decl(bitand(h.e(), mask.e())),
+            i.decl(int(0)),
+            while_(
+                le(i.e(), mask.e()),
+                vec![
+                    entry.decl(slot_at(index.e(), slot.e())),
+                    when(lt(entry.e(), int(0)), vec![ret(int(-1))]),
+                    stored.decl(key_at(d.e(), entry.e())),
+                    when_stored_is(&stored, add(mul(entry.e(), int(2)), int(1))),
+                    slot.set(next_slot(slot.e(), mask.e())),
+                    i.add_assign(int(1)),
+                ],
+            ),
+            ret(int(-1)),
+        ],
+    ));
+    out_decls.push(define(
+        "zb_dict_find_str",
+        &[&d, &s],
+        i64(),
+        vec![
+            when(
+                unindexed(d.e()),
+                vec![
+                    n.decl(len(d.e())),
+                    i.decl(int(1)),
+                    while_(
+                        lt(i.e(), n.e()),
+                        vec![
+                            stored.decl(at(d.e(), i.e())),
+                            when_stored_is(&stored, i.e()),
+                            i.add_assign(int(2)),
+                        ],
+                    ),
+                    ret(int(-1)),
+                ],
+            ),
+            ret(call(
+                "zb_dict_find_hashed_str",
+                vec![d.e(), s.e(), call("zb_dict_str_hash", vec![s.e()], i64())],
+                i64(),
+            )),
+        ],
+    ));
+    let find_str = || call("zb_dict_find_str", vec![d.e(), s.e()], i64());
+    let boxed_key = || call("zb_str_to_dynamic", vec![s.e()], any());
+    out_decls.push(define(
+        "zb_dict_contains_str",
+        &[&d, &s],
+        boolean(),
+        vec![ret(ge(find_str(), int(0)))],
+    ));
+    out_decls.push(define(
+        "zb_dict_get_str",
+        &[&d, &s],
+        any(),
+        vec![
+            i.decl(find_str()),
+            when(lt(i.e(), int(0)), vec![fatal("KeyError", s.e())]),
+            ret(at(d.e(), add(i.e(), int(1)))),
+        ],
+    ));
+    out_decls.push(define(
+        "zb_dict_get_default_str",
+        &[&d, &s, &default],
+        any(),
+        vec![
+            i.decl(find_str()),
+            when(lt(i.e(), int(0)), vec![ret(default.e())]),
+            ret(at(d.e(), add(i.e(), int(1)))),
+        ],
+    ));
+    out_decls.push(define(
+        "zb_dict_set_str",
+        &[&d, &s, &v],
+        unit(),
+        vec![
+            when(
+                unindexed(d.e()),
+                vec![
+                    i.decl(find_str()),
+                    if_(
+                        lt(i.e(), int(0)),
+                        vec![insert(boxed_key(), v.e())],
+                        vec![set_idx(d.e(), add(i.e(), int(1)), v.e())],
+                    ),
+                    ret_void(),
+                ],
+            ),
+            h.decl(call("zb_dict_str_hash", vec![s.e()], i64())),
+            i.decl(call(
+                "zb_dict_find_hashed_str",
+                vec![d.e(), s.e(), h.e()],
+                i64(),
+            )),
+            if_(
+                lt(i.e(), int(0)),
+                vec![expr(call(
+                    "zb_dict_insert_hashed",
+                    vec![d.e(), boxed_key(), v.e(), h.e()],
+                    unit(),
+                ))],
+                vec![set_idx(d.e(), add(i.e(), int(1)), v.e())],
+            ),
+            ret_void(),
+        ],
+    ));
     out_decls.push(define(
         "zb_dict_contains",
         &[&d, &key],

crates/zyntax_python/conformance/dict/string_keys.expected

@@ -0,0 +1,10 @@
+{'alpha': 3, 'beta': 2, 'gamma': 1}
+3 2 None -1
+True False
+40 17 17 17 True False
+170
+1700 1700
+False 39
+KeyError 'key17'
+string one one True True
+{1: 'one', '1': 'changed', 2.5: 'float'}

crates/zyntax_python/conformance/dict/string_keys.py

@@ -0,0 +1,36 @@
+# String keys looked up as strings: stored through a typed string or a
+# dynamic value, read back either way, in a small dict and one with a
+# table, with missing keys, defaults, membership and deletion.
+
+def dynamic(v):
+    return v
+
+
+counts = {}
+words = "alpha beta gamma alpha beta alpha".split(" ")
+for w in words:
+    counts[w] = counts.get(w, 0) + 1
+print(counts)
+print(counts["alpha"], counts.get("beta"), counts.get("delta"), counts.get("delta", -1))
+print("gamma" in counts, "delta" in counts)
+
+big = {}
+for i in range(40):
+    big["key" + str(i)] = i
+key = dynamic("key17")
+print(len(big), big["key17"], big[key], big.get(key), "key39" in big, "key40" in big)
+big[key] = 170
+print(big["key17"])
+big["key17"] = 1700
+print(big[key], big.get("key17", 0))
+del big["key17"]
+print("key17" in big, len(big))
+try:
+    print(big["key17"])
+except KeyError as e:
+    print("KeyError", e)
+
+mixed = {1: "one", "1": "string one", 2.5: "float"}
+print(mixed["1"], mixed[1], "1" in mixed, 1 in mixed)
+mixed["1"] = "changed"
+print(mixed)

crates/zyntax_python/src/lower.rs

@@ -2467,9 +2467,14 @@ impl<'m> Lowerer<'m> {
                         call(&list_fn("set", e), vec![seq.node, i, v], Ty::None, span)
                     }
                     Ty::Dict => {
-                        let k = self.expr_as(&sub.slice, Ty::Object)?;
+                        let (k, by) = self.dict_key(&sub.slice)?;
                         let v = self.coerce(value, Ty::Object);
-                        call("zb_dict_set", vec![seq.node, k, v], Ty::None, span)
+                        call(
+                            &format!("zb_dict_set{by}"),
+                            vec![seq.node, k, v],
+                            Ty::None,
+                            span,
+                        )
                     }
                     Ty::Object => {
                         let i = self.expr_as(&sub.slice, Ty::Object)?;
@@ -3068,6 +3073,17 @@ impl<'m> Lowerer<'m> {
 
     /// A value as a `List<Any>` to iterate: a typed list boxed, a string
     /// its characters, a dynamic value whatever it iterates as.
+    /// A dict key as the lookup takes it: a string as itself, for the
+    /// lookups that hash and compare a string without boxing it, and
+    /// anything else as a dynamic value. The suffix names the lookup.
+    fn dict_key(&mut self, e: &py::Expr) -> Result<(Node, &'static str)> {
+        if self.ty_of(e) == Ty::Str {
+            Ok((self.expr_as(e, Ty::Str)?, "_str"))
+        } else {
+            Ok((self.expr_as(e, Ty::Object)?, ""))
+        }
+    }
+
     fn iterable(&mut self, v: Val, span: Span) -> Node {
         match v.ty {
             Ty::Str => {
@@ -4025,8 +4041,18 @@ impl<'m> Lowerer<'m> {
                         span,
                     )
                 } else if right.ty == Ty::Dict {
-                    let item = self.coerce(left, Ty::Object);
-                    call("zb_dict_contains", vec![right.node, item], Ty::Bool, span)
+                    let by = if left.ty == Ty::Str { "_str" } else { "" };
+                    let item = if left.ty == Ty::Str {
+                        left.node
+                    } else {
+                        self.coerce(left, Ty::Object)
+                    };
+                    call(
+                        &format!("zb_dict_contains{by}"),
+                        vec![right.node, item],
+                        Ty::Bool,
+                        span,
+                    )
                 } else {
                     let item = self.coerce(left, Ty::Object);
                     let container = self.coerce(right, Ty::Object);
@@ -4460,9 +4486,14 @@ impl<'m> Lowerer<'m> {
                 Ok(self.index_value(seq, index, ty, span))
             }
             Ty::Dict => {
-                let key = self.expr_as(&sub.slice, Ty::Object)?;
+                let (key, by) = self.dict_key(&sub.slice)?;
                 Ok(Val {
-                    node: call("zb_dict_get", vec![seq.node, key], Ty::Object, span),
+                    node: call(
+                        &format!("zb_dict_get{by}"),
+                        vec![seq.node, key],
+                        Ty::Object,
+                        span,
+                    ),
                     ty: Ty::Object,
                 })
             }
@@ -4699,7 +4730,7 @@ impl<'m> Lowerer<'m> {
                 let d = receiver.node;
                 let node = match (name, args.len()) {
                     ("get", 1) => {
-                        let k = self.expr_as(&args[0], Ty::Object)?;
+                        let (k, by) = self.dict_key(&args[0])?;
                         let none = self.coerce(
                             Val {
                                 node: node(
@@ -4711,12 +4742,22 @@ impl<'m> Lowerer<'m> {
                             },
                             Ty::Object,
                         );
-                        call("zb_dict_get_default", vec![d, k, none], Ty::Object, span)
+                        call(
+                            &format!("zb_dict_get_default{by}"),
+                            vec![d, k, none],
+                            Ty::Object,
+                            span,
+                        )
                     }
                     ("get", 2) => {
-                        let k = self.expr_as(&args[0], Ty::Object)?;
+                        let (k, by) = self.dict_key(&args[0])?;
                         let default = self.expr_as(&args[1], Ty::Object)?;
-                        call("zb_dict_get_default", vec![d, k, default], Ty::Object, span)
+                        call(
+                            &format!("zb_dict_get_default{by}"),
+                            vec![d, k, default],
+                            Ty::Object,
+                            span,
+                        )
                     }
                     ("setdefault", 2) => {
                         let k = self.expr_as(&args[0], Ty::Object)?;