IPFS IPFS þing 2022 - IPFS and WASM, 10 Aug 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Marine: dynamic Wasm modules linking - @mikevoronov - IPFS and WASM

Description

Marine: dynamic Wasm modules linking - presented by @mikevoronov at IPFS bing 2022 - IPFS and WASM - https://2022.ipfs-thing.io

A

My name is mike and I'm from cleveland swaps, and today, I'm going to tell you about marine. Our general purpose web assembly run time. The toy content for run multimodal web assembly applications and, in particular the agenda of my talk, is as follows. So, first of all, uh I will talk a bit about the webassembly component model.

A

I think that it's like the most valuable proposal that now webassembly folks try to push. Then I will talk also a bit about how we use webassembly influence and why we need our own runtime and, what's like use case for web assembly in like fluent swaps, and how, for example, aqua vm that was already mentioned, also approach this model and then finally, we will talk about the architecture of marine and how sdk and tools and how you could use marine debug your application and how it could be used, probably with ipod and ipfs.

A

So, let's start with the webassembly component model with some basics, but first of all like to be on the same page, I need to say that, like webassembly has one important uh restrictions that like already was already mentioned, and this restriction is about types. Yes, webassembly has only five basic types. They are two integers two voting point and one at types for sims instructions, and usually everyone who develops their own runtime stumbled across the problem that like we need to pass.

A

Not only numbers but complex objects like strings arrays structures and the stuff like that and like almost all runtimes uh tries to solve it. Yes tries to provide some ebi to like grab string from memory converted to point, run the size and lower it back. So it's like uh usual usual thing for almost every every runtime before the component model, because component model, like I I got, I got all the stacks from the official uh proposal.

B

A

You could see here like the first uh three. Hello goes. Yes, the first one is a defined portable, uh binary format that would be like could provide your uh language, agnostic interface and also, I would say that not only language agnostic, but also operation system and architecture, agnostic interface. I think it's the most valuable part of this proposal, and on this slide you could see that could be called lightweight component model view.

A

So here you could see like a container or an application or a microservice that contains several webassembly uh modules, and but all of this module is comprised from different modules. So you could consider this as a like these green boxes, you can consider as a uh like applications that itself comprised from libraries, yes like when you, when you write on, I know on c plus rust and so on, you're always using some standard libraries.

A

uh Some other libraries and component is a thing that combines combining together and like uh uh having like high level every users. You could come combine several components in one container and what in like this arrows it's? What actually marine does so component could be considered as a modulus or applications and like if you want to have several modules simultaneously, won't combine them, want to dynamically load and load them.

A

So in this case we could use marine, and you know like uh I have been watching for the component model proposal for a long time for about four years, and I would say that this proposal has a difficult fate, really difficult wait uh here. You see like main milestones, so uh actually component model proposal is combined from two proposals. First, one usually called interface types and second one is model linking yes in interface types it there were a lot of milestones.

A

By milestone, I mean something that completely changes proposal and like in 2021 roberts, only folks decided to combine them together in one proposal and the split interface types to two proposals and use. So I will show you later, but now in component model, only like a tiny fraction of interface types of initial interface types version, two that the code here uh only used and then, like other uh other, like part, is called adapter functions.

A

uh They only like in in appliance, but component model is already there. You could use it uh from watson time from marine. uh I would show you the difference so like and and difference on the slide. So what sometimes like allows you to do component but uh doesn't allow you to combine companies together, like it doesn't, allow you to the dynamic world and load modules.

A

So let's talk a bit about interface types and about model linking so interface types, uh it's very old picture from 2017, but not so much changed from this time.

A

Here you could see like this module that I would call our own webassembly module raw, because it supports only raw types, only numbers basically, and each this module is wrapped by so-called adapted module, and this wrapping means that for every import and forever expert from raw modules, there is a corresponding adapted import and adapted export.

A

By adapted, I mean that, like uh it could lower, it could lift and lower types. So, for example, in adapted module you could pass strings race and complex types. Then it could lower it and call raw module that do the do like actually, like all logic and and back yes and back, you could leave type from raw module and provided as a complex object as an output or also could use lifting for imports, usually, like all interface types, all stuff related to them.

A

