gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2024-11-26 07:21:54 +00:00
Code Issues Actions 14 Packages Projects Releases Wiki Activity

Update README.md (#12)

Browse Source 
Throughout the text I have tried to make it a bit more readable.
This commit is contained in:
Pieter van Mill 2019-05-10 16:50:10 +02:00 committed by Wang Xin
parent 5df8e94c29
commit 8c76e17e29
1 changed files with 57 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
README.md
View File

@ -1,40 +1,40 @@
WebAssembly Micro Runtime
=========================
WebAssembly Micro Runtime (WAMR) is standalone WebAssembly (WASM) runtime with small footprint. It includes a few components:
WebAssembly Micro Runtime (WAMR) is standalone WebAssembly (WASM) runtime with a small footprint. It includes a few components:
- WebAssembly VM core
- WASM application programming API (code available, but compilation is depending on the app manager component)
- Dynamic WASM application management (Not available in github yet. It will be released soon)
- WASM application programming API (code available, but compilation depends on the app manager component)
- Dynamic WASM application management (Not available on Github yet. It will be released soon)
Why should we use a WASM runtime out of browser? There are a few points which might be meaningful:
1. WASM is already a LLVM official backend target. That means WASM can run any programming languages which can be compiled to LLVM IR. It is a huge advantage comparing to those language bound runtimes like JS, Lua.
2. WASM is an open standard and the growing trend is so fast as it is supported by the whole web ecosystem
3. WASM is designed to be very friendly for compiling to native binary and gaining the native speed.
4. Potentially change the development practices. Imaging we can do both the WASM application development and validation in a browser, then just download the wasm binary code into the target device.
5. WASM can work without garbage collection. It can be designed to support execution determinics for the time sensitive requirement.
Why should you use a WASM runtime out of your browser? There are a few points where this might be meaningful:
1. WASM is already a LLVM official backend target. That means WASM can run any programming languages which can be compiled to LLVM IR. It is a huge advantage compared to language bound runtimes like JS or Lua.
2. WASM is an open standard and it is fast becoming supported by the whole web ecosystem.
3. WASM is designed to be very friendly for compiling to native binaries and gaining the native speed.
4. It can potentially change the development practices. Imagine we can do both the WASM application development and validation in a browser, then just download the WASM binary code onto the target device.
5. WASM can work without garbage collection. It is designed to support execution determinics for the time sensitive requirement.
Features
=========================
- WASM interpreter (AOT is planned)
- Provide built-in Libc subset, support "side_module=1" EMCC compilation option
- Provide APIs for embedding runtime into production software
- Provide mechanism for exporting native APIs to WASM applications
- Support programming firmware apps in multi languages (C/C++/Java/Rust/Go/TypeScript etc.)
- Provides built-in Libc subset, supports "side_module=1" EMCC compilation option
- Provides API's for embedding runtime into production software
- Provides a mechanism for exporting native API's to WASM applications
- Supports the programming of firmware apps in a large range of languages (C/C++/Java/Rust/Go/TypeScript etc.)
- App sandbox execution environment on embedded OS
- Pure asynchronized programming model
- Purely asynchronized programming model
- Menu configuration for easy platform integration
- Support micro service and pub-sub event inter-app communication models
- Supports micro-service and pub-sub event inter-app communication models
- Easy to extend to support remote FW application management from host or cloud
Architecture
=========================
The application manager component handles the packets that the platform received from external through any communication buses such as socket, serial port, PSI. A packet type can be either request, response or event. The app manager will serve the requests with URI "/applet" and call the runtime glue layer interfaces for installing/uninstalling the application. For other URIs, it will filter the resource registration table and router the request to internal queue of responsible application.
The application manager component handles the packets that the platform receives from external sources through any communication buses such as socket, serial port or PSI. A packet type can be either a request, response or event. The app manager will serve the requests with URI "/applet" and call the runtime glue layer interfaces for installing/uninstalling the application. For other URI's, it will filter the resource registration table and route the request to the internal queue of the responsible application.
The WebAssembly runtime is the execution environment for WASM applications.
The messaging layer can support the API for WASM applications communicate to each other and also the host environment.
The messaging layer can support the API for WASM applications to communicate to each other and also the host environment.
When Ahead of Time compilation is enabled, the WASM application can be either bytecode or compiled native binary.
When Ahead of Time compilation is enabled, the WASM application can be either bytecode or a compiled native binary.
<img src="./doc/pics/architecture.PNG" width="80%" height="80%">
@ -42,12 +42,12 @@ When Ahead of Time compilation is enabled, the WASM application can be either by
Build WAMR Core
=========================
Please follow below instructions to build WAMR core on different platforms.
Please follow the instructions below to build the WAMR core on different platforms.
Linux
-------------------------
Firstly please install library dependencies of lib gcc.
Use below installation commands for Ubuntu Linux:
First of all please install library dependencies of lib gcc.
Use installation commands below for Ubuntu Linux:
``` Bash
sudo apt install lib32gcc-5-dev
sudo apt-get install g++-multilib
@ -62,7 +62,7 @@ make
```
Zephyr
-------------------------
You need download Zephyr source code first and embedded WAMR into it.
You need to download the Zephyr source code first and embedded WAMR into it.
``` Bash
git clone https://github.com/zephyrproject-rtos/zephyr.git
cd zephyr/samples/
@ -79,18 +79,18 @@ ninja
Build WASM app
=========================
A popular method to build out WASM binary is to use ```emcc```.
Assuming you are using Linux. Please install emcc from Emscripten EMSDK following below steps:
Assuming you are using Linux, please install emcc from Emscripten EMSDK following the steps below:
```
git clone https://github.com/emscripten-core/emsdk.git
emsdk install latest
emsdk activate latest
```
add ```./emsdk_env.sh``` into path to ease future use, or source it everytime.
Emscripten website provides other installtion method beyond Linux.
add ```./emsdk_env.sh``` into the path to ease future use, or source it everytime.
The Emscripten website provides other installtion methods beyond Linux.
todo: user should copy the app-libs folder into project and include and build.
You can write a simple ```test.c```as the first sample.
You can write a simple ```test.c``` as the first sample.
``` C
#include <stdio.h>
#include <stdlib.h>
@ -116,7 +116,7 @@ int main(int argc, char **argv)
return 0;
}
```
Use below emcc commmand to build the WASM C source code into WASM binary.
Use the emcc commmand below to build the WASM C source code into the WASM binary.
``` Bash
emcc -g -O3 *.c -s WASM=1 -s SIDE_MODULE=1 -s ASSERTIONS=1 -s STACK_OVERFLOW_CHECK=2 \
-s TOTAL_MEMORY=65536 -s TOTAL_STACK=4096 -o test.wasm
@ -125,30 +125,30 @@ You will get ```test.wasm``` which is the WASM app binary.
Run WASM app
========================
Assume you are using Linux, the command to run the test.wasm is
Assume you are using Linux, the command to run the test.wasm is:
``` Bash
cd iwasm/products/linux/bin
./iwasm test.wasm
```
You will get output:
You will get the following output:
```
Hello world!
buf ptr: 0x000101ac
buf: 1234
```
If you would like to run test app on Zephyr, we have embedded test sample into its OS image. You need to execute
If you would like to run the test app on Zephyr, we have embedded a test sample into its OS image. You will need to execute:
```
ninja run
```
Embed WAMR into software production
=====================================
WAMR can be built into a standalone executable which takes WASM application file name as input, and then execute it. To use it in the embedded environment, you should embed WAMR into your own software product. WASM provides a set of APIs for embedders code to load WASM module, instansiate module and invoke WASM function from native call.
WAMR can be built into a standalone executable which takes WASM application file name as input, and then execute it. To use it in the embedded environment, you should embed WAMR into your own software product. WASM provides a set of API's for embedded code to load WASM module, instantiate the module and invoke the WASM function from a native call.
<img src="./doc/pics/embed.PNG" width="60%" height="60%">
A typical WAMR APIs usage is as below:
A typical WAMR API usage is as described below:
``` C
wasm_module_t module;
wasm_module_inst_t inst;
@ -173,19 +173,19 @@ A typical WAMR APIs usage is as below:
WASM application library
========================
In general, there are 3 kinds of APIs for programming the WASM application:
- Built-in APIs: WAMR has already provided a minimal API set for developers.
- 3rd party APIs: Programmer can download include any 3rd party C source code, and added into their own WASM app source tree.
- Platform native APIs: WAMR provides a mechanism to export the native API to the WASM applications.
In general, there are 3 kinds of API's for programming the WASM application:
- Built-in API's: WAMR has already provided a minimal API set for developers.
- 3rd party API's: Programmer can download and include any 3rd party C source code, and add it into their own WASM app source tree.
- Platform native API's: WAMR provides a mechanism to export the native API to the WASM application.
Built-in application library
---------------
Built-in APIs include Libc APIs, Base library, Extension library reference.
Built-in API's include Libc APIs, Base library and Extension library reference.
**Libc APIs**<br/>
It is the minimal Libc APIs like memory allocation and string copy etc.
The header files is ```lib/app-libs/libc/lib-base.h```. The API set is listed as below:
This is the minimal Libc APIs like memory allocation and string copy etc.
The header file is ```lib/app-libs/libc/lib-base.h```. The API set is listed as below:
``` C
void *malloc(size_t size);
void *calloc(size_t n, size_t size);
@ -206,7 +206,7 @@ char *strncpy(char *dest, const char *src, unsigned long n);
```
**Base library**<br/>
The basic support for communication, timers etc is already available. You can refer to the header files ```lib/app-libs/base/wasm-app.h``` which contains the definitions for request and response APIs, event pub/sub APIs and timer APIs. Please be noted that these APIs require the native implementations.
The basic support for communication, timers etc is already available. You can refer to the header file ```lib/app-libs/base/wasm-app.h``` which contains the definitions for request and response API's, event pub/sub APIs and timer APIs. Please note that these API's require the native implementations.
The API set is listed as below:
``` C
typedef void(*request_handler_f)(request_t *) ;
@ -232,7 +232,7 @@ void api_timer_restart(user_timer_t timer, int interval);
```
**Library extension reference**<br/>
Currently we provide the sensor APIs as one library extension sample. In the header file ```lib/app-libs/extension/sensor/sensor.h```, the API set is defined as below:
Currently we provide the sensor API's as one library extension sample. In the header file ```lib/app-libs/extension/sensor/sensor.h```, the API set is defined as below:
``` C
sensor_t sensor_open(const char* name, int index,
void(*on_sensor_event)(sensor_t, attr_container_t *, void *),
@ -245,11 +245,11 @@ bool sensor_close(sensor_t sensor);
The mechanism of exporting Native API to WASM application
=======================================================
The basic working flow for WASM application calling into the native API is described as following diagram.
The basic working flow for WASM application calling into the native API is described in the following diagram.
<img src="./doc/pics/extend_library.PNG" width="60%" height="60%">
WAMR provides the macro `EXPORT_WASM_API` to enable users to export native API to WASM application. WAMR implemented a base API for timer and messaging by using `EXPORT_WASM_API`. They can be reference point of extending your own library.
WAMR provides the macro `EXPORT_WASM_API` to enable users to export native API to a WASM application. WAMR implemented a base API for the timer and messaging by using `EXPORT_WASM_API`. They can be a reference point for extending your own library.
``` C
static NativeSymbol extended_native_symbol_defs[] = {
EXPORT_WASM_API(wasm_register_resource),
@ -264,26 +264,26 @@ static NativeSymbol extended_native_symbol_defs[] = {
```
![#f03c15](https://placehold.it/15/f03c15/000000?text=+) **Security attention:** The WebAssembly application is supposed to access its own memory space, the integrator should carefully design the native function to ensure the memory safe. The native API to be exporte to WASM application must follow the rules:
![#f03c15](https://placehold.it/15/f03c15/000000?text=+) **Security attention:** The WebAssembly application is supposed to access its own memory space, the integrator should carefully design the native function to ensure that the memory is safe. The native API to be exported to the WASM application must follow these rules:
- Only use 32 bits number for parameters
- Don’t passing data structure pointer (do data serialization instead)
- Do the pointer address conversion in native API
- Don’t passing function pointer as callback
- Don't pass data to the structure pointer (do data serialization instead)
- Do the pointer address conversion in the native API
- Don’t pass function pointer as callback
Below is a sample of library extension. All invoke across WASM world and native world must be serialized and de-serialized, and native world must do boundary check for every incoming address from WASM world.
Below is a sample of a library extension. All code invoked across WASM and native world must be serialized and de-serialized, and the native world must do a boundary check for every incoming address from the WASM world.
<img src="./doc/pics/safe.PNG" width="100%" height="100%">
Exporting native API steps
==========================
WAMR implemented a framework for developers to export APIs. The procedure to expose the platform APIs in three steps:
WAMR implemented a framework for developers to export API's. Below is the procedure to expose the platform APIs in three steps:
**Step 1. Create a header file**<br/>
Declare the APIs for WASM application source project to include.
Declare the API's for your WASM application source project to include.
**Step 2. Create a source file**<br/>
Export the platform APIs, for example in ``` products/linux/ext-lib-export.c ```
Export the platform API's, for example in ``` products/linux/ext-lib-export.c ```
``` C
#include "lib-export.h"
@ -295,7 +295,7 @@ static NativeSymbol extended_native_symbol_defs[] =
```
**Step 3. Register new APIs**<br/>
Use macro EXPORT_WASM_API and EXPORT_WASM_API2 to add exported APIs into the array of ```extended_native_symbol_defs```.
Use the macro `EXPORT_WASM_API` and `EXPORT_WASM_API2` to add exported API's into the array of ```extended_native_symbol_defs```.
The pre-defined MACRO `EXPORT_WASM_API` should be used to declare a function export:
``` c
#define EXPORT_WASM_API(symbol) {#symbol, symbol}
@ -338,24 +338,24 @@ static NativeSymbol extended_native_symbol_defs[] =
```
Use extended library
------------------------
In the application source project, it includes the WAMR built-in APIs header file and platform extension header files.
Assume the board vendor extend the library which added a API called customized(). The WASM application would be like this:
In the application source project, it will include the WAMR built-in APIs header file and platform extension header files.
This is assuming the board vendor extends the library which added an API called customized(). The WASM application would be like this:
``` C
#include <stdio.h>
#include "lib-export-dec.h" // provided by platform vendor
#include "lib-export-dec.h" // provided by the platform vendor
int main(int argc, char **argv)
{
int I;
char *buf = “abcd”;
customized(); // customized API provided by platform vendor
customized(); // customized API provided by the platform vendor
return i;
}
```
Coming soon...
========================
We are preparing the open source for application manager and related cool samples like inter-application communication, application life cycle management, 2D graphic demo and more. You will get updated soon.
We are preparing the open source code for the application manager and related code samples like inter-application communication, application life cycle management, 2D graphic demo and more. This will get updated soon.
Submit issues and request
=========================