kernel.h

Go to the documentation of this file.

#ifndef KERNEL_H
#define KERNEL_H

#include <map>
#include <list>
#include <vector>
#include <string>
#include <errno.h>

#ifdef USE_PTHREAD
#include <pthread.h>
#include <sched.h>
#else
#include <pth.h>
#endif

#ifdef SLIM_MINIGUI_ENGINE
#include <minigui/common.h>
#include <minigui/minigui.h>
#include <minigui/gdi.h>
#include <minigui/window.h>
#include <minigui/control.h>
#endif

#include "watchdog.h"
#include "filter.h"
#include "application.h"
#include "signalmanager.h"
#include "configuration.h"

#define SMP_RT_PRIORITY 10


namespace SMP{

//define the maker and disposer function type
typedef SMPFilter* (maker_t)(void);        
typedef void (disposer_t)(SMPFilter*);     


class SMPWatchdog;

class SMPKernel
{
    friend class SMPWatchdog;
private:
  
    static SMPKernel *kernel;
    SMPKernel(void);

    //bool real_time;

    SMPConfiguration config;

    SMPWatchdog *watchdog;


    char repository_path[100];

public:
    SMPSignalManager *signal_manager;
private:

    /*--------------------------------------------------------------------------------------------------
     * Most important members in SMP kernel
     * 1. Filter Factory
     * 2. Buffers
     * 3. Filters
     */
    
    map<string, maker_t*> filter_factory;    
    vector<disposer_t*> filter_disposer;
    
    vector<SMPBuffer*> smp_buffer;
    vector<SMPSignalBuffer*> smp_sigbuffer;
    vector<SMPFilter*> smp_filter;

    vector<int> watchdog_unmonitored;

    /*---------------------------------------------------------------------------------------------------
     * Dynamically loaded library related 
     */
    
    vector<void *> lib_handle;


    /*---------------------------------------------------------------------------------------------------
     * pthread library related
     */
#ifdef USE_PTHREAD

    vector<pthread_t> thread_handle;
    //vector<pthread_t> sig_thread_handle;
    map<int, pthread_t> sig_thread_handle;
#else
    vector<pth_t> thread_handle;
#endif


    
    /*----------------------------------------------------------------------------------------------------
     * Functions to register/load dynamically loaded library
     * 4 functions
     */
    
    int register_filter(const char *name, void *handle);

    int unregister_filters(void);
    
    int load_filter(const char *soname);
    int unload_filters(void);
    
    /*
     * \brief   reset buffer
     *          clean the resources of every buffers
     */ 
    void reset_buffers(void);
    

    static void *run(void *arg);
    
    
#ifdef  USE_PTHREAD

    static void *filter_sig_handler(void *arg);
    static void *filter_sig_handler_light(void *arg);
#endif

#ifndef USE_PTHREAD

    double get_pth_time(pth_time_t *t);
#endif

    static int acquire_realtime_scheduling (pthread_t thread, int priority);

    static int drop_realtime_scheduling (pthread_t thread);
    
    
public:

    ~SMPKernel(void);

    char version[6];
    static SMPKernel *get_kernel(void);

    bool stopped;
    bool paused;
    
    void pat_dog(int id);

    void set_unmonitored(int fid);

    inline SMPConfiguration& get_config();
    inline void set_config(SMPConfiguration &c);
    
    inline void set_config(string name, int value);

    /*--------------------------------------------------------------------------------------
     * Construction of filters
     */
    
#ifdef  USE_PTHREAD
    int construct_component(const char *repos, const char *filter_name, int major_version, int minor_version, 
            int *in_buffer, int num_in, int *out_buffer, int num_out, 
            int *sig_in_buffer, int sig_num_in, int *sig_out_buffer, int sig_num_out,
            map<string, property_item> &prop);
#elif
    int construct_component(const char *repos, const char *filter_name, int major_version, int minor_version, 
            int *in_buffer, int num_in, int *out_buffer, int num_out, map<string, property_item> &prop);
#endif

    int destruct_filters(void);
     
    /*--------------------------------------------------------------------------------------
     * Construction of buffers
     */

    int construct_binding(size_t size, int input, int input_port, vector<int> &output, vector<int> &output_port, int type);
    int destruct_buffers(void);
    
    /*--------------------------------------------------------------------------------------
     * controller of the SMP kernel
     */
    
    int init(void);
    void start(void);
    void pause(void);
    void resume(void);
    void stop(void);
    void halt(void);


    /*-------------------------------------------------------------------------------------------------
     *  Input/Output Buffer Assignment Functions
     *  2 functions
     */
    //void add_input_buf(int buf_id, int filter_id, int port_id);
    //void remove_input_buf(int port_id);

    //void add_output_buf(int buf_id, int filter_id, int port_id);
    //void remove_output_buf(int bufdes, int port_id);
    
    
    /*-------------------------------------------------------------------------------------------------
     *  Get/Set Filter Property 
     *  2 functions
     */
    //int set_property(int filter_id, const char *item_name, const char *prop_name, const char *value);
    //int get_property(int filter_id, const char *item_name, const char *prop_name, char *value);
    


    //void set_realtime(bool is_realtime);

    /*------------------------------------------------------------------------------------------------------
     * Kernel API
     */

    void set_buf_status(int buf_id, int status);
    int get_buf_status(int buf_id);
    
    void flush_buffer(int buf_id);

    //blocking read/write in bytes

    ssize_t buf_read(int buf_id, void *buff, size_t nbytes, int fid=0);
    ssize_t buf_write(int buf_id, const void *buff, size_t nbytes);
    
    //nonblocking read/write in bytes

    ssize_t buf_read_nonblock(int buf_id, void *buff, size_t nbytes, int fid=0);
    ssize_t buf_write_nonblock(int buf_id, const void *buff, size_t nbytes);


    ssize_t buf_read_space(int buf_id, int fid);
    ssize_t buf_write_space(int buf_id);

#ifdef  USE_PTHREAD

    int signal_emit(int buf_id, SMPSignal *sig);

    map<int, int> signal_timeout;
    void set_signal_timeout(int fid, int usec);
    int get_signal_timeout(int fid);


    void set_repos_path(const char *path);
    char *get_repos_path(void);

#endif

    void show_buffers(void);

    void show_buffer(int bid);

    void show_threads(void);
    
    void show_thread(int fid);

    /*------------------------------------------------------------------------------------------------------
     * settings
     */

    bool buf_rw_info;

    void set_priority(int fid, int prio);

    void update_property(int fid, map<string, property_item> &prop);


#ifdef SLIM_MINIGUI_ENGINE
private:        
    static int SLIMWinProc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam);

    static void *start_MG_main_win(void *arg);

    static pthread_t MG_tid;
public:
    static void start_MG();
    static void join_MG();


#endif

//========== the following functions not yet verified! They just don't work! ================

    int argc;
    char **argv;
    void set_env(int pargc, char **pargv){ argc = pargc; argv = pargv;}
    void get_env(int *pargc, char ***pargv){ *pargc = argc; *pargv = argv;}

//========== just for testing ================

public:
    void run_additional();   
    void begin();
    void join();
private:
    pthread_mutex_t mutex_stop;
    pthread_cond_t  cond_stop;
    bool stop_met;
    static void *_begin(void *arg);

};

SMPConfiguration& SMPKernel::get_config()
{
    return config;
}
void SMPKernel::set_config(SMPConfiguration& c)
{
    config = c;
}
void SMPKernel::set_config(string name, int value)
{
    config.set_config(name, value);
}


} //end namespace

#endif

---