erpc_threading.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2016, Freescale Semiconductor, Inc.
 * Copyright 2016-2023 NXP
 * Copyright 2021 ACRIOS Systems s.r.o.
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifndef __embedded_rpc__thread__
#define __embedded_rpc__thread__

#include "erpc_config_internal.h"

#include <stdint.h>

// Exclude the rest of the file if threading is disabled.
#if !ERPC_THREADS_IS(NONE)

#if ERPC_THREADS_IS(PTHREADS)
#include <pthread.h>
#elif ERPC_THREADS_IS(FREERTOS)
#include "FreeRTOS.h"
#include "semphr.h"
#include "task.h"
#elif ERPC_THREADS_IS(ZEPHYR)
#include <zephyr/kernel.h>
#elif ERPC_THREADS_IS(MBED)
#if MBED_CONF_RTOS_PRESENT
#include "rtos.h"
#else
#warning mbed-rpc: Threading is enabled but Mbed RTOS is not present!
#endif
#elif ERPC_THREADS_IS(WIN32)
#include "windows.h"
#elif ERPC_THREADS_IS(THREADX)
#include "tx_api.h"

#endif // ERPC_THREADS

// Types

typedef void (*thread_entry_t)(void *arg);

// Declarations

#if defined(__cplusplus)

namespace erpc {
class Thread
{
public:
    typedef void *thread_id_t;
#if ERPC_THREADS_IS(FREERTOS)
    typedef StackType_t *thread_stack_pointer;
#else
    typedef void *thread_stack_pointer;
#endif

    Thread(const char *name = 0);

    Thread(thread_entry_t entry, uint32_t priority = 0, uint32_t stackSize = 0, const char *name = 0,
           thread_stack_pointer stackPtr = NULL);

    virtual ~Thread(void);

    void setName(const char *name) { m_name = name; }

    const char *getName(void) const { return m_name; }

    void init(thread_entry_t entry, uint32_t priority = 0, uint32_t stackSize = 0, thread_stack_pointer stackPtr = NULL);

    void start(void *arg = 0);

    static void sleep(uint32_t usecs);

    thread_id_t getThreadId(void) const
    {
#if ERPC_THREADS_IS(PTHREADS)
        return reinterpret_cast<thread_id_t>(m_thread);
#elif ERPC_THREADS_IS(FREERTOS)
        return reinterpret_cast<thread_id_t>(m_task);
#elif ERPC_THREADS_IS(ZEPHYR)
        return reinterpret_cast<thread_id_t>(m_thread_id);
#elif ERPC_THREADS_IS(MBED)
        return reinterpret_cast<thread_id_t>(m_thread->get_id());
#elif ERPC_THREADS_IS(WIN32)
        return reinterpret_cast<thread_id_t>(m_thread);
#elif ERPC_THREADS_IS(THREADX)
        return reinterpret_cast<thread_id_t>(m_thread.tx_thread_id);
#endif
    }

    static thread_id_t getCurrentThreadId(void)
    {
#if ERPC_THREADS_IS(PTHREADS)
        return reinterpret_cast<thread_id_t>(pthread_self());
#elif ERPC_THREADS_IS(FREERTOS)
        return reinterpret_cast<thread_id_t>(xTaskGetCurrentTaskHandle());
#elif ERPC_THREADS_IS(ZEPHYR)
        return reinterpret_cast<thread_id_t>(k_current_get());
#elif ERPC_THREADS_IS(MBED)
        return reinterpret_cast<thread_id_t>(rtos::ThisThread::get_id());
#elif ERPC_THREADS_IS(WIN32)
        return reinterpret_cast<thread_id_t>(GetCurrentThread());
#elif ERPC_THREADS_IS(THREADX)
        return reinterpret_cast<thread_id_t>(tx_thread_identify());
#endif
    }

#if ERPC_THREADS_IS(ZEPHYR)

    void setStackPointer(k_thread_stack_t *stack) { m_stack = stack; }
#endif

    static Thread *getCurrentThread(void);