They are located in a custom section, because custom sections are completely user defined and you could see you could put it like uh any bytes. You want, and usually they are located in nothing like their own section but like in a custom section. uh The next proposal is moodle linking so model. Linking is just what like what we need to combine modules.

A

uh Actually, there are two types of linking scheme characteristic and shared nothing. So the first one uh like based on chart everything from a module every every state, every state that the store like according to specification, has such as memories tables, globals imports and so on, and the second one like station is different module encapsulated state and provides only experts and inputs and modules could be combined together only by imports and experts.

A

On the side, you could see also like a picture from the official presentation of component model. Here you could see, like main keywords, main new keywords- uh probably the most interesting part is here- is adapted function that, like remember, that was switched from interface types as a separated one, and here you could see like lower params and lift result.

A

So this how uh interface types would work just like they receive stream, yes or like any any complex object, then lower it uh to webassembly to row of assembly, uh module memory and pass and call x the actual function, yes and then the lift result back and it what actually like. So in ipod, uh it's there is a similar process, so we also have like a so-called data module and you have rules how data could be lifted and lowering according to the different targets.

A

So in this sense, like interface types, is very, very similar to ipod, in my case so in, in my opinion, sorry, and also the last last slide from the official presentation. It's how it's. What is the target of component model here? You can see a spawn like um what was only folks says that, like we have trade-offs here, we could support.

A

uh We could support, for example, static life cycle static linkage, uh but like nodejit and no garbage collection on other side, you could support full jit, yes, but know these properties and the goal of component model is to support. Only this part is that what I said to icons is picture these green boxes, so it's like actually green boxes, is only a static linking. So when you it's you, you could consider it as a like uh when you're programming on cc, plus, plus, rust and etc.

A

You could build it as a static library or static binary. It's essentially.

A

And the last slide from this section is about fit interface. That's what I ask uh so actually like component model proposal, also specifies so actually it's a very complex proposal. It I, I would say that it's rule changer for zero assembly world. It specified with interface.

A

So it's this interface comprised of several like keywords, but there is a keywords related to like data format so and and there you could see that, like wheat interface, support records, list, tuples and all star all bunch of complex types, so with interface, you could describe every type you want actually so like when component model uh like would take place and would widespread there wouldn't be any necessity for custom ebi for custom type conversion, martial lifts in and over and so on. So there will be standard way to do that.

A

uh So, let's move on to the fluence of assembly use case, so actually uh fluence is consists of, like fluence stack and probably the most valuable parts of film stack is a language called aqua that intended for, uh like pre-coordination and peer-to-peer network, it's inspired by pcalcus.

A

It allows you to coordinate and orchestrate uh network requests and how it connected with webassembly.

A

So basically, aqua allows you to like compose web assembly modules located on our peer-to-peer network and in a self this modules, or I would say that services and I would describe what services on the next slide, but the services there are webassembly-based they based on a websimilar component model with help of interface types and model linking they could be state forward, stateless and they could be extendable uh like with so-called mounted binaries, so actually from a web assembly module. We could call external binary.

A

I I would show you interface later, uh so that's how it could be extendable and fluent service actually is just a group of modules, combined together with the sharedness and linking scheme, and one thing that I forgot to mention. So if you need shared nothing scheme, uh you would need interface types because it's impossible to decouple like complex type from webassembly memory, without revealing memory table and so on. The only way to do that is with help of interface types and that's.

A

Why, like marine, also support all this component model, and here you could see example of uh fluent service comprised of three modules, uh so we have like sqlite radius compiled assembly and compatible with uh marine interface and, uh like I hear escalate, is linked together with some module called facade uh through exports and imports, and also imagine that there is a some amplification module that also linked with the facade one actually like in web assembly or sorry influencer apps.

A

uh We have chosen web assembly uh because, like it, provides a lot of advantages like really what first of all it allows us unboxing modules by design, so our miners could not like think about security, uh the module, so they could control effects. They could control modules that like allow you to do something uh manageable on your system.

A

Also webassembly allows you to make life cycle of modules independent on each other with help of component model, so you could develop your module or one could develop. uh One developer could develop their module like uh with only consistent api, so in this like uh as a uh it, could be considered as development of dynamic library.

