Joseph Ferano
bb90f6e65e
Two things, and either alone is useless, so they are one commit. Emit.redefinition compiles one function into its own module against a host that is already running. What it does *not* define is the design: a global is external, so state survives a reload and sand's grid is not reset by editing the code; every other function is a declare, so a redefined settle calls the host's move-grain rather than a frozen copy; there is no main. Build.shared puts that text through llc + ld -shared. ld, not clang, because a shared object is allowed undefined symbols and that is the whole mechanism - and because the driver is 50ms of a 20ms job. Measured here: llc 16ms, ld 3ms, dlopen 0.04ms. Loading a body is not installing it, though. A call bound at link time cannot notice a new one, so a dev build routes every Flan-to-Flan call through a cell - a mutable global holding the address of the function that is current - and a module publishes itself with one store. The cell load is emitted after the arguments, so a redefinition between two calls cannot land inside one. Three details that are not free choices. flan_reload_install is a named function rather than an ELF constructor, because the agent has to choose when the store happens and a constructor would do it during dlopen, mid-frame, on whatever thread called it. A redefinition's own body is hidden, because default visibility in a shared object is interposable and that applies to taking the address too: plain @"flan.bump" inside the module resolves to the host's copy, so the installer would publish the function it was replacing and the reload would silently do nothing. And -rdynamic is what exports the cells at all, so it and cells are one flag: Build.opts.dev, flan build --dev, the first time opts means something semantic rather than an optimisation level. The test is one process, because two runs would prove nothing about a swap, and two .so paths, because dlopen caches by path and would hand back the first handle. Every call in it goes through outer, compiled once into the host and never rebuilt, so a changed answer can only mean its call site followed. v2 recurses through its own cell, which is the interposition case; it would print the old body's text if it did not. helper differs between the fixtures purely as a tripwire for a module that grew its own copy. LLVM cannot fold the indirection - the cell is an external mutable global - and a --dev calc-me keeps 46 indirect calls at -O2. values, machine and sand-headless now run as dev builds in the acceptance table too; the sand hash is the one result that would notice a call reaching the wrong function.
87 lines
3.3 KiB
C
87 lines
3.3 KiB
C
/* reload_host.c — redefinition, exercised in one process.
|
|
*
|
|
* This is the smallest thing that can prove the dev loop's first two steps:
|
|
* a function recompiled into its own object, loaded into a program that is
|
|
* already running, *installed* there, and then reached by a call site that
|
|
* was compiled before it existed. No socket, no daemon, no frame boundary —
|
|
* those are step 3, and the agent that does them lives next to flan_rt.c for
|
|
* the same reason this host is C: there is no OCaml in a game process.
|
|
*
|
|
* It stands in for the entry point of a Flan program, so the .flan fixture it
|
|
* links against has no [main] of its own. Three things are being checked, and
|
|
* only a single process can check any of them:
|
|
*
|
|
* - installing a new body makes the host's own [outer] — linked once, never
|
|
* rebuilt — call it, which is the whole of C-c C-c;
|
|
* - the loaded copy writes the *host's* [counter] and calls the host's
|
|
* [helper], because a redefinition module declares both rather than
|
|
* defining them;
|
|
* - the state carries across two reloads untouched.
|
|
*
|
|
* The two versions are separate files rather than one path rewritten in
|
|
* place: dlopen keys its cache on the path, so re-opening the same name can
|
|
* hand back the handle it already has and the test would then "pass" on the
|
|
* code it loaded the first time.
|
|
*/
|
|
|
|
#include <dlfcn.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
|
|
/* The Flan symbols the executable itself defines. Flan names contain
|
|
* characters C identifiers cannot, so each one is reached through its asm
|
|
* label — the same name Emit spells. */
|
|
extern int64_t flan_outer(void) __asm__("flan.outer");
|
|
extern int64_t flan_counter __asm__("flan.counter");
|
|
|
|
void flan_rt_init(int32_t argc, char **argv);
|
|
|
|
/* What a redefinition module exposes. It is a named function and not an ELF
|
|
* constructor on purpose: the agent has to choose when the store happens —
|
|
* on the game thread, between frames — and a constructor would do it during
|
|
* dlopen, wherever that call happened to be. */
|
|
typedef void (*install_fn)(void);
|
|
|
|
/* The load is timed here rather than from the test process, because this is
|
|
* the part that has to fit inside a frame. */
|
|
static double now_ms(void) {
|
|
struct timespec t;
|
|
clock_gettime(CLOCK_MONOTONIC, &t);
|
|
return (double)t.tv_sec * 1e3 + (double)t.tv_nsec / 1e6;
|
|
}
|
|
|
|
static int install(const char *path) {
|
|
double t0 = now_ms();
|
|
void *h = dlopen(path, RTLD_NOW | RTLD_LOCAL);
|
|
if (h == NULL) {
|
|
fprintf(stderr, "dlopen %s: %s\n", path, dlerror());
|
|
return 0;
|
|
}
|
|
install_fn f = (install_fn)(uintptr_t)dlsym(h, "flan_reload_install");
|
|
if (f == NULL) {
|
|
fprintf(stderr, "dlsym flan_reload_install in %s: %s\n", path, dlerror());
|
|
return 0;
|
|
}
|
|
double t1 = now_ms();
|
|
f();
|
|
fprintf(stderr, "dlopen+dlsym %.2fms install %.4fms\n", t1 - t0,
|
|
now_ms() - t1);
|
|
return 1;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
flan_rt_init(argc, argv);
|
|
if (argc != 3) {
|
|
fprintf(stderr, "usage: %s <v1.so> <v2.so>\n", argv[0]);
|
|
return 2;
|
|
}
|
|
printf("host %lld\n", (long long)flan_outer());
|
|
if (!install(argv[1])) return 1;
|
|
printf("v1 %lld\n", (long long)flan_outer());
|
|
if (!install(argv[2])) return 1;
|
|
printf("v2 %lld\n", (long long)flan_outer());
|
|
printf("counter %lld\n", (long long)flan_counter);
|
|
return 0;
|
|
}
|