platform.h

Go to the documentation of this file.

/* Platform API support for the C target of Lingua Franca. */
 
 
#ifndef PLATFORM_H
#define PLATFORM_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "tag.h"
#include <assert.h>
 
// Forward declarations
typedef struct environment_t environment_t;
 
int lf_notify_of_event(environment_t* env);
 
int lf_critical_section_enter(environment_t* env);
 
int lf_critical_section_exit(environment_t* env);
 
#if defined(PLATFORM_ARDUINO)
    #include "platform/lf_arduino_support.h"
#elif defined(PLATFORM_ZEPHYR)
    #include "platform/lf_zephyr_support.h"
#elif defined(PLATFORM_NRF52)
    #include "platform/lf_nrf52_support.h"
#elif defined(PLATFORM_RP2040)
    #include "platform/lf_rp2040_support.h"
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
   // Windows platforms
   #include "lf_windows_support.h"
#elif __APPLE__
    // Apple platforms
    #include "lf_macos_support.h"
#elif __linux__
    // Linux
    #include "lf_linux_support.h"
#elif __unix__ // all unices not caught above
    // Unix
    #include "lf_POSIX_threads_support.h"
#elif defined(_POSIX_VERSION)
    // POSIX
    #include "lf_POSIX_threads_support.h"
#elif defined(__riscv) || defined(__riscv__)
    // RISC-V (see https://github.com/riscv/riscv-toolchain-conventions)
    #error "RISC-V not supported"
#else
#error "Platform not supported"
#endif
 
#define LF_TIMEOUT 1
 
 
// To support the single-threaded runtime, we need the following functions. They
//  are not required by the threaded runtime and is thus hidden behind a #ifdef.
#if defined (LF_SINGLE_THREADED)
    typedef void lf_mutex_t;
    int lf_disable_interrupts_nested();
    int lf_enable_interrupts_nested();
 
    int _lf_single_threaded_notify_of_event();
#else 
// For platforms with threading support, the following functions
// abstract the API so that the LF runtime remains portable.
 
 
int lf_available_cores();
 
int lf_thread_create(lf_thread_t* thread, void *(*lf_thread) (void *), void* arguments);
 
int lf_thread_join(lf_thread_t thread, void** thread_return);
 
int lf_mutex_init(lf_mutex_t* mutex);
 
int lf_mutex_lock(lf_mutex_t* mutex);
 
int lf_mutex_unlock(lf_mutex_t* mutex);
 
int lf_cond_init(lf_cond_t* cond, lf_mutex_t* mutex);
 
int lf_cond_broadcast(lf_cond_t* cond);
 
int lf_cond_signal(lf_cond_t* cond);
 
int lf_cond_wait(lf_cond_t* cond);
 
int lf_cond_timedwait(lf_cond_t* cond, instant_t absolute_time_ns);
 
/*
 * Atomically increment the variable that ptr points to by the given value, and return the original value of the variable.
 * @param ptr A pointer to a variable. The value of this variable will be replaced with the result of the operation.
 * @param value The value to be added to the variable pointed to by the ptr parameter.
 * @return The original value of the variable that ptr points to (i.e., from before the application of this operation).
 */
#if defined(PLATFORM_ZEPHYR)
#define lf_atomic_fetch_add(ptr, value) _zephyr_atomic_fetch_add((int*) ptr, value)
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
// Assume that an integer is 32 bits.
#define lf_atomic_fetch_add(ptr, value) InterlockedExchangeAdd(ptr, value)
#elif defined(__GNUC__) || defined(__clang__)
#define lf_atomic_fetch_add(ptr, value) __sync_fetch_and_add(ptr, value)
#else
#error "Compiler not supported"
#endif
 
/*
 * Atomically increment the variable that ptr points to by the given value, and return the new value of the variable.
 * @param ptr A pointer to a variable. The value of this variable will be replaced with the result of the operation.
 * @param value The value to be added to the variable pointed to by the ptr parameter.
 * @return The new value of the variable that ptr points to (i.e., from before the application of this operation).
 */
#if defined(PLATFORM_ZEPHYR)
#define lf_atomic_add_fetch(ptr, value) _zephyr_atomic_add_fetch((int*) ptr, value)
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
// Assume that an integer is 32 bits.
#define lf_atomic_add_fetch(ptr, value) InterlockedAdd(ptr, value)
#elif defined(__GNUC__) || defined(__clang__)
#define lf_atomic_add_fetch(ptr, value) __sync_add_and_fetch(ptr, value)
#else
#error "Compiler not supported"
#endif
 
/*
 * Atomically compare the variable that ptr points to against oldval. If the
 * current value is oldval, then write newval into *ptr.
 * @param ptr A pointer to a variable.
 * @param oldval The value to compare against.
 * @param newval The value to assign to *ptr if comparison is successful.
 * @return True if comparison was successful. False otherwise.
 */
#if defined(PLATFORM_ZEPHYR)
#define lf_bool_compare_and_swap(ptr, value, newval) _zephyr_bool_compare_and_swap((bool*) ptr, value, newval)
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
// Assume that a boolean is represented with a 32-bit integer.
#define lf_bool_compare_and_swap(ptr, oldval, newval) (InterlockedCompareExchange(ptr, newval, oldval) == oldval)
#elif defined(__GNUC__) || defined(__clang__)
#define lf_bool_compare_and_swap(ptr, oldval, newval) __sync_bool_compare_and_swap(ptr, oldval, newval)
#else
#error "Compiler not supported"
#endif
 
/*
 * Atomically compare the 32-bit value that ptr points to against oldval. If the
 * current value is oldval, then write newval into *ptr.
 * @param ptr A pointer to a variable.
 * @param oldval The value to compare against.
 * @param newval The value to assign to *ptr if comparison is successful.
 * @return The initial value of *ptr.
 */
#if defined(PLATFORM_ZEPHYR)
#define lf_val_compare_and_swap(ptr, value, newval) _zephyr_val_compare_and_swap((int*) ptr, value, newval)
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
#define lf_val_compare_and_swap(ptr, oldval, newval) InterlockedCompareExchange(ptr, newval, oldval)
#elif defined(__GNUC__) || defined(__clang__)
#define lf_val_compare_and_swap(ptr, oldval, newval) __sync_val_compare_and_swap(ptr, oldval, newval)
#else
#error "Compiler not supported"
#endif
 
#endif
 
void _lf_initialize_clock(void);
 
int _lf_clock_now(instant_t* t);
 
int lf_sleep(interval_t sleep_duration);
 
int _lf_interruptable_sleep_until_locked(environment_t* env, instant_t wakeup_time);
 
#ifdef __GNUC__
    #define DEPRECATED(X) X __attribute__((deprecated))
#elif defined(_MSC_VER)
    #define DEPRECATED(X) __declspec(deprecated) X
#else
    #define DEPRECATED(X) X
#endif
 
DEPRECATED(int lf_nanosleep(interval_t sleep_duration));
 
#ifdef __cplusplus
}
#endif
 
#endif // PLATFORM_H