watchdog.h

Go to the documentation of this file.

#ifndef WATCHDOG_H
#define WATCHDOG_H

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <algorithm>
#include <assert.h>
#include "kernel.h"

using namespace std;
namespace SMP{

class SMPKernel;

class SMPWatchdog{
        static void *watchdog_thread(void *arg);
    private:
        int timeout;
        pthread_t dog_thread;
        int n_bones;
        vector<bool> bones;
        SMPKernel *kernel;

        vector<bool> not_monitored; 
        

    public:
        SMPWatchdog(SMPKernel *k, int timeout);
        ~SMPWatchdog();

        int start();
        int stop();

        inline void pat(int id); 
        inline void set_timeout(int sec);
        inline int get_timeout();

        //============================================================================================
        // the following function should be made public in order for watchdog thread callback function
        // to be able to access. 

        inline void pat(); 
        inline void stir_up();
        inline bool is_happy();
        inline int *get_bad_ids(int *num);      

        inline int add_not_monitored(int fid);

    
        //2007/2/6 
        void update_watch_size();

};

inline void SMPWatchdog::set_timeout(int sec)
{
    timeout = sec;
}
inline int SMPWatchdog::get_timeout()
{
    return timeout;
}

inline void SMPWatchdog::stir_up()
{
    for(int i = 0; i < n_bones; i++)
        bones[i] = false;
}

inline void SMPWatchdog::pat()
{
    for(int i = 0; i < n_bones; i++)
        bones[i] = true;
}

inline void SMPWatchdog::pat(int id)
{
//    printf("id=%d n_bones=%d\n", id, n_bones);
    assert(id >= 0 && id < n_bones);
    bones[id] = true;
}

inline bool SMPWatchdog::is_happy()
{
    for(int i = 0; i < n_bones; i++){
        if(not_monitored[i]){  //skip not-monitored threads 
            //printf("[watchdog]:skip filter:%d\n", i);
            continue;
        }
        if(!bones[i])
            return false;
    }
    return true;
}

inline int *SMPWatchdog::get_bad_ids(int *num)
{
    //find the first bad id. 
    int i = 0;
    int no = 0;
    for(; i < n_bones; i++){
        if(!bones[i] && !not_monitored[i]) //if flag not set, and it is monitored
            no++;
    }
    *num = no;
    if(no == 0) 
        return NULL;

    int *bads = new int[no];
    for(i = no = 0; i < n_bones; i++){
        if(!bones[i] && !not_monitored[i])
            bads[no++] = i;
    }
    
    return bads;
}


inline int SMPWatchdog::add_not_monitored(int fid)
{
    assert(fid >= 0 && fid < n_bones);
    not_monitored[fid]=true;
    printf("[watchdog]:filter id=%d added to not_monitored list\n", fid);
    return 0;
    /*
    vector<int>::iterator it = find(not_monitored.begin(), not_monitored.end(), fid);
    if(it == not_monitored.end()){ //not in not_monitored vector
        printf("filter id=%d added to not_monitored list in watchdog\n", fid);
        not_monitored.push_back(fid);
        return 0;
    }
    return -1; //fid has already been in the not_monitored list!
    */
}
/*
inline pthread_t SMPWatchdog::get_watchdog_thread()
{
    return watched_thread;
}
*/
} //end of namespace

#endif

---