A

So it's the same experience and here you could see like slides that have already been used, so it's cow maureen is used inside our peer architecture, so actually marine is run time and in marine we run both services and aquaviums, and there are like a bunch of services, bunch of aquavium so and the queue that manages pool- and there is a like pure core- that manages queues and handle events between the skews uh and a fluence network could be considered like this on every period.

A

In our network there is a marine and there is aqua, vm and also marine could be run in a browser on the client side. So there is a like almost the same experience uh and what's dike, what dick into the marine one time itself.

A

So when we uh initially started the marine uh we defined some high level goals, so the first one is the most important one is maureen should provide like, uh like the best developer, experience that possible yes and for us the best developer. Experience is like allowing developers to write on when you are asked as where is possible.

A

uh Also, marine should allow you to compose module to run on server and client-side is already set and also have a fine-grained resource control.

A

And here you could see the marine architecture very, like high-level blocks, so marine actually has layered architecture and on the bottom side we have like supported uh run times. Here you could see was mirror and uh some browser runtimes. So for right, size there is like doesn't uh like. There is no difference between runtime and on the right side. We support now vasmir and move into wasm time. So it supports us uh and we have. We have a core and the main like feature of core.

A

Is that like when you use marine from the rust side from the rust api, the core is a rust like the rust code that compiles to native, but when you use it from the javascript core compiles to webassembly and run into the marie's marine.js wrapper written on javascript.

A

So this, like part of marinette itself, for marine and marine js. So you could find also like the complete details and complete uh description of the scheme in our marine book. So then link here uh so and how like? How we approach this multi modules? So actually we have three types of modules. The first one is facade, so for said modules they expose their api of like entire service and only they could be called from aqua, not like every module from service, but only facade pure modules say contain pure logic.

A

They can't access file systems, they can access external binaries uh and the the last one is factors effectors could access everything? Could access file systems through yz circuits when they will be ready when we switch to washing time and stuff like that?

A

So why we need pure and effector modules, because effectors are those modules that could damage your system, damage system of miners and miners uh should have a chance to pick which modules they trust, which effector models, they trust and when you deploy pure module, so everyone could be could feel safe because pure module doesn't call any import and yeah web assembly is unboxed itself by design, and here you could see another picture how it could be represented, so uh marine could load several modules, combine them together to services and uh provide a way to call these services from uh like from the external api uh and uh like let's dive a bit, how like service looks like and what is how they could combine together.

A

uh So here you could see service configurations, basically thomas file, so uh let's consider services that contains of three modules. It's like just uh example: it's not like real service, uh so the first uh module is first aid. It should be more like uh put as a last line this next one is a cool adapter, so here we could see that we should specify name and also should specify the section called mounted binaries. It's essentially our interface to external binaries, and this black line allows a module to call binary located by this bus.

A

The last one is vocal storage, so here could see, buy and show off settings, for example, for each model you could adjust like a memory maximum memory size. Also, you could adjust a yg state. You could say that, like this, module could use only these files and inside like there is. It could be a mapping from like this path to some shorthand.

A

And, probably is the most important think here for those who want to use marine from uh as a runtime itself from their ras project is a the cinema code type value. So I value is like in num that you could use uh specifying host experts host imports and using it as a like, uh like from your rust projects.

A

So um several uh guys said that, like it's really difficult to uh like work with pointers like grabbing strings from memory and stuff like that- and here like you- could see, I value the type that uh like allows you to do. Not use. Don't do that. Yes, it's like has just ring just array, and this type is a like type that you could use in your host export function.

A

So it's function that you are written on rust or like language that you uh from from, like from those that you use marine, and here you could see a descriptor of host exported function. So actually this function is a quarter that takes some context. It doesn't matter so it's just allows you to do some more stuff and a vector of I values and a values is essentially an argument that, like uh would put into your import function and the result is also value.

A

So here you could specify argument types, output, types. There was a great question about how dynamic linking works and like, in our case it works like that, so you should specify types you like they can't be uh get from out of some uh error, so you need to specify types of a function and also you could have your handler. So, let's consider an example for how mounted binary import could be written on with the scheme.

A

