monitor.h

Go to the documentation of this file.

/*
** Copyright (C) 2005 Russell Leighton
**
** 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 2 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, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/


#ifndef __AWMONITOR__
#define __AWMONITOR__

#include "sysnet.h"

#include "util.h"
#include "address.h"
#include "hash.h"
#include "mask.h"
#include "log.h"

#include "monsignals.h"
#include "monthread.h"
#include "event.h"
#include "alarm.h"
#include "handler.h"
#include "tasklet.h"

/* stack sizes for threads */
#define AW_ALARM_THREAD_STACKSIZE (8*1024)
#define AW_HANDLER_THREAD_STACKSIZE (128*1024)
#define AW_TASKLET_THREAD_STACKSIZE (512*1024)

/* default event factory cache size */
#define AW_DEFAULT_EVENT_CACHE_SIZE 256

/* default alarm factory cache size */
#define AW_DEFAULT_ALARM_CACHE_SIZE 256

/* default fdcallback factory cache size */
#define AW_DEFAULT_FDCALLBACK_CACHE_SIZE 256

/* default irecallback factory cache size */
#define AW_DEFAULT_IRECALLBACK_CACHE_SIZE 256

/* fixed depth of fd q for signals */
#define AW_FD_QSIZE 1024

/* -------- Alarm --------- */

typedef struct {

  /* duty cycle */
  aw_timestamp_t
   cycle_time;

  /* number of alarms */
  u_int32_t
   nalarms;

  /* list of alarms */
  aw_alarm_t
   *alarms;

  /* thread to run alarms */
  aw_monthread_t
   *thread;

  /* holds command events for the alarm_q */
  aw_event_q_t
   alarm_cmd_event_q;
  aw_plock_t
   alarm_cmd_event_q_lock;

  /* event factory */
  aw_cache_allocator_t
   event_factory;

  /* alarm factory */
  aw_cache_allocator_t
   alarm_factory;
  aw_plock_t
   alarm_factory_lock;

} aw_monitor_alarm_q_t;


/* -------- Handler --------- */
/* used to abstract the lookup of handler event q's */
typedef aw_hash32_t aw_handler_qlookup_t;

/* used to abstract the masked lookup of handler event q's */
typedef aw_mask_t aw_handler_maskqlookup_t;

/* points to handler's event q's */
typedef struct aw_handler_q_s {

  /* used to link together the runnable q's */
  struct aw_handler_q_s 
   *next_runnable;

  /* non-zero if in runnable state */
  u_int32_t
   runnable;

  /* master list */
  struct aw_handler_q_s 
   *prev,*next;
  
  /* the handler for events in this q */
  aw_handler_t
   *handler;

  /* active event q */
  aw_event_q_t
   q;

  /* deferred event q, events arriving while handler running in tasklet */
  aw_event_q_t
   deferred_q;

 /* wait event q, events arriving if handler is waiting on xaction signal */
  aw_event_q_t
   wait_q;

} aw_handler_q_t;

typedef struct {

  /* number of handlers */
  u_int32_t
   nhandlers;

  /* lookup table for handlers */
  struct {

    /* need to lock the hash and counter */
    aw_plock_t
     lock;

    /* sequencer */
    u_int32_t
     counter;

    /* table */
    aw_hash32_t
     *id2handler;

  } lut ;

  /* event handler qs for above handlers */
  aw_handler_q_t
   *handler_qs;

  /* lookup table for handler's q */
  aw_handler_qlookup_t
   *handler_qlookup_byevent;

  /* mask lookup table for handler's q*/
  aw_handler_maskqlookup_t
   *handler_maskqlookup_byevent;

  /* thread to run event handlers */
  aw_monthread_t
   *thread;

  /* non-zero if thread has been initialized */
  u_int32_t
   running;

  /* holds command events for the handler_q */
  aw_event_q_t
   handler_cmd_event_q;
  aw_plock_t
   handler_cmd_event_q_lock;

  /* q to hold events generated by
     handlers that will be dispatched
     to other handlers */
  aw_event_q_t
   handlers_event_q;

  /* event factory */
  aw_cache_allocator_t
   event_factory;

} aw_monitor_handler_q_t;

/* -------- Monitor --------- */