    bool operator==(Thread &o);

protected:
    virtual void threadEntryPoint(void);

private:
    const char *m_name;              
    thread_entry_t m_entry;          
    void *m_arg;                     
    uint32_t m_stackSize;            
    uint32_t m_priority;             
    thread_stack_pointer m_stackPtr; 
#if ERPC_THREADS_IS(PTHREADS)
    static pthread_key_t s_threadObjectKey; 
    pthread_t m_thread;                     
#elif ERPC_THREADS_IS(FREERTOS)
    TaskHandle_t m_task;       
    Thread *m_next;            
    static Thread *s_first;    
#if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_STATIC
    StaticTask_t m_staticTask; 
#endif
#elif ERPC_THREADS_IS(ZEPHYR)
    struct k_thread m_thread; 
    k_tid_t m_thread_id;
    k_thread_stack_t *m_stack; 
#elif ERPC_THREADS_IS(MBED)
    rtos::Thread *m_thread; 
    Thread *m_next;         
    static Thread *s_first; 
#elif ERPC_THREADS_IS(WIN32)
    HANDLE m_thread;
    unsigned int m_thrdaddr;
    Thread *m_next;         
    static Thread *s_first; 
    static CRITICAL_SECTION m_critical_section;
    static BOOL m_critical_section_inited;
#elif ERPC_THREADS_IS(THREADX)
    TX_THREAD m_thread;     
    Thread *m_next;         
    static Thread *s_first; 
#endif

#if ERPC_THREADS_IS(PTHREADS)

    static void *threadEntryPointStub(void *arg);
#elif ERPC_THREADS_IS(FREERTOS)

    static void threadEntryPointStub(void *arg);
#elif ERPC_THREADS_IS(ZEPHYR)

    static void threadEntryPointStub(void *arg1, void *arg2, void *arg3);

#elif ERPC_THREADS_IS(MBED)

    static void threadEntryPointStub(void *arg);

#elif ERPC_THREADS_IS(WIN32)

    static unsigned WINAPI threadEntryPointStub(void *arg);

#elif ERPC_THREADS_IS(THREADX)

    static void threadEntryPointStub(ULONG arg);
#endif

private:
    Thread(const Thread &o);

    Thread &operator=(const Thread &o);
};

class Mutex
{
public:
    class Guard
    {
    public:
        Guard(Mutex &mutex) : m_mutex(mutex) { (void)m_mutex.lock(); }
        ~Guard(void) { (void)m_mutex.unlock(); }

    private:
        Mutex &m_mutex; 
    };

    Mutex(void);

    ~Mutex(void);

    bool tryLock(void);

    bool lock(void);

    bool unlock(void);

#if ERPC_THREADS_IS(PTHREADS)

    pthread_mutex_t *getPtr(void) { return &m_mutex; }
#endif

private:
#if ERPC_THREADS_IS(PTHREADS)
    pthread_mutex_t m_mutex; 
#elif ERPC_THREADS_IS(FREERTOS)
    SemaphoreHandle_t m_mutex;       
    StaticSemaphore_t m_staticQueue; 
#elif ERPC_THREADS_IS(ZEPHYR)
    struct k_mutex m_mutex; 
#elif ERPC_THREADS_IS(MBED)
    rtos::Mutex *m_mutex;   
#elif ERPC_THREADS_IS(WIN32)
    HANDLE m_mutex;
#elif ERPC_THREADS_IS(THREADX)
    TX_MUTEX m_mutex;
#endif

private:
    Mutex(const Mutex &o);
    Mutex &operator=(const Mutex &o);
};

class Semaphore
{
public:
    static const uint32_t kWaitForever = 0xffffffffu;

    Semaphore(int count = 0);

    ~Semaphore(void);

    void put(void);

#if ERPC_THREADS_IS(FREERTOS)

    void putFromISR(void);
#endif // ERPC_HAS_FREERTOS

    bool get(uint32_t timeoutUsecs = kWaitForever);

    int getCount(void) const;

private:
#if ERPC_THREADS_IS(PTHREADS)
    int m_count;           
    pthread_cond_t m_cond; 
    Mutex m_mutex;         
#elif ERPC_THREADS_IS(FREERTOS)
    SemaphoreHandle_t m_sem;         
    StaticSemaphore_t m_staticQueue; 
#elif ERPC_THREADS_IS(ZEPHYR)
    struct k_sem m_sem;     
#elif ERPC_THREADS_IS(MBED)
    rtos::Semaphore *m_sem; 
    int m_count;            
#elif ERPC_THREADS_IS(WIN32)
    Mutex m_mutex; 
    int m_count;
    HANDLE m_sem;
#elif ERPC_THREADS_IS(THREADX)
    TX_SEMAPHORE m_sem; 
#endif

private:
    Semaphore(const Semaphore &o);
    Semaphore &operator=(const Semaphore &o);
};

} // namespace erpc

#endif // defined(__cplusplus)

#endif // ERPC_THREADS

#endif // defined(__embedded_rpc__thread__)
// EOF