radiance · commit

lookup: Borrow keyword and dictionary entries

76d18fbc5ee8806637f860263954a1edf158e0b845b91b1d44a1f821de000b9e

Lookup loops only read entry fields. Borrow entries to avoid copying
records on each keyword comparison and dictionary probe.

Assisted-by: Codex:gpt-6-astra

Alexis Sellier committed 15 days ago 1 parent a7dcdcfb

lib/std/collections/dict.rad +2 -2

export fn insert(m: *mut Dict, key: *[u8], value: i32) {
    let mask = m.entries.len - 1;
    let mut idx = hash(key) & mask;

    loop {
        let entry = m.entries[idx];
        let entry = &m.entries[idx];
        if entry.key.len == 0 {
            assert m.count < m.entries.len / 2, "dict::insert: table full";
            set m.entries[idx] = Entry { key, value };
            set m.count += 1;
            return;

export fn get(m: *Dict, key: *[u8]) -> ?i32 {
    let mask = m.entries.len - 1;
    let mut idx = hash(key) & mask;

    loop {
        let entry = m.entries[idx];
        let entry = &m.entries[idx];
        if entry.key.len == 0 {
            return nil;
        }
        if mem::eq(entry.key, key) {
            return entry.value;

lib/std/lang/scanner.rad +1 -1

    let mut left: u32 = 0;
    let mut right: u32 = KEYWORDS.len;

    while left < right {
        let mid = left + ((right - left) / 2);
        let kw = KEYWORDS[mid];
        let kw = &KEYWORDS[mid];
        let cmp = mem::cmp(src, kw.name);

        match cmp {
            case -1 => set right = mid,
            case 1 => set left = mid + 1,

386	386		let mut left: u32 = 0;
387	387		let mut right: u32 = KEYWORDS.len;
388	388
389	389		while left < right {
390	390		let mid = left + ((right - left) / 2);
391		-	let kw = KEYWORDS[mid];
	391	+	let kw = &KEYWORDS[mid];
392	392		let cmp = mem::cmp(src, kw.name);
393	393
394	394		match cmp {
395	395		case -1 => set right = mid,
396	396		case 1 => set left = mid + 1,

34	34		export fn insert(m: mut Dict, key: [u8], value: i32) {
35	35		let mask = m.entries.len - 1;
36	36		let mut idx = hash(key) & mask;
37	37
38	38		loop {
39		-	let entry = m.entries[idx];
	39	+	let entry = &m.entries[idx];
40	40		if entry.key.len == 0 {
41	41		assert m.count < m.entries.len / 2, "dict::insert: table full";
42	42		set m.entries[idx] = Entry { key, value };
43	43		set m.count += 1;
44	44		return;

55	55		export fn get(m: Dict, key: [u8]) -> ?i32 {
56	56		let mask = m.entries.len - 1;
57	57		let mut idx = hash(key) & mask;
58	58
59	59		loop {
60		-	let entry = m.entries[idx];
	60	+	let entry = &m.entries[idx];
61	61		if entry.key.len == 0 {
62	62		return nil;
63	63		}
64	64		if mem::eq(entry.key, key) {
65	65		return entry.value;