christoph/wamr
1
Fork 0
Code Releases Activity

Import FreeRTOS platform experiment codes for further development (#451)

Browse Source
This commit is contained in:
Wenyong Huang
2020-11-26 19:10:05 +08:00
committed by GitHub
parent 74be7a0b7c
commit 0359805c82
11 changed files with 1117 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

315
core/shared/platform/freertos/freertos_platform.c Normal file
View File

@ -0,0 +1,315 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
int errno = 0;
int
os_thread_sys_init();
void
os_thread_sys_destroy();
int
bh_platform_init()
{
return os_thread_sys_init();
}
void
bh_platform_destroy()
{
os_thread_sys_destroy();
}
void *
os_malloc(unsigned size)
{
return NULL;
}
void *
os_realloc(void *ptr, unsigned size)
{
return NULL;
}
void
os_free(void *ptr)
{
}
int os_printf(const char *format, ...)
{
/* TODO: implement os_printf */
return 0;
}
int
os_vprintf(const char *format, va_list ap)
{
/* TODO: implement os_vprintf */
return 1;
}
void *
os_mmap(void *hint, size_t size, int prot, int flags)
{
return BH_MALLOC(size);
}
void
os_munmap(void *addr, size_t size)
{
BH_FREE(addr);
}
int
os_mprotect(void *addr, size_t size, int prot)
{
return 0;
}
void
os_dcache_flush()
{
}
int atoi(const char *nptr)
{
bool is_negative = false;
int total = 0;
const char *p = nptr;
char temp = '0';
if (NULL == p) {
os_printf("invlaid atoi input\n");
return 0;
}
if (*p == '-') {
is_negative = true;
p++;
}
while ((temp = *p++) != '\0') {
if (temp > '9' || temp < '0') {
continue;
}
total = total * 10 + (int)(temp - '0');
}
if (is_negative)
total = 0 - total;
return total;
}
/**
* TODO: implement these APIs which are needed by libc_builtin_wrapper.c
* and wasm_runtime_common.c
*/
int strncasecmp(const char *s1, const char *s2, size_t n)
{
os_printf("### unimplemented function strncasecmp called!\n");
return 0;
}
long int strtol(const char *str, char **endptr, int base)
{
os_printf("### unimplemented function strtol called!\n");
return 0;
}
unsigned long int strtoul(const char *str, char **endptr, int base)
{
os_printf("### unimplemented function strtoul called!\n");
return 0;
}
unsigned long long int strtoull(const char *nptr, char **endptr, int base)
{
os_printf("### unimplemented function strtoull called!\n");
return 0;
}
double strtod(const char *nptr, char **endptr)
{
os_printf("### unimplemented function strtod called!\n");
return 0;
}
float strtof(const char *nptr, char **endptr)
{
os_printf("### unimplemented function strtof called!\n");
return 0;
}
char *strstr(const char *haystack, const char *needle)
{
os_printf("### unimplemented function strstr called!\n");
return NULL;
}
size_t strspn(const char *s, const char *accept)
{
os_printf("### unimplemented function strspn called!\n");
return 0;
}
size_t strcspn(const char *s, const char *reject)
{
os_printf("### unimplemented function strcspn called!\n");
return 0;
}
void *memchr(const void *s, int c, size_t n)
{
os_printf("### unimplemented function memchr called!\n");
return NULL;
}
int isalnum(int c)
{
os_printf("### unimplemented function isalnum called!\n");
return 0;
}
int isxdigit(int c)
{
os_printf("### unimplemented function isxdigit called!\n");
return 0;
}
int isdigit(int c)
{
os_printf("### unimplemented function isdigit called!\n");
return 0;
}
int isprint(int c)
{
os_printf("### unimplemented function isprint called!\n");
return 0;
}
int isgraph(int c)
{
os_printf("### unimplemented function isgraph called!\n");
return 0;
}
int isspace(int c)
{
os_printf("### unimplemented function isspace called!\n");
return 0;
}
int isalpha(int c)
{
os_printf("### unimplemented function isalpha called!\n");
return 0;
}
int isupper(int c)
{
os_printf("### unimplemented function isupper called!\n");
return 0;
}
int toupper(int c)
{
os_printf("### unimplemented function toupper called!\n");
return 0;
}
int tolower(int c)
{
os_printf("### unimplemented function tolower called!\n");
return 0;
}
void *memmove(void *dest, const void *src, size_t n)
{
char *d = dest;
const char *s = src;
if (d < s) {
while (n--)
*d++ = *s++;
}
else {
const char *lasts = s + (n-1);
char *lastd = d + (n-1);
while (n--)
*lastd-- = *lasts--;
}
return dest;
}
static union {
int a;
char b;
} __ue = { .a = 1 };
#define is_little_endian() (__ue.b == 1)
static void swap32(uint8_t* pData)
{
uint8_t value = *pData;
*pData = *(pData + 3);
*(pData + 3) = value;
value = *(pData + 1);
*(pData + 1) = *(pData + 2);
*(pData + 2) = value;
}
static void swap16(uint8_t* pData)
{
uint8_t value = *pData;
*(pData) = *(pData + 1);
*(pData + 1) = value;
}
uint32_t htonl(uint32_t value)
{
uint32_t ret;
if (is_little_endian()) {
ret = value;
swap32((uint8*) &ret);
return ret;
}
return value;
}
uint32_t ntohl(uint32_t value)
{
return htonl(value);
}
uint16_t htons(uint16_t value)
{
uint16_t ret;
if (is_little_endian()) {
ret = value;
swap16((uint8_t *)&ret);
return ret;
}
return value;
}
uint16_t ntohs(uint16_t value)
{
return htons(value);
}

426
core/shared/platform/freertos/freertos_thread.c Normal file
View File

@ -0,0 +1,426 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "platform_api_vmcore.h"
#include "platform_api_extension.h"
#define bh_assert(v) do { \
if (!(v)) { \
os_printf("\nASSERTION FAILED: %s, at %s, line %d\n",\
#v, __FILE__, __LINE__); \
abort(); \
} \
} while (0)
struct os_thread_data;
typedef struct os_thread_wait_node {
/* Binary semaphore */
SemaphoreHandle_t sem;
os_thread_wait_list next;
} os_thread_wait_node;
typedef struct os_thread_data {
/* Next thread data */
struct os_thread_data *next;
/* Thread handle */
TaskHandle_t handle;
/* Thread start routine */
thread_start_routine_t start_routine;
/* Thread start routine argument */
void *arg;
/* Thread local root */
void *tlr;
/* Wait node of current thread */
os_thread_wait_node wait_node;
/* Lock for waiting list */
SemaphoreHandle_t wait_list_lock;
/* Waiting list of other threads who are joining this thread */
os_thread_wait_list thread_wait_list;
} os_thread_data;
static bool is_thread_sys_inited = false;
/* Lock for thread data list */
static SemaphoreHandle_t thread_data_lock;
/* Thread data list */
static os_thread_data *thread_data_list = NULL;
/* Thread data of supervisor thread */
static os_thread_data supervisor_thread_data;
/* Thread name index */
static int thread_name_index;
static void thread_data_list_add(os_thread_data *thread_data)
{
xSemaphoreTake(thread_data_lock, portMAX_DELAY);
if (!thread_data_list)
thread_data_list = thread_data;
else {
/* If already in list, just return */
os_thread_data *p = thread_data_list;
while (p) {
if (p == thread_data) {
xSemaphoreGive(thread_data_lock);
return;
}
p = p->next;
}
/* Set as head of list */
thread_data->next = thread_data_list;
thread_data_list = thread_data;
}
xSemaphoreGive(thread_data_lock);
}
static void thread_data_list_remove(os_thread_data *thread_data)
{
xSemaphoreTake(thread_data_lock, portMAX_DELAY);
if (thread_data_list) {
if (thread_data_list == thread_data)
thread_data_list = thread_data_list->next;
else {
/* Search and remove it from list */
os_thread_data *p = thread_data_list;
while (p && p->next != thread_data)
p = p->next;
if (p && p->next == thread_data)
p->next = p->next->next;
}
}
xSemaphoreGive(thread_data_lock);
}
static os_thread_data *
thread_data_list_lookup(TaskHandle_t handle)
{
xSemaphoreTake(thread_data_lock, portMAX_DELAY);
if (thread_data_list) {
os_thread_data *p = thread_data_list;
while (p) {
if (p->handle == handle) {
/* Found */
xSemaphoreGive(thread_data_lock);
return p;
}
p = p->next;
}
}
xSemaphoreGive(thread_data_lock);
return NULL;
}
int
os_thread_sys_init()
{
if (is_thread_sys_inited)
return BHT_OK;
if (!(thread_data_lock = xSemaphoreCreateMutex()))
return BHT_ERROR;
/* Initialize supervisor thread data */
memset(&supervisor_thread_data, 0, sizeof(supervisor_thread_data));
if (!(supervisor_thread_data.wait_node.sem = xSemaphoreCreateBinary())) {
vSemaphoreDelete(thread_data_lock);
return BHT_ERROR;
}
supervisor_thread_data.handle = xTaskGetCurrentTaskHandle();
/* Set as head of thread data list */
thread_data_list = &supervisor_thread_data;
is_thread_sys_inited = true;
return BHT_OK;
}
void
os_thread_sys_destroy()
{
if (is_thread_sys_inited) {
vSemaphoreDelete(supervisor_thread_data.wait_node.sem);
vSemaphoreDelete(thread_data_lock);
is_thread_sys_inited = false;
}
}
static os_thread_data *
thread_data_current()
{
TaskHandle_t handle = xTaskGetCurrentTaskHandle();
return thread_data_list_lookup(handle);
}
static void
os_thread_cleanup(void)
{
os_thread_data *thread_data = thread_data_current();
os_thread_wait_list thread_wait_list;
SemaphoreHandle_t wait_list_lock;
SemaphoreHandle_t wait_node_sem;
bh_assert(thread_data != NULL);
wait_list_lock = thread_data->wait_list_lock;
thread_wait_list = thread_data->thread_wait_list;
wait_node_sem = thread_data->wait_node.sem;
xSemaphoreTake(wait_list_lock, portMAX_DELAY);
if (thread_wait_list) {
/* Signal each joining thread */
os_thread_wait_list head = thread_wait_list;
while (head) {
os_thread_wait_list next = head->next;
xSemaphoreGive(head->sem);
head = next;
}
}
xSemaphoreGive(wait_list_lock);
/* Free sem and lock */
vSemaphoreDelete(wait_node_sem);
vSemaphoreDelete(wait_list_lock);
thread_data_list_remove(thread_data);
BH_FREE(thread_data);
}
static void
os_thread_wrapper(void *arg)
{
os_thread_data *thread_data = arg;
thread_data->handle = xTaskGetCurrentTaskHandle();
thread_data_list_add(thread_data);
thread_data->start_routine(thread_data->arg);
os_thread_cleanup();
vTaskDelete(NULL);
}
int os_thread_create(korp_tid *p_tid, thread_start_routine_t start, void *arg,
unsigned int stack_size)
{
return os_thread_create_with_prio(p_tid, start, arg, stack_size,
BH_THREAD_DEFAULT_PRIORITY);
}
int os_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
void *arg, unsigned int stack_size, int prio)
{
os_thread_data *thread_data;
char thread_name[32];
if (!p_tid || !stack_size)
return BHT_ERROR;
/* Create and initialize thread data */
if (!(thread_data = BH_MALLOC(sizeof(os_thread_data))))
return BHT_ERROR;
memset(thread_data, 0, sizeof(os_thread_data));
thread_data->start_routine = start;
thread_data->arg = arg;
if (!(thread_data->wait_node.sem = xSemaphoreCreateBinary()))
goto fail1;
if (!(thread_data->wait_list_lock = xSemaphoreCreateMutex()))
goto fail2;
snprintf(thread_name, sizeof(thread_name), "%s%d",
"wasm-thread-", ++thread_name_index);
/* Create the thread */
if (pdPASS != xTaskCreate(os_thread_wrapper, thread_name,
stack_size / 4, thread_data,
prio, &thread_data->handle))
goto fail3;
thread_data_list_add(thread_data);
*p_tid = thread_data->handle;
return BHT_OK;
fail3:
vSemaphoreDelete(thread_data->wait_list_lock);
fail2:
vSemaphoreDelete(thread_data->wait_node.sem);
fail1:
BH_FREE(thread_data);
return BHT_ERROR;
}
korp_tid os_self_thread()
{
return xTaskGetCurrentTaskHandle();
}
int os_thread_join(korp_tid thread, void **value_ptr)
{
os_thread_data *thread_data, *curr_thread_data;
TaskHandle_t handle = thread;
(void)value_ptr;
/* Get thread data of current thread */
curr_thread_data = thread_data_current();
curr_thread_data->wait_node.next = NULL;
/* Get thread data */
thread_data = thread_data_list_lookup(handle);
xSemaphoreTake(thread_data->wait_list_lock, portMAX_DELAY);
if (!thread_data->thread_wait_list)
thread_data->thread_wait_list = &curr_thread_data->wait_node;
else {
/* Add to end of waiting list */
os_thread_wait_node *p = thread_data->thread_wait_list;
while (p->next)
p = p->next;
p->next = &curr_thread_data->wait_node;
}
xSemaphoreGive(thread_data->wait_list_lock);
/* Wait the sem */
xSemaphoreTake(curr_thread_data->wait_node.sem, portMAX_DELAY);
return BHT_OK;
}
int os_mutex_init(korp_mutex *mutex)
{
SemaphoreHandle_t semaphore;
if (!(semaphore = xSemaphoreCreateMutex()))
return BHT_ERROR;
mutex->sem = semaphore;
mutex->is_recursive = false;
return BHT_OK;
}
int os_recursive_mutex_init(korp_mutex *mutex)
{
SemaphoreHandle_t semaphore;
if (!(semaphore = xSemaphoreCreateRecursiveMutex()))
return BHT_ERROR;
mutex->sem = semaphore;
mutex->is_recursive = true;
return BHT_OK;
}
int os_mutex_destroy(korp_mutex *mutex)
{
vSemaphoreDelete(mutex->sem);
return BHT_OK;
}
int os_mutex_lock(korp_mutex *mutex)
{
int ret = -1;
if (!mutex->is_recursive)
ret = xSemaphoreTake(mutex->sem, portMAX_DELAY);
else
ret = xSemaphoreTakeRecursive(mutex->sem, portMAX_DELAY);
return ret == pdPASS ? BHT_OK : BHT_ERROR;
}
int os_mutex_unlock(korp_mutex *mutex)
{
int ret = -1;
if (!mutex->is_recursive)
ret = xSemaphoreGive(mutex->sem);
else
ret = xSemaphoreGiveRecursive(mutex->sem);
return ret == pdPASS ? BHT_OK : BHT_ERROR;
}
int os_cond_init(korp_cond *cond)
{
if (!(cond->wait_list_lock = xSemaphoreCreateMutex()))
return BHT_ERROR;
cond->thread_wait_list = NULL;
return BHT_OK;
}
int os_cond_destroy(korp_cond *cond)
{
vSemaphoreDelete(cond->wait_list_lock);
return BHT_OK;
}
static int
os_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
bool timed, int mills)
{
os_thread_wait_node *node = &thread_data_current()->wait_node;
node->next = NULL;
xSemaphoreTake(cond->wait_list_lock, portMAX_DELAY);
if (!cond->thread_wait_list)
cond->thread_wait_list = node;
else {
/* Add to end of wait list */
os_thread_wait_node *p = cond->thread_wait_list;
while (p->next)
p = p->next;
p->next = node;
}
xSemaphoreGive(cond->wait_list_lock);
/* Unlock mutex, wait sem and lock mutex again */
os_mutex_unlock(mutex);
xSemaphoreTake(node->sem, timed ? mills / portTICK_RATE_MS : portMAX_DELAY);
os_mutex_lock(mutex);
/* Remove wait node from wait list */
xSemaphoreTake(cond->wait_list_lock, portMAX_DELAY);
if (cond->thread_wait_list == node)
cond->thread_wait_list = node->next;
else {
/* Remove from the wait list */
os_thread_wait_node *p = cond->thread_wait_list;
while (p->next != node)
p = p->next;
p->next = node->next;
}
xSemaphoreGive(cond->wait_list_lock);
return BHT_OK;
}
int os_cond_wait(korp_cond *cond, korp_mutex *mutex)
{
return os_cond_wait_internal(cond, mutex, false, 0);
}
int os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int useconds)
{
if (useconds == BHT_WAIT_FOREVER)
return os_cond_wait_internal(cond, mutex, false, 0);
else
return os_cond_wait_internal(cond, mutex, true, useconds / 1000);
}
int os_cond_signal(korp_cond *cond)
{
/* Signal the head wait node of wait list */
xSemaphoreTake(cond->wait_list_lock, portMAX_DELAY);
if (cond->thread_wait_list)
xSemaphoreGive(cond->thread_wait_list->sem);
xSemaphoreGive(cond->wait_list_lock);
return BHT_OK;
}
uint8 *os_thread_get_stack_boundary()
{
/* TODO: implement os_thread_get_stack_boundary */
return NULL;
}