typedef struct {

  /* lock for manipulating q's */
  aw_plock_t
   lock;

  /* mapping of interrupt event id -> icallback */
  aw_hash32_t
   *ire2callback;

  /* holds events sent externally into monitor */
  aw_event_q_t
   input_event_q;

  /* holds events relayed from alarm_q to handler_q */
  aw_event_q_t
   alarm_generated_event_q;

  /* holds events relayed handler_q to alarm_q for reuse */
  aw_event_q_t
   alarm_processed_event_q;

  /* holds interrupt events relayed from alarm_q to handler_q */
  aw_event_q_t
   alarm_generated_interrupt_q;

  /* holds interrupt events relayed handler_q to alarm_q for reuse */
  aw_event_q_t
   alarm_processed_interrupt_q;

  /* holds events relayed from rx_q to handler_q */
  aw_event_q_t
   rx_generated_event_q;

  /* holds events relayed handler_q to rx_q for reuse */
  aw_event_q_t
   rx_processed_event_q;

  /* holds command events for the rx_q */
  aw_event_q_t
   rx_cmd_event_q;

  /* object cache */
  aw_cache_allocator_t
   irecallback_factory;

} aw_monitor_relay_t;

/* describes fd q */
typedef struct {

  /* how many in the q */
  u_int16_t
   nentries;

  /* how many failed inserts into q */
  u_int16_t
   nmisses;

} aw_monitor_fd_q_info_t;


/* holds fds delivered via signals */
typedef struct {

  aw_monitor_fd_q_info_t
   info;

  u_int16_t
   fds[AW_FD_QSIZE];

} aw_monitor_fd_q_t;

typedef struct {

  /* NOTE: all access MUST be from within handler thread! */
  
  /* mapping of fd -> fdcallback */
  aw_hash32_t
   *fd2callback;

  /* holds fds generated from signal handler ...
     uses double buffer technique to minimize race condition */
  volatile aw_monitor_fd_q_t
   *current_fd_q,
   *next_fd_q;
  aw_monitor_fd_q_t
   signal_fd_q1,
   signal_fd_q2;

  /* object cache */
  aw_cache_allocator_t
   fdcallback_factory;

} aw_monitor_fd_relay_t;

typedef struct aw_monitor_handler_fdcallback_s {

  /* the fd */
  int32_t
   fd;

  aw_handler_t
   *handler;

  /* the method to call when there is data ready to read on fd */
  aw_handler_code_t 
   (*callback)(aw_handler_args_t *args, int32_t fd );

} aw_monitor_handler_fdcallback_t;

typedef struct aw_monitor_handler_irecallback_s {

  aw_alarm_sched_t 
   sched;

  aw_alarm_t
   *interrupt;

  aw_handler_t
   *handler;

  /* the method to call when there is data ready to read on fd */
  aw_handler_code_t 
   (*callback)(aw_handler_args_t *args, aw_event_t *e );

} aw_monitor_handler_irecallback_t;


typedef struct aw_monitor_xaction_state_s {

  aw_hash32_t
   *handler_xaction2count;

} aw_monitor_xaction_state_t;

typedef struct aw_monitor_sched_s {

  int32_t
   policy;

  struct sched_param
   params;

} aw_monitor_sched_t;

typedef enum {
  AW_MONITOR_STOP_STATE,
  AW_MONITOR_RUN_STATE,
  AW_MONITOR_PAUSE_STATE,
  AW_MONITOR_FUBAR_STATE,
  AW_MONITOR_NSTATES              /* must be last! */
} aw_monitor_state_t;

typedef struct aw_monitor_s {

  /* one of aw_monitor_state_t */
  aw_monitor_state_t
   state;   

  /* logger for warning/error messages */
  aw_logger_t
   logger;

  /* lock for manipulating monitor */
  aw_plock_t
   lock;

  /* alarms */
  aw_monitor_alarm_q_t
   alarm_q;

  /* id squencer for event sigs + lock */
  struct {

    /* for mask based addressing, needed
       so that handlers don't accidently
       reuse mask bits */
    u_int32_t
     high_mask_bit; // highest mask bit available

    /* for point 2 point addressing */
    aw_address_t 
     counter;

    aw_plock_t
     lock;

  } event_addr;

  /* sychronized xfer point for events */
  aw_monitor_relay_t
   relay_q;

  /* sychronized xfer point for fd events */
  aw_monitor_fd_relay_t
   fd_relay_q;

  /* event handlers */
  aw_monitor_handler_q_t
   handler_q;

  /* thread pool for handler tasklets */
  aw_tasklet_pool_t
   handler_tasklet_pool;

  /* info about current transactions */
  aw_monitor_xaction_state_t
   xaction_state;

  /* used if you want to send signals to creating process */
  pid_t
   creation_pid;

  /* thread control */
  u_int32_t
   threadstop;

} aw_monitor_t;

