floem app fails to launch when using libloading

[woodworthkyle]

107 talks about a stack overflow when trying to use floem with libloading. I've been trying to do something similar with floem, but I don't get a stack overflow error. The application just terminates without ever showing a window or error message.

I'm assuming the way VIEW_STORAGE is defined (with thread_local! and static), it is forced to be stored at the same memory location across floem instances in the same thread. And by instances I mean linked instances of floem. In this case the host app and plugin have linked instances of floem but when running they live on the same thread. So they share the VIEW_STORAGE memory location (I think this is an over-simplified version of how rust actually compiles this down, but it boils down to this core concept). This is verified by printing out the raw pointer location of the VIEW_STORAGE of the host app and the VIEW_STORAGE of the plugin and observing that they were the same. However, something happens with the control machinery of VIEW_STORAGE and how it creates keys. It looks like the plugin starts over with key creation and will essentially start to overwrite the contents of VIEW_STORAGE from the perspective of the host app.

I've verified this by "sending" the text function (the one that creates a static label) to the plugin and utilizing this function to create a text label. When using this sent function, I am able to render a window without the application "crashing". When I use the "normal" text function from the namespace of the plugin, the application fails to launch (presumably for overwriting the first entry in the VIEW_STORAGE struct). So it seems like there are two "instances" of floem that fight over VIEW_STORAGE when libloading is used.

One solution would be to libload floem as its own library so that applications can make use of it via an ABI. This would allow for smaller end-user binaries (I think) and for other languages to hook into the framework (like python+Qt; I would love a floem python interface :) ). I keep reading that rust's ABI is unstable, but I'm not entirely sure the implications of this. Another solution might involve something like a "shared" floem API of sorts. Something that allows "plugins" to talk to a common set of functions more easily.

It took some hours of messy code to get to this point, so I will post a simplified example tomorrow.

[woodworthkyle]

I have uploaded a simple example to: https://github.com/woodworthkyle/floem_libloading.

There is a global variable named DEBUG_858 in host/src/main.rs to switch between the text function that is used. I use a slightly modifed floem source that allows me to see VIEW_STORAGE.view_ids for debugging.

The following are a set of logs used to illustrate how the VIEW_STORAGE is seen by the host and plugin. The first log is when we use the host's text function. The second log is when we use the plugin's text function. In both sets of logs I print out the location of VIEW_STORAGE as seen by the host and plugin as well as the structure of VIEW_STORAGE.view_ids before and after calling plugin.render(). In the second log there is an extra set of VIEW_STORAGE.view_ids printed to see how it changes when the plugin's text function is used. We can see that the plugin's VIEW_STORAGE.view_ids is empty when compared to the VIEW_STORAGE.view_ids of the host.

When using the "host" function:

        ===== Begin host main =====
        Floem version: 0.1.0
        VIEW_STORAGE vtable: 0x54535f5745495609
        ====== End host main ======
        ===== Begin plugin_entry =====
        Floem version: 0.1.0
        VIEW_STORAGE vtable: 0x54535f5745495609
        ====== End plugin_entry ======
VIEW_STORAGE prior to calling plugin.render():
        SlotMap {
    slots: [
        Slot {
            version: 0,
            next_free: 0,
        },
        Slot {
            version: 1,
            value: (),
        },
        Slot {
            version: 1,
            value: (),
        },
    ],
    free_head: 3,
    num_elems: 2,
    _k: PhantomData<fn(floem::id::ViewId) -> floem::id::ViewId>,
}
VIEW_STORAGE after calling plugin.render():
        SlotMap {
    slots: [
        Slot {
            version: 0,
            next_free: 0,
        },
        Slot {
            version: 1,
            value: (),
        },
        Slot {
            version: 1,
            value: (),
        },
        Slot {
            version: 1,
            value: (),
        },
    ],
    free_head: 4,
    num_elems: 3,
    _k: PhantomData<fn(floem::id::ViewId) -> floem::id::ViewId>,
}

With using the plugin function:

        ===== Begin host main =====
        Floem version: 0.1.0
        VIEW_STORAGE vtable: 0x54535f5745495609
        ====== End host main ======
        ===== Begin plugin_entry =====
        Floem version: 0.1.0
        VIEW_STORAGE vtable: 0x54535f5745495609
        ====== End plugin_entry ======
VIEW_STORAGE prior to calling plugin.render():
        SlotMap {
    slots: [
        Slot {
            version: 0,
            next_free: 0,
        },
        Slot {
            version: 1,
            value: (),
        },
        Slot {
            version: 1,
            value: (),
        },
    ],
    free_head: 3,
    num_elems: 2,
    _k: PhantomData<fn(floem::id::ViewId) -> floem::id::ViewId>,
}
VIEW_STORAGE after plugin render using plugin function:
        SlotMap {
    slots: [
        Slot {
            version: 0,
            next_free: 0,
        },
    ],
    free_head: 1,
    num_elems: 0,
    _k: PhantomData<fn(floem::id::ViewId) -> floem::id::ViewId>,
}
VIEW_STORAGE after plugin render using plugin function:
        SlotMap {
    slots: [
        Slot {
            version: 0,
            next_free: 0,
        },
        Slot {
            version: 1,
            value: (),
        },
    ],
    free_head: 2,
    num_elems: 1,
    _k: PhantomData<fn(floem::id::ViewId) -> floem::id::ViewId>,
}
VIEW_STORAGE after calling plugin.render():
        SlotMap {
    slots: [
        Slot {
            version: 0,
            next_free: 0,
        },
        Slot {
            version: 1,
            value: (),
        },
        Slot {
            version: 1,
            value: (),
        },
    ],
    free_head: 3,
    num_elems: 2,
    _k: PhantomData<fn(floem::id::ViewId) -> floem::id::ViewId>,
}