14
core/shared/platform/freertos/freertos_time.c Normal file
View File

@ -0,0 +1,14 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "platform_api_vmcore.h"
uint64
os_time_get_boot_microsecond()
{
TickType_t ticks = xTaskGetTickCount();
return (uint64)1000 * 1000 / configTICK_RATE_HZ * ticks;
}

97
core/shared/platform/freertos/platform_internal.h Normal file
View File

@ -0,0 +1,97 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _PLATFORM_INTERNAL_H
#define _PLATFORM_INTERNAL_H
#include <stdint.h>
#include <stdarg.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <FreeRTOS.h>
#include <semphr.h>
#include <task.h>
#include <os_api.h>
#ifndef BH_PLATFORM_FREERTOS
#define BH_PLATFORM_FREERTOS
#endif
#define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
/* Default thread priority */
#define BH_THREAD_DEFAULT_PRIORITY 5
extern int errno;
typedef TaskHandle_t korp_thread;
typedef korp_thread korp_tid;
typedef struct {
bool is_recursive;
SemaphoreHandle_t sem;
} korp_mutex;
struct os_thread_wait_node;
typedef struct os_thread_wait_node *os_thread_wait_list;
typedef struct korp_cond {
SemaphoreHandle_t wait_list_lock;
os_thread_wait_list thread_wait_list;
} korp_cond;
int os_printf(const char *format, ...);
int os_vprintf(const char *format, va_list ap);
/* math functions which are not provided by os */
double sqrt(double x);
double floor(double x);
double ceil(double x);
double fmin(double x, double y);
double fmax(double x, double y);
double rint(double x);
double fabs(double x);
double trunc(double x);
float floorf(float x);
float ceilf(float x);
float fminf(float x, float y);
float fmaxf(float x, float y);
float rintf(float x);
float truncf(float x);
int signbit(double x);
int isnan(double x);
int atoi(const char *s);
int strncasecmp(const char *s1, const char *s2, size_t n);
long int strtol(const char *str, char **endptr, int base);
unsigned long int strtoul(const char *str, char **endptr, int base);
unsigned long long int strtoull(const char *nptr, char **endptr, int base);
double strtod(const char *nptr, char **endptr);
float strtof(const char *nptr, char **endptr);
char *strstr(const char *haystack, const char *needle);
size_t strspn(const char *s, const char *accept);
size_t strcspn(const char *s, const char *reject);
void *memchr(const void *s, int c, size_t n);
int isalnum(int c);
int isxdigit(int c);
int isdigit(int c);
int isprint(int c);
int isgraph(int c);
int isspace(int c);
int isalpha(int c);
int isupper(int c);
int toupper(int c);
int tolower(int c);
void *memmove(void *dest, const void *src, size_t n);
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
#endif

16
core/shared/platform/freertos/shared_platform.cmake Normal file
View File

@ -0,0 +1,16 @@
# Copyright (C) 2019 Intel Corporation. All rights reserved.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
add_definitions(-DBH_PLATFORM_FREERTOS)
include_directories(${PLATFORM_SHARED_DIR})
include_directories(${PLATFORM_SHARED_DIR}/../include)
include (${CMAKE_CURRENT_LIST_DIR}/../common/math/platform_api_math.cmake)
file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
set (PLATFORM_SHARED_SOURCE ${source_all} ${PLATFORM_COMMON_MATH_SOURCE})