typedef struct {

  /* logger params for warning/error messages */
  aw_logger_params_t
   logger_params;

  /* process init */
  aw_monitor_sched_t
   sched;

} aw_monitor_params_t;

/* #################### macros ######################## */

/* change default min level for debugging */
#ifdef AW_DEBUG
  #define AW_MONITOR_LOGGER_DEFAULT_MINLEVEL AW_DEBUG_LOG_LEVEL 
#else
  #define AW_MONITOR_LOGGER_DEFAULT_MINLEVEL AW_INFO_LOG_LEVEL 
#endif

#define AW_MONITOR_LOGGER_DEFAULT_PARAMS { \
\
 .filename = NULL,\
\
 /* stderr */ \
 .fd = 2, \
 \
 .min_level = AW_MONITOR_LOGGER_DEFAULT_MINLEVEL,\
\
 .max_level = AW_ERROR_LOG_LEVEL, \
\
 .strlevel = NULL, \
\
 .flags = AW_LOGGER_DEFAULT_FLAGS, \
\
 .error_logger = NULL \
}

/* @define AW_MONITOR_SCHED_DEFAULT_PARAMS
   Default process scheduling parameters
*/
#define AW_MONITOR_SCHED_DEFAULT_PARAMS {\
\
 .policy = SCHED_OTHER, \
 .params.sched_priority = 0 \
}

#define AW_MONITOR_DEFAULT_PARAMS { \
 .logger_params = AW_MONITOR_LOGGER_DEFAULT_PARAMS , \
 .sched = AW_MONITOR_SCHED_DEFAULT_PARAMS \
}

/* #################### exported functions ######################## */

/* monitor.c */

aw_address_t aw_reserve_event_mask_bit(aw_monitor_t *mon);

aw_address_t aw_next_event_id(aw_monitor_t *mon);

aw_handlerid_t aw_add_handler(aw_monitor_t *mon, aw_handler_t *handler);

void aw_reschedule_handler(aw_monitor_t *mon, aw_handler_t *handler, aw_alarm_sched_t *sched);

void aw_remove_handler(aw_monitor_t *mon, aw_handlerid_t id);

int32_t aw_add_handler_fdcallback(aw_monitor_t *mon, aw_handler_t *handler, int32_t fd,   
                                  aw_handler_code_t (*fdcallback)(aw_handler_args_t *args, int32_t fd ));

int32_t aw_remove_handler_fdcallback(aw_monitor_t *mon, int32_t fd);

int32_t aw_add_handler_irecallback(aw_monitor_t *mon, aw_handler_t *handler,
                                   aw_address_t ire_id, aw_alarm_sched_t *sched,
                                   aw_handler_code_t (*callback)(aw_handler_args_t *args, aw_event_t *e ));

int32_t aw_remove_handler_irecallback(aw_monitor_t *mon, aw_address_t ire_id);


void aw_signal_handler_irecallback(aw_monitor_t *mon, aw_address_t ire_id);


void aw_monitor_append_q(aw_event_q_t *q, aw_monitor_t *mon);

void aw_monitor_append_event(aw_event_t *event, aw_monitor_t *mon);

void aw_monitor_int32_event(aw_monitor_t *mon, aw_event_sig_t *event_sig, u_int32_t val);

void aw_monitor_int64_event(aw_monitor_t *mon, aw_event_sig_t *event_sig, u_int64_t val);


void aw_monitor_float32_event(aw_monitor_t *mon, aw_event_sig_t *event_sig, float32_t val);

void aw_monitor_float64_event(aw_monitor_t *mon, aw_event_sig_t *event_sig, float64_t val);



void aw_monitor_timestamp_event(aw_monitor_t *mon, aw_event_sig_t *event_sig, aw_timestamp_t val);

void aw_monitor_string_event(aw_monitor_t *mon, aw_event_sig_t *event_sig, byte_t *val, int32_t dup);

int32_t aw_wait_monitor(aw_monitor_t *mon);


aw_monitor_t * aw_create_monitor(aw_monitor_params_t *params);


void aw_destroy_monitor(aw_monitor_t *mon);

void aw_monitor_logstats(aw_monitor_t *mon, aw_logger_t *logger);

#endif

Aware 0.11.1 Copyright (C) 1998-2005 Russell Leighton (russ@elegant-software.com)