ssm.h

Go to the documentation of this file.

#ifndef _SSM_H
#define _SSM_H

#include <stdint.h>   /* For uint16_t, UINT64_MAX etc. */
#include <stdbool.h>  /* For bool, true, false */
#include <stdlib.h>   /* For size_t */
#include <assert.h>
#include <stddef.h>   /* For offsetof */

#ifndef SSM_ACT_MALLOC

#define SSM_ACT_MALLOC(size) malloc(size)
#endif

#ifndef SSM_ACT_FREE

#define SSM_ACT_FREE(ptr, size) free(ptr)
#endif

#ifndef SSM_RESOURCES_EXHAUSTED

#define SSM_RESOURCES_EXHAUSTED(string) exit(1)
#endif

#ifndef SSM_SECOND

#define SSM_SECOND 1000000000L
#endif

#define SSM_NANOSECOND  (SSM_SECOND/1000000000L)

#define SSM_MICROSECOND (SSM_SECOND/1000000L)

#define SSM_MILLISECOND (SSM_SECOND/1000L)

#define SSM_MINUTE      (SSM_SECOND*60L)

#define SSM_HOUR        (SSM_SECOND*3600L)

typedef uint64_t ssm_time_t;

#define SSM_NEVER UINT64_MAX

typedef uint32_t ssm_priority_t;

#define SSM_ROOT_PRIORITY 0

typedef uint8_t ssm_depth_t;

#define SSM_ROOT_DEPTH (sizeof(ssm_priority_t) * 8)

struct ssm_sv;
struct ssm_trigger;
struct ssm_act;

typedef void ssm_stepf_t(struct ssm_act *);

typedef struct ssm_act {
  ssm_stepf_t *step;       
  struct ssm_act *caller;  
  uint16_t pc;             
  uint16_t children;       
  ssm_priority_t priority; 
  ssm_depth_t depth;       
  bool scheduled;          
} ssm_act_t;

#define SSM_ACT_FIELDS     \
  ssm_stepf_t *step;       \
  ssm_act_t *caller;       \
  uint16_t pc;             \
  uint16_t children;       \
  ssm_priority_t priority; \
  ssm_depth_t depth;       \
  bool scheduled          

typedef struct ssm_trigger {
  struct ssm_trigger *next;      
  struct ssm_trigger **prev_ptr; 
  ssm_act_t *act;           
} ssm_trigger_t;


typedef struct ssm_sv {
  void (*update)(struct ssm_sv *); 
  ssm_trigger_t *triggers;    
  ssm_time_t later_time;       
  ssm_time_t last_updated;     
} ssm_sv_t;


extern void ssm_sensitize(ssm_sv_t *, ssm_trigger_t *);

extern void ssm_desensitize(ssm_trigger_t *);

extern void ssm_activate(ssm_act_t *);

static inline void ssm_call(ssm_act_t *act) { (*(act->step))(act); }

static inline ssm_act_t *ssm_enter(size_t bytes, 
                   ssm_stepf_t *step, 
                   ssm_act_t *parent, 
                   ssm_priority_t priority, 
                   ssm_depth_t depth 
                                 ) {
  assert(bytes > 0);
  assert(step);
  assert(parent);
  ++parent->children;
  ssm_act_t *act = (ssm_act_t *)SSM_ACT_MALLOC(bytes);
  if (!act) SSM_RESOURCES_EXHAUSTED("ssm_enter");
  *act = (ssm_act_t){
      .step = step,
      .caller = parent,
      .pc = 0,
      .children = 0,
      .priority = priority,
      .depth = depth,
      .scheduled = false,
  };
  return act;
}

static inline void ssm_leave(ssm_act_t *act, size_t bytes) {
  assert(act);
  assert(act->caller);
  assert(act->caller->step);
  ssm_act_t *caller = act->caller;
  SSM_ACT_FREE(act, bytes); /* Free the whole activation record, not just the start */
  if ((--caller->children) == 0)
    ssm_call(caller); /* If we were the last child, run our parent */
}

bool ssm_event_on(ssm_sv_t *var  );

void ssm_initialize(ssm_sv_t *var,
            void (*update)(ssm_sv_t *));

void ssm_schedule(ssm_sv_t *var, 
          ssm_time_t later);

void ssm_unschedule(ssm_sv_t *var);

void ssm_trigger(ssm_sv_t *var, 
         ssm_priority_t priority
         );

ssm_time_t ssm_next_event_time(void);

ssm_time_t ssm_now(void);

void ssm_tick();

void ssm_reset();

extern ssm_act_t ssm_top_parent;


#ifdef __GNUC__
#define member_type(type, member) __typeof__(((type *)0)->member)
#else
#define member_type(type, member) const void
#endif
#define container_of(ptr, type, member)                                        \
  ((type *)((char *)(member_type(type, member) *){ptr} -                       \
            offsetof(type, member)))

typedef ssm_sv_t ssm_event_t;
#define ssm_later_event(var, then) ssm_schedule((var), (then))
extern void ssm_assign_event(ssm_event_t *var, ssm_priority_t prio);
extern void ssm_initialize_event(ssm_event_t *);


#define SSM_DECLARE_SV_SCALAR(payload_t)                                       \
  typedef struct {                                                             \
    ssm_sv_t sv;                                                          \
    payload_t value;       /* Current value */                                 \
    payload_t later_value; /* Buffered value */                                \
  } ssm_##payload_t##_t;                                                       \
  void ssm_assign_##payload_t(ssm_##payload_t##_t *sv, ssm_priority_t prio,    \
                          const payload_t value);                              \
  void ssm_later_##payload_t(ssm_##payload_t##_t *sv, ssm_time_t then,         \
                         const payload_t value);                               \
  void ssm_initialize_##payload_t(ssm_##payload_t##_t *v);

#define SSM_DEFINE_SV_SCALAR(payload_t)                                        \
  static void ssm_update_##payload_t(ssm_sv_t *sv) {                      \
    ssm_##payload_t##_t *v = container_of(sv, ssm_##payload_t##_t, sv);        \
    v->value = v->later_value;                                                 \
  }                                                                            \
  void ssm_assign_##payload_t(ssm_##payload_t##_t *v, ssm_priority_t prio,     \
                              const payload_t value) {                         \
    v->value = value;                                          \
    v->sv.last_updated = ssm_now();                        \
    ssm_trigger(&v->sv, prio);                                                 \
  }                                                                            \
  void ssm_later_##payload_t(ssm_##payload_t##_t *v, ssm_time_t then,          \
                         const payload_t value) {                              \
    v->later_value = value;                                                    \
    ssm_schedule(&v->sv, then);                                \
  }                                        \
  void ssm_initialize_##payload_t(ssm_##payload_t##_t *v) {                    \
    ssm_initialize(&v->sv, ssm_update_##payload_t);                        \
  }
 
typedef int8_t   i8;   
typedef int16_t  i16;  
typedef int32_t  i32;  
typedef int64_t  i64;  
typedef uint8_t  u8;   
typedef uint16_t u16;  
typedef uint32_t u32;  
typedef uint64_t u64;  
SSM_DECLARE_SV_SCALAR(bool)
SSM_DECLARE_SV_SCALAR(i8)
SSM_DECLARE_SV_SCALAR(i16)
SSM_DECLARE_SV_SCALAR(i32)
SSM_DECLARE_SV_SCALAR(i64)
SSM_DECLARE_SV_SCALAR(u8)
SSM_DECLARE_SV_SCALAR(u16)
SSM_DECLARE_SV_SCALAR(u32)
SSM_DECLARE_SV_SCALAR(u64)

// FIXME!
#include "ssm-debug.h"

#endif