So here we could see like a function that returns this descriptor and the most important part here is the closure itself. So quarter uh receives arguments. Yes, that is just a vector of five values, called the functions that actually do some logic over this high values and then like uh convert result back to ivalia.

A

So that's how like it could look like yes, only three lines: you don't need to care about. Memories about that string represent by point, run size and stuff like that, so you have handy eye values and you could work with them and also you should specify types here, but I think it's not so bad developer experience and it's like from some case it's unavoidable, because you need this dynamic function linking and that's how the entire function look like.

A

uh So, let's move on to the marines decaying tools, and here you can see how how world could look like with our sdk. So we want. As I already said, we want uh developer experience close to when you were asked and here's. The only thing that you need to do is just to use our procedure. Macro called marine and like applying this macro to a function, makes it exportable.

A

So this code we would compile with our marine coi tool with just marine, build two web assembly modules that exports a greeting function from itself, and here please note that this function takes strings. It not takes all webassembly types takes whenever us types uh so like. Let's imagine like let's remember uh again, you wrote on order servers that we consider and see how. uh So this example was about previous example, was about exporting.

A

This example is about importing, so imagine that we have um this service that contains of three modules, and we want to like uh combine them together from the code perspective from the ras side, and to do that like the only uh thing that you need to do is just to use rust, foreign function interface and also, if you wrap like this external function with the marine runtime, you would have almost the same experience that, like with the rust ffi, so also, please note that here you could use whenever rust types.

A

uh Of course, there are some constraints uh you can't use like every type you want. I, I will show you later what constraints are, and here you could see like how this module could be built. Yes, there are three webassembly files for say, coral and local storage, and uh so this. This is why just a little little example, yes, uh coral web webassembly file, just download file with help of coral binary and the local storage just save somewhere in the file system, and here on the facade module you use, exported function from this two modules.

A

That's how it look like from the developer side and, of course, not only strings and not only vectors, could be passed. You could pass records, so I mean strikes, so you could even use uh references, but it's not so much sense.

A

The only implication that now we have is support of enams. We like don't support them now because, uh like we could more or less easily add them to marine run time, but it would be so hard to add them to the aqua side.

A

So that's why we don't uh like do it now but like if someone want to use maureen and there would be demand for them, so we could easily easily eat them at them and also, as I said, uh marine could be run uh from the browser, and here you could see example how it could run from the javascript site. uh So imagine a service that has some not so trivial uh signature.

A

Yes, it takes a string and takes some object that actually is extract and on the right side you could see how it could be called from the javascript side.

A

So- and here uh so also- I haven't said, but from the right side, you could also use json objects, so we could also co-function not with just vector five values but with json object. That would be also over it and like the result. Pointers would be passed to row modules uh as it did, and here are the same experience it's also like it wouldn't be. I know, as you would say, uh series just by. I know, sir there and the past as a array of bytes it would be.

A

There would be like a honest, uh like typed reversal, uh some comparison and wolverine if each type as a signature says how signature size- uh and the last topic here is about how all of this could be tested. So we have our own uh another macro called marine test, and it provides you also like uh when uh calls to a new rest experience. uh Hero could should specify for like pass to configuration, file and pass to modules directories, whereas the binaries allocated and you could just use inside uh this function, you could use interface.

A

uh That would be like uh completely the same as a module has yes. The difference here is usual testing that that's like in usual, this function itself compiles the webassembly and test runs from from the web assembly itself. Here this function won't become part of our assembly here, like under the hood. The marine on time would be instantiated and the greeting function could be called and also you have almost the same experience for services. You could test several services as it is like on the slide here.

A

Yes, you could just specify them in marine test config and then call their facade modules and probably it's last slide. It's a last tool called marine repo. This is tool we could just test modules from the repo experience, and here you could see. Example of ipfs uh like ip ipfs, effector and ipfs pure module, where ap face effector uses.

A

Ipfs daemon, located on your system, and here code like an iphone pure, is just a module that called in itself iphos, effector and here. In this example, we just call from the iphone secure, pure function, put provide some arguments, one two and three in array.

A

The result is a hash that published to ipfs, and then we could call iphosph providing this hash, and you could see this beautiful numbers that would be result of this request itself. So thank you very much here. You could see, uh like all links to the marine rasters did key in aqua and also, if you take care about marine, please take a look to marine book. There is like complete information about architecture, about sdk how we could develop.

