include/rt.h

Go to the documentation of this file.

/*
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah, Weill Cornell Medical College

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef RT_H
#define RT_H

#include <fifo.h>
#include <mutex.h>
#include <pthread.h>
#include <semaphore.h>
#include <settings.h>


namespace RT {

    namespace OS {

        typedef void * Task;

        int initiate(void);
        void shutdown(void);

        int createTask(Task *,void *(*)(void *),void *,int =0);
        void deleteTask(Task);

        int setPeriod(Task,long long);
        void sleepTimestep(Task);

        bool isRealtime(void);

        long long getTime(void);

    } // namespace OS

    class Event {

        friend class System;

    public:

        Event(void);
        virtual ~Event(void);

        virtual int callback(void)=0;

    private:

        void execute(void);
        void wait(void);

        int retval;
        sem_t signal;

    }; // class Event

    template<typename T>
    class List {

    public:

        class Node;

        class iterator {

        public:

            iterator(void)
                : current(0) {};
            iterator(T *x)
                : current(static_cast<Node *>(x)) {};
            iterator(const iterator &x)
                : current(x.current) {};

            bool operator==(const iterator &x) const {
                return current == x.current;
            };
            bool operator!=(const iterator &x) const {
                return current != x.current;
            };

            T &operator*(void) const {
                return *static_cast<T *>(current);
            };
            T *operator->(void) const {
                return static_cast<T *>(current);
            };

            iterator &operator++(void) {
                current = current->next;
                return *this;
            };
            iterator operator++(int) {
                typename RT::List<T>::iterator tmp = *this;
                current = current->next;
                return tmp;
            };
            iterator &operator--(void) {
                current = current->prev;
                return *this;
            };
            iterator operator--(int) {
                typename RT::List<T>::iterator tmp = *this;
                current = current->prev;
                return tmp;
            };


        private:

            Node *current;

        }; // class iterator

        class const_iterator {

        public:

            const_iterator(void)
                : current(0) {};
            const_iterator(const T *x)
                : current(static_cast<const Node *>(x)) {};
            const_iterator(const const_iterator &x)
                : current(x.current) {};

            bool operator==(const const_iterator &x) const {
                return current == x.current;
            };
            bool operator!=(const const_iterator &x) const {
                return current != x.current;
            };

            const T &operator*(void) const {
                return *static_cast<const T *>(current);
            };
            const T *operator->(void) const {
                return static_cast<const T *>(current);
            };

            const_iterator &operator++(void) {
                current = current->next;
                return *this;
            };
            const_iterator operator++(int) {
                typename RT::List<T>::const_iterator tmp = *this;
                current = current->next;
                return tmp;
            };
            const_iterator &operator--(void) {
                current = current->prev;
                return *this;
            };
            const_iterator operator--(int) {
                typename RT::List<T>::const_iterator tmp = *this;
                current = current->prev;
                return tmp;
            };


        private:

            const Node *current;

        }; // class const_iterator

        class Node {

            friend class List<T>;
            friend class List<T>::iterator;
            friend class List<T>::const_iterator;

        public:

            Node(void)
                : next(0), prev(0) {};
            virtual ~Node(void) {};

            bool operator==(const Node &x) const {
                return next == x.next && prev == x.prev;
            };

        private:

            Node *next, *prev;

        }; // class Node

        List(void)
            : count(0), head(&tail), tail() {};
        virtual ~List(void) {
#ifdef DEBUG
            if(tail.next)
                ERROR_MSG("RT::List::~List : end of list overwritten\n");
#endif
        };

        size_t size(void) const {
            return count;
        };
        bool empty(void) const {
            return count==0;
        };

        iterator begin(void) {
            return iterator(static_cast<T *>(head));
        };
        iterator end(void) {
            return iterator(static_cast<T *>(&tail));
        };

        const_iterator begin(void) const {
            return const_iterator(static_cast<const T *>(head));
        };
        const_iterator end(void) const {
            return const_iterator(static_cast<const T *>(&tail));
        };

        void insert(iterator,T &);
        void insertRT(iterator position,T &node) {
            Node *object = static_cast<Node *>(&node);

            object->next = &(*position);
            object->prev = object->next->prev;
            if(object->next == head)
                head = object;
            else
                position->prev->next = object;
            position->prev = object;
            count++;
        };

        void remove(T &);
        void removeRT(T &node) {
            Node *object = static_cast<Node *>(&node);

            if(object == &tail)
                return;
            if(object == head)
                head = object->next;
            else if(object->prev)
                object->prev->next = object->next;
            object->next->prev = object->prev;
            count--;
        };

    private:

        class InsertListNodeEvent : public RT::Event {

        public:

            InsertListNodeEvent(List<T> *l,iterator i,T *n)
                : list(l), iter(i), node(n) {};
            int callback(void) {
                list->insertRT(iter,*node);
                return 0;
            };

        private:

            List<T> *list;
            typename List<T>::iterator iter;
            T *node;

        }; // class InsertListNodeEvent;

        class RemoveListNodeEvent : public RT::Event {

        public:

            RemoveListNodeEvent(List<T> *l,T *n)
                : list(l), node(n) {};
            int callback(void) {
                list->removeRT(*node);
                return 0;
            };

        private:

            List<T> *list;
            T *node;

        }; // class RemoveListNodeEvnet;

        size_t count;
        Node *head, tail;

    }; // class List

    class Device;
    class Thread;

    class System {

        friend class Device;
        friend class Thread;

    public:

        static System *getInstance(void);

        long long getPeriod(void) const { return period; };
        int setPeriod(long long period);

        void foreachDevice(void (*callback)(Device *,void *),void *param);
        void foreachThread(void (*callback)(Thread *,void *),void *param);

        int postEvent(Event *event,bool blocking =true);

    private:

        /******************************************************************
         * The constructors, destructor, and assignment operator are made *
         *   private to control instantiation of the class.               *
         ******************************************************************/

        System(void);
        ~System(void);
        System(const System &) : eventFifo(0) {};
        System &operator=(const System &) { return *getInstance(); };

        class SetPeriodEvent : public RT::Event {

        public:

            SetPeriodEvent(long long);
            ~SetPeriodEvent(void);

            int callback(void);

        private:

            long long period;

        }; // class SetPeriodEvent


        static System *instance;

        Mutex deviceMutex;
        void insertDevice(Device *);
        void removeDevice(Device *);

        Mutex threadMutex;
        void insertThread(Thread *);
        void removeThread(Thread *);

        static void *bounce(void *);
        void execute(void);

        bool finished;
        pthread_t thread;
        RT::OS::Task task;
        long long period;

        List<RT::Device> deviceList;
        List<RT::Thread> threadList;

        Fifo eventFifo;

    }; // class System

    class Device : public List<Device>::Node {

    public:

        Device(void);
        virtual ~Device(void);

        /**********************************************************
         * read & write must not be pure virtual because they can *
         *    be called during construction and destruction.      *
         **********************************************************/

        virtual void read(void) {};
        virtual void write(void) {};

        inline bool getActive(void) const { return active; };
        void setActive(bool);

    private:

        bool active;

    }; // class Device

    class Thread : public List<Thread>::Node {

    public:

        typedef unsigned long Priority;

        static const Priority MinimumPriority = 0;
        static const Priority MaximumPriority = 100;
        static const Priority DefaultPriority = MaximumPriority/2;

        Thread(Priority p =DefaultPriority);
        virtual ~Thread(void);

        Priority getPriority(void) const { return priority; };

        /**********************************************************
         * execute must not be pure virtual because it can be     *
         *   called during construction and destruction.          *
         **********************************************************/

        virtual void execute(void) {};

        inline bool getActive(void) const { return active; };
        void setActive(bool);

    private:

        bool active;
        Priority priority;

    }; // class Thread

    template<typename T>
    void List<T>::insert(iterator position,T &node) {
        InsertListNodeEvent event(this,position,&node);
        RT::System::getInstance()->postEvent(&event);
    }

    template<typename T>
    void List<T>::remove(T &node) {
        RemoveListNodeEvent event(this,&node);
        RT::System::getInstance()->postEvent(&event);
    }

} // namespace RT

#endif // RT_H