bool
Timer::add(Event* e, int id, int64_t cycle, void* param)
{
const intptr_t key((intptr_t)e);
auto ib = m_clients.find(key);
if ( ib == m_clients.end() )
{
auto res = m_clients.insert(client_cont::value_type(key, event_cont()));
if ( res.second == false )
{
PWLOGLIB("failed to insert timer event: e:%p id:%d cycle:%jd param:%p", e, id, intmax_t(cycle), param);
return false;
}
event_cont& ec(res.first->second);
// 이후 코드는 insert 성공 여부와 상관 없이 반복자가 무효하다.
invalidateIterator();
if ( false == ec.insert(event_cont::value_type(id, event_type(param, cycle, s_getNow()))).second )
{
PWLOGLIB("failed to insert timer event: e:%p id:%d cycle:%jd param:%p", e, id, intmax_t(cycle), param);
m_clients.erase(ib);
return false;
}
//PWTRACE("add new timer event: e:%p type:%s id:%d cycle:%jdms", e, typeid(*e).name(), id, cycle);
return true;
}
auto& ec = ib->second;
auto ib_event = ec.find(id);
if ( ec.end() == ib_event )
{
if ( false == ec.insert(event_cont::value_type(id, event_type(param, cycle, s_getNow()))).second )
{
PWLOGLIB("failed to insert timer event: e:%p id:%d cycle:%jd param:%p", e, id, intmax_t(cycle), param);
return false;
}
invalidateIterator();
//PWTRACE("add new timer event: e:%p type:%s id:%d cycle:%jdms", e, typeid(*e).name(), id, cycle);
return true;
}
// 반복자를 건들지 않았으므로 invalidateIterator를 호출하지 않는다.
auto& et = ib_event->second;
et.param = param;
et.cycle = cycle;
et.start = s_getNow();
//PWTRACE("add new timer event: e:%p type:%s id:%d cycle:%jdms", e, typeid(*e).name(), id, cycle);
return true;
}
static int syslog(int level, char *fmt, ...)
{
va_list argptr;
char sbuf[1024];
char* p=sbuf;
int retval;
static HANDLE event_handle;
va_start(argptr,fmt);
retval=vsnprintf(sbuf,sizeof(sbuf),fmt,argptr);
sbuf[sizeof(sbuf)-1]=0;
va_end(argptr);
if(event_handle == NULL)
event_handle = RegisterEventSource(
NULL, // server name for source (NULL = local computer)
TITLE); // source name for registered handle
if(event_handle != NULL)
ReportEvent(event_handle, // event log handle
event_type(level), // event type
0, // category zero
0, // event identifier
NULL, // no user security identifier
1, // one string
0, // no data
&p, // pointer to string array
NULL); // pointer to data
return(retval);
}
bool os::task_control_block::execute(const os::tick_type& timepoint_of_ckeck_ready_task) const
{
// Check for a task event.
const bool task_does_have_event = (my_event != event_type(0U));
if(task_does_have_event)
{
// Set the global task index equal to the index of the running task.
os_task_global_index() = my_index;
// Call the task function because of an event.
my_func();
}
// Check for a task timeout.
const bool task_does_have_timeout = ( (my_cycle != os::tick_type(0U))
&& my_timer.timeout_of_specific_timepoint(timepoint_of_ckeck_ready_task));
if(task_does_have_timeout)
{
// Increment the task's interval timer with the task cycle.
my_timer.start_interval(my_cycle);
// Set the global task index equal to the index of the running task.
os_task_global_index() = my_index;
// Call the task function because of a timer timeout.
my_func();
}
return (task_does_have_event || task_does_have_timeout);
}
INPUT_RECORD *TThreads::get_next_event(void) {
if (evpending) return &ir;
PeekConsoleInput(chandle[cnInput],&ir,1,&evpending);
if (evpending) {
int code = event_type(ir);
// printf("evtype = %d\n",code);
switch (code) {
case IO_RAW_EVENT:
ReadConsoleInput(chandle[cnInput],&ir,1,&evpending);
break;
case IO_CHR_EVENT:
char chr;
// printf("before readconsole\n");
ReadConsole(chandle[cnInput],&chr,1,&evpending,NULL);
// printf("key %x %d\n",chr,evpending);
ir.Event.KeyEvent.uChar.AsciiChar = chr;
break;
case IO_IGN_EVENT:
ReadConsoleInput(chandle[cnInput],&ir,1,&evpending);
accept_event();
break;
}
}
return evpending ? &ir : NULL;
}
int
unexpected_event(struct streamstate* stp)
{
fprintf(stderr, "%s:%zu:%zu:unexpected event: %s\n",
stp->filename, stp->event.start_mark.line+1, stp->event.start_mark.column+1,
event_type(&stp->event));
return 1;
}
void EventDispatcherBase<TDerived>::enterInitialStates()
{
// TODO: Would be nice, if the state machine had an initial
// transition similar to initial transitions of states.
clearTransientStateFlags();
derived().m_flags |= state_type::InEnterSet;
markDescendantsForEntry();
enterStatesInEnterSet(event_type());
}
void EventDispatcherBase<TDerived>::runToCompletion(bool changedConfiguration)
{
// We are in microstepping mode: follow all eventless transitions.
while (1)
{
clearTransientStateFlags();
selectTransitions(true, event_type());
if (!m_enabledTransitions)
break;
changedConfiguration |= microstep(event_type());
clearEnabledTransitionsSet();
}
// Synchronize the visible state active flag with the internal
// state active flag.
for (auto iter = derived().begin(); iter != derived().end(); ++iter)
iter->m_visibleActive = (iter->m_flags & state_type::Active) != 0;
// Call the invoke() methods of all currently active states.
for (auto iter = derived().begin(); iter != derived().end(); ++iter)
{
if (iter->m_flags & state_type::StartInvoke)
{
iter->enterInvoke();
iter->m_flags &= ~state_type::StartInvoke;
iter->m_flags |= state_type::Invoked;
}
}
// If we followed at least one transition, which was not target-less,
// invoke the configuration change callback.
if (changedConfiguration)
{
++m_numConfigurationChanges;
derived().invokeConfigurationChangeCallback();
}
}
void EventDispatcherBase<TDerived>::leaveConfiguration()
{
for (auto iter = derived().begin(); iter != derived().end(); ++iter)
{
if (iter->m_flags & state_type::Active)
iter->m_flags |= state_type::InExitSet;
}
leaveStatesInExitSet(event_type());
for (auto iter = derived().begin(); iter != derived().end(); ++iter)
iter->m_visibleActive = false;
++m_numConfigurationChanges;
derived().invokeConfigurationChangeCallback();
//! \todo Clear the event list? Or document that the event list is
//! preserved when the FSM is stopped?
}
void
debug_event_type(yaml_event_t* ep)
{
printf("%s", event_type(ep));
}
static void upnm_handler(state_t s, event_t e) {
switch(event_type(e)) {
case EVENT_FAIL:
assert(bool_array_super(event_failures(e), s->failed, s->vs->nmembers)) ;
bool_array_copy_into(s->failed, event_failures(e), s->vs->nmembers) ;
upnm(s, e) ;
break ;
case EVENT_INIT:
dnnm(s, event_timer_time(time_zero())) ;
upnm(s, e) ;
break ;
case EVENT_TIMER: {
etime_t time = event_time(e) ;
item_t item ;
while (priq_get_upto(s->priq, time, NULL, (void**)&item)) {
s->acct_delivered ++ ;
switch(item->type) {
case DROP_UP: {
rank_t origin = event_peer(item->u.up.event) ;
if (origin >= 0 &&
array_get(s->failed, origin)) {
up_free(item->u.up.event, item->u.up.abv) ;
} else {
up(s, item->u.up.event, item->u.up.abv) ;
}
} break ;
case DROP_UPNM:
upnm(s, item->u.upnm.event) ;
break ;
OTHERWISE_ABORT() ;
}
record_free(item) ;
}
if (time_ge(time, s->next_sweep)) {
if (!time_is_zero(s->next_sweep) &&
sys_random(5) == 1) {
rank_t i ;
bool_array_t suspects = bool_array_create_init(s->vs->nmembers, FALSE) ;
for(i=0;i<s->vs->nmembers;i++) {
if (i == s->ls->rank) {
continue ;
}
if (sys_random(4) == 0) {
array_set(suspects, i, TRUE) ;
}
}
if (bool_array_exists(suspects, s->vs->nmembers)) {
dnnm(s, event_suspect_reason_create(suspects, name)) ;
} else {
array_free(suspects) ;
}
}
#if 0
/* Suspicions are randomly generated every 0-8 seconds.
*/
s->next_sweep = time_add(time, time_of_usecs(sys_random(1<<23/*8M*/))) ;
#else
s->next_sweep = time_add(time, time_of_usecs(sys_random(1<<20/*1M*/))) ;
#endif
dnnm(s, event_timer_time(s->next_sweep)) ; /* request next sweep */
}
upnm(s, e) ;
} break ;
case EVENT_GOSSIP_EXT: {
/*endpt_id_t origin = NULL ;*/
etime_t delay ;
/*
let origin =
getExtender (function
| HealGos(_,(_,endpt),_,_) -> Some (Some endpt)
| SwitchGos(_,(_,endpt),_) -> Some (Some endpt)
| _ -> None
) None ev
in
*/
if (1 /*!origin*/) {
upnm(s, e) ;
} else if (s->partition) {
sys_abort() ;
} else if (!distrib(s, &delay)) {
event_free(e) ;
} else {
/* Deliver after a certain delay....
*/
etime_t when = time_add(alarm_gettime(s->alarm), delay) ;
item_t item = record_create(item_t, item) ;
item->type = DROP_UPNM ;
item->u.upnm.event = e ;
priq_add(s->priq, when, item) ;
dnnm(s, event_timer_time(when)) ;
}
} break ;
case EVENT_ACCOUNT:
log(("delivered=%d dropped=%d", s->acct_delivered, s->acct_dropped)) ;
upnm(s, e) ;
break ;
EVENT_DUMP_HANDLE() ;
default:
upnm(s, e) ;
break ;
}
}
proton_event::proton_event(pn_event_t *ce, pn_event_type_t t, class container *c) :
pn_event_(ce),
type_(event_type(t)),
container_(c)
{}
QBindDelegate( const boost::function<void()>& f )
:QEvent( (QEvent::Type)event_type() ),run(f){}