A

Oh. Thank you very much.

C

uh So first question is why external binaries like? Why can't I just like use, wasn't for everything like amount of binaries yeah like? Why do I need to use curl or anything like that.

A

Because, like you know, when we started it, it was, it was very easy to just call them like in a prototype from your uh webassembly module as a coi binary.

A

Now was it like itself, like so like advanced, that it could be called from with help of yg, not with help of like this cli modules, and also when, like circuits was made in wazi at the beginning of this year, and also like a lot of uh programs could be, could be called with a unique circuit, with a local unix circuit, with help of yc circuits itself. So yeah, it's a good question and this interface could be considered as like as an example.

A

As a like the most simple way to call binaries and in future we would consider uh moving uh to vasi completely.

C

So so would I be able to like have my program? Specified depends on like curl and then, when I compile my program into wasm, it would take curl and like include that and then re transpile it. How would that work.

A

uh No, no it it. It would be called just to use voicing, because why the process start, but then.

C

It would still have to run like the problem, then I have to expect okay. What does this command doesn't exist? What if the command is malicious all that kind of stuff like my question is like. Why can't I just like basically like bundle curl with my my application.

C

Does that make sense.

A

um Yeah so yep it's a good question. So that's why we have like model several model types as effectors and uh pure modules and effector modules should be reviewed before using on and on stuff.

C

Or you know, I agree, I know my point is like: do we really need effectors like like? We can build a world where, like we have like effectively like uh just copy and write semantics and immutable files and stuff like that, or we don't actually need to modify this, but concern is like once you start having a lot of different effects, then you have to start reasoning about the interactions between different effectors and that can get difficult from a security perspective, but.

D

There's a good hack around this, which is to treat those systems and the system it runs in as an actor. So, for example, you can model the binary running on some host os and ideally like a container vm or whatever, and treat that as an actor with some history, and so maybe the history changes for that for the state of the local actor or whatever. But you have some model for encapsulating all the things with side effects.

D

You just put into this like this, like really dirty um environment area, where you don't where you still use message passing into the pure area, and so you can like compute in the pure area as much as you want and ideally fully. But then you can still interact with yes, music computer.

A

D

And external services, by making sure that you model them as some long-lived actor and- and this might even be like massive scale systems right- you can treat all of ntp as like one actor. That is just emitting some clock time, and that gives you like some.

C

I guess what I was looking for is like actually just like taking curl and running it inside a wasm vm and then giving the wasn't vm access to the network via capabilities and stuff like that, because that means I kind of like I don't have to like the only thing like if I need to write state okay, I need some kind of access cables, but usually I don't like. Usually I just like- I can have my local virtual file system, for example in ibfs, and then I produce a cid or spin like that.

C

uh So, like you, just you very rarely actually need mutability for a lot of the stuff or effectors. But that's almost like sorry next thing.

D

So uh totally I completely agree in in the case of curl. You just want to run that curl binary within wasm and so on. It sounds like just like it was hasn't, been a priority for them to like shift over. However, there are other cases where it's not curl.

D

It's like some much more complex example that you need a way of like adapting to external world in a way that you don't get to rewrite the world, but you have you, can you have to make it make sense in in this world and and just figuring out the abstraction there so that you deal with all possible side effects of this thing that might influence some of the pure parts?

D

Because right now, I think all the services are impure right. All the services are treated as like. Who knows what these things are running and you can't really reason about their state. Is that correct? Or yes? Yes, so I think like once you start using ipld there. Then you get a hash linked state for those things, and ideally those can become um this kind of like semi-pure uh forever. You called it.

D

It was like this pure-ish boundary where, like you, have an actor that is effectively pure from the perspective of like whenever you call it, whatever it outputs and so on. You can reason about that whole model, but it does preserve some local state um over time. Yeah actually.

A

Actually, yes, it's it's a good! uh It's a good comment. uh I think we in this way, we could consider you uh use like this links instead of just pass on a workout system. Yes, it's a good idea to use a pod.

E

