From a0ee2169e5e9b017238d1fd0b137bc012a6d2162 Mon Sep 17 00:00:00 2001
From: veclavtalica <veclavtalica@poto.cafe>
Date: Sun, 28 Jul 2024 04:06:30 +0300
Subject: [PATCH] rodata-lookup-caching

---
 articles/rodata-lookup-caching/page.mmd | 90 +++++++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 articles/rodata-lookup-caching/page.mmd

diff --git a/articles/rodata-lookup-caching/page.mmd b/articles/rodata-lookup-caching/page.mmd
new file mode 100644
index 0000000..16d7e60
--- /dev/null
+++ b/articles/rodata-lookup-caching/page.mmd
@@ -0,0 +1,90 @@
+Title:  Lookup Caching by .rodata Section String Inference
+Brief:  Rather hacky, but working way of string key lookup acceleration.
+Date:   1722127090
+Tags:   Programming, Optimization, C, Linux
+CSS:    /style.css
+
+While working on our immediate no-state engine, the need for texture lookup optimization arose.
+API is designed in a way where every single pushed triangle means resolution of texture by path.
+
+My insane mind came to such optimization then: detect is given path pointer is in .rodata and if so, -
+just lookup by hash of the pointer, not whole varying-size string. Constant time and all that.
+
+For that I ended up writing a limited ELF parsing routine that expects `/proc/self/exe`.
+Virtual address space randomization was tricky until I realized that
+`getauxval(AT_ENTRY) - ehdr.e_entry` could be used to get the base process address.
+
+After the section bounds are known, - it's as simple as checking `vm_start >= ptr && ptr < vm_end`.
+
+### Code ###
+```c
+/* code is fully self-contained, feel free to use it :) */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/auxv.h>
+#include <elf.h>
+#include <linux/limits.h>
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool infer_elf_section_bounds(const char *const restrict name,
+                              const char **restrict vm_start,
+                              const char **restrict vm_end)
+{
+    bool result = false;
+    char buf[PATH_MAX];
+    ssize_t l = readlink("/proc/self/exe", buf, PATH_MAX);
+    if (l == -1)
+        goto ERR_CANT_READLINK;
+    buf[l] = 0; /* readlink() doesn't write a terminator */
+
+    int elf = open(buf, O_RDONLY);
+    if (elf == -1)
+        goto ERR_CANT_OPEN_SELF;
+
+    /* elf header */
+    Elf64_Ehdr ehdr;
+    read(elf, &ehdr, sizeof ehdr);
+    if (ehdr.e_ident[EI_MAG0] != ELFMAG0 ||
+            ehdr.e_ident[EI_MAG1] != ELFMAG1 ||
+            ehdr.e_ident[EI_MAG2] != ELFMAG2 ||
+            ehdr.e_ident[EI_MAG3] != ELFMAG3)
+        goto ERR_NOT_ELF;
+
+    /* section header string table */
+    Elf64_Shdr shstrdr;
+    lseek(elf, ehdr.e_shoff + ehdr.e_shstrndx * sizeof (Elf64_Shdr), SEEK_SET);
+    read(elf, &shstrdr, sizeof shstrdr);
+    char *sh = malloc(shstrdr.sh_size);
+    lseek(elf, shstrdr.sh_offset, SEEK_SET);
+    read(elf, sh, shstrdr.sh_size);
+
+    /* walk sections searching for needed name */
+    lseek(elf, ehdr.e_shoff, SEEK_SET);
+    for (size_t s = 0; s < ehdr.e_shnum; ++s) {
+        Elf64_Shdr shdr;
+        read(elf, &shdr, sizeof shdr);
+
+        if (strcmp(&sh[shdr.sh_name], name) == 0) {
+            result = true;
+            *vm_start = getauxval(AT_ENTRY) - ehdr.e_entry + (char *)shdr.sh_addr;
+            *vm_end   = getauxval(AT_ENTRY) - ehdr.e_entry + (char *)shdr.sh_addr + shdr.sh_size;
+            break;
+        }
+    }
+
+    free(sh);
+
+ERR_NOT_ELF:
+    close(elf);
+
+ERR_CANT_OPEN_SELF:
+ERR_CANT_READLINK:
+    return result;
+}
+
+```