low_level_platform.h

Go to the documentation of this file.

 
#ifndef PLATFORM_H
#define PLATFORM_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "tag.h"
#include <assert.h>
#include "platform/lf_atomic.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_PATMOS)
#include "platform/lf_patmos_support.h"
#elif defined(PLATFORM_RP2040)
#include "platform/lf_rp2040_support.h"
#elif defined(PLATFORM_FLEXPRET)
#include "platform/lf_flexpret_support.h"
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
// Windows platforms
#include "platform/lf_windows_support.h"
#elif __APPLE__
// Apple platforms
#include "platform/lf_macos_support.h"
#elif __linux__
// Linux
#include "platform/lf_linux_support.h"
#elif __unix__ // all unices not caught above
// Unix
#include "platform/lf_POSIX_threads_support.h"
#elif defined(_POSIX_VERSION)
// POSIX
#include "platform/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
 
// Worker priorities range from 0 to 99 where 99 is the highest priority.
#define LF_SCHED_MAX_PRIORITY 99
#define LF_SCHED_MIN_PRIORITY 0
 
// 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)
 
// For unthreaded platforms, the mutex functions below are implemented in reactor.c
// and do nothing, returning 0.
typedef void* lf_mutex_t;
int lf_mutex_unlock(lf_mutex_t* mutex);
int lf_mutex_init(lf_mutex_t* mutex);
int lf_mutex_lock(lf_mutex_t* mutex);

int lf_disable_interrupts_nested(void);

int lf_enable_interrupts_nested(void);

int _lf_single_threaded_notify_of_event(void);
 
#else // defined(LF_SINGLE_THREADED)
 
// For platforms with threading support, the following functions
// abstract the API so that the LF runtime remains portable.

int lf_available_cores(void);

lf_thread_t lf_thread_self(void);

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);

typedef enum {
  LF_SCHED_FAIR,      // Non real-time scheduling policy. Corresponds to SCHED_OTHER
  LF_SCHED_TIMESLICE, // Real-time, time-slicing priority-based policty. Corresponds to SCHED_RR.
  LF_SCHED_PRIORITY,  // Real-time, priority-only based scheduling. Corresponds to SCHED_FIFO.
} lf_scheduling_policy_type_t;

typedef struct {
  lf_scheduling_policy_type_t policy; // The scheduling policy
  int priority;                       // The priority, if applicable
  interval_t time_slice;              // The time-slice allocated, if applicable.
} lf_scheduling_policy_t;

int lf_thread_set_cpu(lf_thread_t thread, size_t cpu_number);

int lf_thread_set_priority(lf_thread_t thread, int priority);

int lf_thread_set_scheduling_policy(lf_thread_t thread, lf_scheduling_policy_t* policy);

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 wakeup_time);
 
/*
 * Cross-platform version of the C11 thread_local keyword.
 */
#ifndef thread_local
#if __STDC_VERSION__ >= 201112 && !defined __STDC_NO_THREADS__
#define thread_local _Thread_local
#elif defined _WIN32 && (defined _MSC_VER || defined __ICL || defined __DMC__ || defined __BORLANDC__)
#define thread_local __declspec(thread)
/* note that ICC (linux) and Clang are covered by __GNUC__ */
#elif defined __GNUC__ || defined __SUNPRO_C || defined __xlC__
#define thread_local __thread
#else
#error "Cannot define thread_local"
#endif
#endif // thread_local

int lf_thread_id(void);

void initialize_lf_thread_id(void);
#endif // !defined(LF_SINGLE_THREADED)

void _lf_initialize_clock(void);

int _lf_clock_gettime(instant_t* t);

int lf_sleep(interval_t sleep_duration);

int _lf_interruptable_sleep_until_locked(environment_t* env, instant_t wakeup_time);
 
/*
 * Macros for marking function as deprecated
 */
#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