Yeah, so sometimes this is uh called like pure state. uh Sorry impure state, yes pure state um uh or pure effects, right um there's, but there's that distinction right of this is something that I can rewind and that's: okay and I'm just grabbing. You know a reference versus I'm sending an email and I'm updating the state of the universe right um so and you kind of like often you want both, but you need to be really careful with the second one.

C

uh Dexcom wasn't it looks like it's almost the ipod data model and we should be able to just create codec as you're saying, but is it self-describing internally as like I can, I can take an I value, object and say what it is like. This is like no.

A

No, it's it's just. I will so it's an answer to the question you want to. uh Like have information from like which services uh I will vector five value: okay,.

C

No, no sorry, I I want to know like. Is it an int? Is it a string? Is it whatever? Is that included inside the value.

A

No, no, it's it's! It's rusty num! So it's rust! Now we could have like much from variants. It's not not a one, not a right object. Okay, but.

C

Like it's a bit.

A

C

I I know I saw the rust enum there, but that has to then cross a boundary and go somewhere else.

C

But how does this cross the boundary, then? How do you get this from pointing to point b like we.

A

We have api how this I really crossed the uh boundary and like in the future. When we are now, we are moving to that's exactly why you need to press that. Yes,.

D

A

You just, I think,.

D

What's going on functions and you define the type there and then.

B

D

Use this to pass the value from the input, but it does not carry another text information. So it's just like that box.

C

Got it okay? But I guess my question is more like when, because when you cross the boundary you have to you go, do something or you do some funkiness.

B

Do you analyze the web assembly text and just like find which these types are and then take a type generation.

A

Exactly yes, we we embed information into webassembly, binary itself in a custom section and custom section contains a description of all function of all their signatures and like according to their signatures. Runtime could like extract types and struct uh objects from webassembly memory.

C

Okay, so it's not dynamic at all. It's like. I have some static object.

A

uh It's dynamic in sense of that, like the signature of function like could be changed and when you like, uh having exported from a host site function, you should you shouldn't know a type like in advance.

A

You could like you, could code it like it. Could you could put it into our this descriptor one second.

A

Into this one, in this sense, it's like dynamic function.

C

Okay, but in that sense like something is going to have to like say the types at some point. Yes,.

A

It's uh this safety uh checks by interface, type instructions.

C

How does that check like, where are the types specified wherever you're touching.

D

C

Something here where you transfer the data across yes,.

D

You write the text over here.

A

So it's how interface types works in the web assembly binaries, there is a like description of signature function. So these types- and there is a bunch bunch of uh I will. I will show you that.

C

Okay never mind: uh we can talk later.

A

C

So, okay, so that means basically, this does not work as ipld. uh It would require more.

A

Okay, let me try just usual usual terminal. Instead of fish.

A

uh So there is a like it's a written binary, so that contains only one export functions and there is a how it looks like from the low level stuff. There is a adapter function for this row type function and contains of uh interface type instruction that actually, like the do. All the like. All the logic of type extraction.

A

C

No, we will talk about it.

A

B

Okay and then um so how much binding can you generate? Well, you have the function, uh the output types right, um so you can generate that. But can you generate like the actual function calls like from javascript into the web assembly like uh what uh what's been does currently.

A

Yes, it's it's it's similar to. What's in my engine, yes and uh like, if you are talking about uh so the first thing that I need to say is that binaries run both on a javascript site on rough side that they are essentially the same. So the glue codes are generated by the our procedure, macros.

A

They are the same both for javascript and rust and uh like it's a bit similar to what was my engine does is, but it does it only for the outskirt side- and there are like uh there is a bunch of uh ebi functions that could every module export to the remodel export like allocate the allocate and stuff like that, uh so they're similar to what uh should we do in the interface type site and like actually a core module that um that core on this swipe?

A

It actually call it actually interprets interface types instructions and then some sort of like web assembly memory type should be done. It calls import function from uh marine.js and marine.js acts here as a some sort of manager and itself. It also comes to a specific module and extract memory from it. um You might answer the question yeah.

B

um And how old does this work with? uh um What's it called uh the share everything scheme where you have multiple memory or multiple memories accessing each other.

A

um So actually maureen doesn't support shared every single linking scheme at all. Okay.

B