bool is_cylinder_used(struct dive *dive, int idx) { struct divecomputer *dc; bool firstGasExplicit = false; if (cylinder_none(&dive->cylinder[idx])) return false; if ((dive->cylinder[idx].start.mbar - dive->cylinder[idx].end.mbar) > SOME_GAS) return true; for_each_dc(dive, dc) { struct event *event = get_next_event(dc->events, "gaschange"); while (event) { if (dc->sample && (event->time.seconds == 0 || (dc->samples && dc->sample[0].time.seconds == event->time.seconds))) firstGasExplicit = true; if (get_cylinder_index(dive, event) == idx) return true; event = get_next_event(event->next, "gaschange"); } if (dc->divemode == CCR && (idx == dive->diluent_cylinder_index || idx == dive->oxygen_cylinder_index)) return true; } if (idx == 0 && !firstGasExplicit) return true; return false; }
int SquiggleRead::get_closest_event_to(int k_idx, uint32_t strand) const { int stop_before = std::max(0, k_idx - 1000); int stop_after = std::min(k_idx + 1000, (int32_t)read_sequence.size() - K + 1); int event_before = get_next_event(k_idx, stop_before, -1, strand); int event_after = get_next_event(k_idx, stop_after, 1, strand); // TODO: better selection of "best" event to return if(event_before == -1) return event_after; return event_before; }
static void configure_next_event() { //this function should only be called from an atomic context timer_tick_t next_fire_time; do { //find the next event that has not yet passed, and schedule //the 'late' events while we're at it NG(next_event) = get_next_event(); if(NG(next_event) != NO_EVENT) { next_fire_time = NG(timers)[NG(next_event)].next_event; if ( (((int32_t)next_fire_time) - ((int32_t)timer_get_counter_value())) <= 0 ) { sched_post_task_prio(NG(timers)[NG(next_event)].f, NG(timers)[NG(next_event)].priority); NG(timers)[NG(next_event)].f = 0x0; } } } while(NG(next_event) != NO_EVENT && ( (((int32_t)next_fire_time) - ((int32_t)timer_get_counter_value())) <= 0 ) ); //at this point NG(next_event) is eiter equal to NO_EVENT (no tasks left) //or we have the next event we can schedule if(NG(next_event) == NO_EVENT) { //cancel the timer in case it is still running (can happen if we're called from timer_cancel_event) NG(hw_event_scheduled) = false; hw_timer_cancel(HW_TIMER_ID); } else { //calculate schedule time relative to current time rather than //latest overflow time, to counteract any delays in updating counter_offset //(eg when we're scheduling an event from an interrupt and thereby delaying //the updating of counter_offset) timer_tick_t fire_delay = (next_fire_time - timer_get_counter_value()); //if the timer should fire in less ticks than supported by the HW timer --> schedule it //(otherwise it is scheduled from timer_overflow when needed) if(fire_delay < COUNTER_OVERFLOW_INCREASE) { NG(hw_event_scheduled) = true; hw_timer_schedule_delay(HW_TIMER_ID, (hwtimer_tick_t)fire_delay); #ifndef NDEBUG //check that we didn't try to schedule a timer in the past //normally this shouldn't happen but it IS theoretically possible... fire_delay = (next_fire_time - timer_get_counter_value()); //fire_delay should be in [0,COUNTER_OVERFLOW_INCREASE]. if this is not the case, it is because timer_get_counter() is //now larger than next_fire_event, which means we 'missed' the event assert(((int32_t)fire_delay) > 0); #endif } else { //set hw_event_scheduled explicitly to false to allow timer_overflow //to schedule the event when needed NG(hw_event_scheduled) = false; } } }
boost::shared_ptr<receiver> accept( Parcelport & parcelport, util::memory_chunk_pool & pool, boost::system::error_code &ec) { boost::shared_ptr<receiver> rcv; rdma_cm_event event; if(!get_next_event(event_channel_, event, this, ec)) { return rcv; } if(event.event == RDMA_CM_EVENT_CONNECT_REQUEST) { rdma_conn_param cm_params; std::memset(&cm_params, 0, sizeof(rdma_conn_param)); cm_params.initiator_depth = cm_params.responder_resources = 1; cm_params.rnr_retry_count = 7; // infinite retry rcv.reset(new receiver(parcelport, pool)); rcv->context().build_connection(parcelport, event.id, ec); if(ec) { rcv.reset(); return rcv; } rcv->context().on_preconnect(event.id, ec); if(ec) { rcv.reset(); return rcv; } rdma_accept(event.id, &cm_params); pending_recv_list.push_back(std::make_pair(event, rcv)); rcv.reset(); return rcv; } if(event.event == RDMA_CM_EVENT_ESTABLISHED) { for(pending_recv_list_type::iterator it = pending_recv_list.begin(); it != pending_recv_list.end();) { if(it->first.id == event.id) { rcv = it->second; rcv->context().on_connection(event.id, ec); it = pending_recv_list.erase(it); break; } else { ++it; } } HPX_ASSERT(rcv); } return rcv; }
int cros_ec_get_next_event(struct cros_ec_device *ec_dev) { if (ec_dev->mkbp_event_supported) return get_next_event(ec_dev); else return get_keyboard_state_event(ec_dev); }
int main(int argc, char **argv) { struct system_t system; init(&system); //performance_begin(); #ifdef __10000_CUSTOMER__ while (system.total_served < SIM_CUSTOMER) #else while (system.current_time < SIM_TIME) #endif { enum event_type_t event = get_next_event(&system); switch (event) { case ARRIVAL: arrival_process(&system); break; case DEPARTURE: departure_process(&system); break; default: break; } } performance_end(&system); deinit(&system); return 0; }
int cros_ec_get_next_event(struct cros_ec_device *ec_dev, bool *wake_event) { u32 host_event; int ret; if (!ec_dev->mkbp_event_supported) { ret = get_keyboard_state_event(ec_dev); if (ret < 0) return ret; if (wake_event) *wake_event = true; return ret; } ret = get_next_event(ec_dev); if (ret < 0) return ret; if (wake_event) { host_event = cros_ec_get_host_event(ec_dev); /* Consider non-host_event as wake event */ *wake_event = !host_event || !!(host_event & ec_dev->host_event_wake_mask); } return ret; }
/** * @brief * returns 1 if there exists a timed run event in * the event list between the current event * and the last event, or the end time if it is set * * @param[in] calendar - event list * @param[in] end - optional end time (0 means search all events) * * @return int * @retval 1 : there exists a run event * @retval 0 : there doesn't exist a run event * */ int exists_run_event(event_list *calendar, time_t end) { timed_event *te; if (calendar == NULL) return 0; te = get_next_event(calendar); if (te == NULL) /* no events in our calendar */ return 0; te = find_init_timed_event(te, IGNORE_DISABLED_EVENTS, TIMED_RUN_EVENT); if (te == NULL) /* no run event */ return 0; /* there is a run event, but it's after end */ if (end != 0 && te->event_time > end) return 0; /* if we got here, we have a happy run event */ return 1; }
/** * @brief * generic simulation function which will call a function pointer over * events of a calendar from now up to (but not including) the end time. * @par * The simulation works by looping searching for a success or failure. * The loop will stop if the function returns 1 for success or -1 for * failure. We continue looping if the function returns 0. If we run * out of events, we return the default passed in. * * @par Function: * The function can return three return values * >0 success - stop looping and return success * 0 failure - keep looping * <0 failure - stop looping and return failure * * @param[in] calendar - calendar of timed events * @param[in] event_mask - mask of timed_events which we want to simulate * @param[in] end - end of simulation (0 means search all events) * @param[in] default_ret - default return value if we reach the end of the simulation * @param[in] func - the function to call on each timed event * @param[in] arg1 - generic arg1 to function * @param[in] arg2 - generic arg2 to function * * @return success of simulate * @retval 1 : if simulation is success * @retval 0 : if func returns failure or there is an error */ int generic_sim(event_list *calendar, unsigned int event_mask, time_t end, int default_ret, int (*func)(timed_event*, void*, void*), void *arg1, void *arg2) { timed_event *te; int rc = 0; if (calendar == NULL || func == NULL) return 0; /* We need to handle the calendar's initial event special because * get_next_event() only returns the calendar's next_event member. * We need to make sure the initial event is of the correct type. */ te = get_next_event(calendar); for (te = find_init_timed_event(te, IGNORE_DISABLED_EVENTS, event_mask); te != NULL && rc == 0 && (end == 0 || te->event_time < end); te = find_next_timed_event(te, IGNORE_DISABLED_EVENTS, event_mask)) { rc = func(te, arg1, arg2); } if (rc > 0) return 1; else if (rc < 0) return 0; return default_ret; }
/* Execute the server-side duties for remote on-the-wire testing using * a real NIC. Basically the server side just needs to send packets * over the wire (to the kernel under test) and sniff and verify * packets on the wire (from the kernel under test). This is analogous * to run_script(), which executes scripts for stand-alone mode, * and also executes the client side for remote on-the-wire testing * using a real NIC. */ static int wire_server_run_script(struct wire_server *wire_server, char **error) { struct state *state = wire_server->state; struct event *event = NULL; DEBUGP("wire_server_run_script\n"); state->live_start_time_usecs = now_usecs(); DEBUGP("live_start_time_usecs is %lld\n", state->live_start_time_usecs); while (1) { if (get_next_event(state, error)) return STATUS_ERR; event = state->event; if (event == NULL) break; if (wire_server_next_event(wire_server, event)) return STATUS_ERR; /* We adjust relative times after getting notification * that previous client-side events have completed. */ adjust_relative_event_times(state, event); switch (event->type) { case PACKET_EVENT: if (wire_server_run_packet_event(wire_server, event, event->event.packet, error) == STATUS_ERR) return STATUS_ERR; break; case SYSCALL_EVENT: DEBUGP("SYSCALL_EVENT happens on client side...\n"); break; case COMMAND_EVENT: DEBUGP("COMMAND_EVENT happens on client side...\n"); break; case CODE_EVENT: DEBUGP("CODE_EVENT happens on client side...\n"); break; case INVALID_EVENT: case NUM_EVENT_TYPES: assert(!"bogus type"); break; /* We omit default case so compiler catches missing values. */ } } /* Tell the client about any outstanding packet events it requested. */ wire_server_next_event(wire_server, NULL); DEBUGP("wire_server_run_script: done running\n"); return STATUS_OK; }
static INLINE void send_event(part_evtlist_t *evlist, void **val, bool (*match_func)(void **a, void **b)) { elistdata_t eld_p; mempart_evt_t *reg_event = get_first_event(evlist, &eld_p); while (reg_event != NULL) { struct evt_info_s *evt = ®_event->evt_reg; if (reg_event->onlist == &evlist->active) { /* if this event has been deactivated, don't send it */ if (evt->flags & evtflags_DEACTIVATE) { deactivate_event(evlist, (part_evt_t *)reg_event); } /* check for event send conditions */ else if (reg_event->evt_dest.rcvid > 0) { void **compare_val_p = GET_COMPARE_VAL_P(evt); CRASHCHECK(compare_val_p == NULL); /* * if the caller did not provide a match function, or a match * function was provided and it returns TRUE, deliver the event */ if ((match_func == NULL) || (match_func(compare_val_p, val) == bool_t_TRUE)) { int r; struct sigevent se = evt->sig; // make a local copy /* * if the caller has set evtflags_SIGEV_FLAG_SIGINFO, we * can return some useful information */ if (evt->flags & evtflags_SIGEV_FLAG_SIGINFO) { se.sigev_value.sival_ptr = *val; } r = apm_deliver_event(®_event->evt_dest, &se); if (r == EOK) reg_event->undeliverable_count = 0; else if (r == ESRCH) ++reg_event->undeliverable_count; if ((reg_event->undeliverable_count > ORPHAN_RETRY_COUNT) || (!(evt->flags & evtflags_REARM))) { /* remove the event from the list */ deactivate_event(evlist, (part_evt_t *)reg_event); } } } } reg_event = get_next_event(evlist, reg_event, &eld_p); } }
static void check_gas_change_events(struct dive *dive, struct divecomputer *dc, struct plot_info *pi) { int i = 0, cylinderindex = 0; struct event *ev = get_next_event(dc->events, "gaschange"); // for dive computers that tell us their first gas as an event on the first sample // we need to make sure things are setup correctly cylinderindex = explicit_first_cylinder(dive, dc); set_first_cylinder_index(pi, 0, cylinderindex, ~0u); if (!ev) return; do { i = set_cylinder_index(pi, i, cylinderindex, ev->time.seconds); cylinderindex = get_cylinder_index(dive, ev); ev = get_next_event(ev->next, "gaschange"); } while (ev); set_cylinder_index(pi, i, cylinderindex, ~0u); }
static void check_setpoint_events(struct dive *dive, struct divecomputer *dc, struct plot_info *pi) { int i = 0; pressure_t setpoint; setpoint.mbar = 0; struct event *ev = get_next_event(dc->events, "SP change"); if (!ev) return; do { i = set_setpoint(pi, i, setpoint.mbar, ev->time.seconds); setpoint.mbar = ev->value; if (setpoint.mbar) dc->divemode = CCR; ev = get_next_event(ev->next, "SP change"); } while (ev); set_setpoint(pi, i, setpoint.mbar, ~0u); }
void TankItem::modelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight) { Q_UNUSED(topLeft); Q_UNUSED(bottomRight); // We don't have enougth data to calculate things, quit. if (!dataModel || !pInfoEntry || !pInfoNr) return; // remove the old rectangles foreach (QGraphicsRectItem *r, rects) { delete(r); } rects.clear(); qreal width, left; // Find correct end of the dive plot for correct end of the tankbar struct plot_data *last_entry = &pInfoEntry[pInfoNr-1]; // get the information directly from the displayed_dive (the dc always exists) struct divecomputer *dc = get_dive_dc(&displayed_dive, dc_number); // start with the first gasmix and at the start of the dive int cyl = explicit_first_cylinder(&displayed_dive, dc); struct gasmix *gasmix = &displayed_dive.cylinder[cyl].gasmix; int startTime = 0; // work through all the gas changes and add the rectangle for each gas while it was used struct event *ev = get_next_event(dc->events, "gaschange"); while (ev && ev->time.seconds < last_entry->sec) { width = hAxis->posAtValue(ev->time.seconds) - hAxis->posAtValue(startTime); left = hAxis->posAtValue(startTime); createBar(left, width, gasmix); startTime = ev->time.seconds; gasmix = get_gasmix_from_event(&displayed_dive, ev); ev = get_next_event(ev->next, "gaschange"); } width = hAxis->posAtValue(last_entry->sec) - hAxis->posAtValue(startTime); left = hAxis->posAtValue(startTime); createBar(left, width, gasmix); }
errval_t event_dispatch(struct waitset *ws) { struct event_closure closure; errval_t err = get_next_event(ws, &closure); if (err_is_fail(err)) { return err; } assert(closure.handler != NULL); closure.handler(closure.arg); return SYS_ERR_OK; }
/* look at all dive computers and figure out if this cylinder is used anywhere * d has to be a valid dive (test before calling) * cyl does not have to be a cylinder that is part of this dive structure */ bool cylinder_is_used(struct dive *d, cylinder_t *cyl) { struct divecomputer *dc = &d->dc; bool same_as_first = gasmix_distance(&cyl->gasmix, &d->cylinder[0].gasmix) < 200; while (dc) { struct event *ev = get_next_event(dc->events, "gaschange"); if (same_as_first && (!ev || ev->time.seconds > 30)) { // unless there is a gas change in the first 30 seconds we can // always mark the first cylinder as used return true; } while (ev) { if (gasmix_distance(&cyl->gasmix, get_gasmix_from_event(ev)) < 200) return true; ev = get_next_event(ev->next, "gaschange"); } dc = dc->next; } return false; }
bool is_cylinder_used(struct dive *dive, int idx) { struct divecomputer *dc; bool firstGasExplicit = false; if (cylinder_none(&dive->cylinder[idx])) return false; for_each_dc(dive, dc) { struct event *event = get_next_event(dc->events, "gaschange"); while (event) { if (event->time.seconds < 30) firstGasExplicit = true; if (get_cylinder_index(dive, event) == idx) return true; event = get_next_event(event->next, "gaschange"); } } if (idx == 0 && !firstGasExplicit) return true; return false; }
inline bool get_next_event( rdma_event_channel *event_channel, rdma_cm_event & event_copy, Connection * c , boost::system::error_code &ec ) { if(!event_channel) { HPX_IBVERBS_THROWS_IF(ec, boost::asio::error::not_connected); return false; } rdma_cm_event * event = NULL; if(rdma_get_cm_event(event_channel, &event) == 0) { std::memcpy(&event_copy, event, sizeof(rdma_cm_event)); rdma_ack_cm_event(event); if(event_copy.event == RDMA_CM_EVENT_DISCONNECTED) { c->on_disconnect(event_copy.id); return get_next_event(event_channel, event_copy, c, ec); } return true; } else { int verrno = errno; if(verrno == EBADF) return false; if(verrno == EAGAIN) return false; if(verrno == EWOULDBLOCK) return false; boost::system::error_code err(verrno, boost::system::system_category()); HPX_IBVERBS_THROWS_IF( ec , err ); return false; } HPX_ASSERT(false); return false; }
static void received_event_add_request(gint fd) { gchar *vevent; gchar *msg; gchar *new_vevent = NULL; vevent = get_next_event(); g_print("Event to add: '%s'\n",vevent); if (vevent) { AlertValue val; val = G_ALERTALTERNATE; if (opensync_config.event_ask_add) { msg = g_strdup_printf(_("Really add event:\n%s?"),vevent); val = alertpanel(_("OpenSync plugin"),msg, GTK_STOCK_CANCEL,GTK_STOCK_ADD,NULL); g_free(msg); } if (!opensync_config.event_ask_add || (val != G_ALERTDEFAULT)) { if((new_vevent = vcal_add_event(vevent)) != NULL) { g_print("adding successful\n"); } else g_print("could not add event\n"); } else { g_print("Error: User refused to add event '%s'\n", vevent); } } else { g_print("Error: Not able to get the event to add\n"); } if(new_vevent) event_send_cb(new_vevent); else sock_send(fd, ":failure:\n"); g_free(vevent); }
void track::del_event(unsigned short int row, int needlock) { event *e,*e2; if (event_list) { if (needlock) lock_mutex(song->hEditMutex,EDIT_LOCK_TIMEOUT); if (event_list->row == row) { e = (event *)event_list->next_event; delete event_list; event_list = e; file_changed++; } else { if (e=get_next_event(row)) { e2 = (event *)e->next_event; e->next_event = e2->next_event; delete e2; file_changed++; } } if (needlock) unlock_mutex(song->hEditMutex); } }
/** * @brief finds if there is a reservation run event between now and 'end' * @param[in] calendar - the calendar to search * @param[in] end - when to stop searching * * @returns int * @retval 1 found a reservation event * @retval 0 did not find a reservation event */ int exists_resv_event(event_list *calendar, time_t end) { timed_event *te; timed_event *te_list; if (calendar == NULL) return 0; te_list = get_next_event(calendar); if (te_list == NULL) /* no events in our calendar */ return 0; for (te = te_list; te != NULL && te->event_time <= end; te = find_next_timed_event(te, 0, TIMED_RUN_EVENT)) { if (te->event_type == TIMED_RUN_EVENT) { resource_resv *resresv = (resource_resv *)te->event_ptr; if(resresv->is_resv) return 1; } } return 0; }
/* THIS IS MAIN */ int main(int argc, char *argv[]) { nge_connection *c = NULL; nge_event *e = NULL; /* open correct socket */ if (strstr(argv[0], "ngde")) c = ngeclient_connect(NGE_TEST); else c = ngeclient_connect(NGE_REAL); /* if open_socket fails, ngeclient_error is set */ if (ngeclient_error) { fprintf(stderr, "NGECLIENT ERROR: %s\n", ngeclient_error); exit(1); } assert(c); while ((e = get_next_event(c, 20000))) { /*printf("Got an event: %i!\n", e->state_type); */ handle_event(e); ngeclient_event_free(e); } /* clean up */ ngeclient_close(c); /* check so there is no ngeclient_error set */ if (ngeclient_error) { fprintf(stderr, "NGECLIENT ERROR: %s\n", ngeclient_error); exit(1); } exit(0); }
int main(int argc, char **argv) { unsigned int mainWndId; unsigned int gc; KWEvent event; mainWndId = new_main_window_simple(50, 50, WIDTH, HEIGHT, "Window 1, This is the first one."); if (mainWndId == BAD_WND_ID) { LOG(("%s\n", "<Demo2 Error> can not create the main window.")); exit (-1); } gc = new_gc(); select_events(mainWndId, EVENT_MASK_EXPOSURE); map_window(mainWndId); for (;;) { get_next_event(&event); switch (event.type) { } } }
/* THIS IS MAIN */ int main(int argc, char *argv[]) { nge_connection *c = NULL; nge_event *e = NULL; pid_t fork_pid; /* open up for usplash */ if (chdir("/dev/.initramfs") != 0) { printf("Error chdir \"/dev/.initramfs\"\n"); exit(1); } /* set some progress */ /*usplash("TEXT Launching InitNG"); */ usplash("PROGRESS 10"); usplash("TIMEOUT 180"); /* ok, now fork */ fork_pid = fork(); /* make sure this is not the fork */ if (fork_pid != 0) { /* Now make sure this is not a fork */ char initng_path[] = "/sbin/initng"; argv[0] = initng_path; execve(argv[0], argv, environ); _exit(1); } /* FROM HERE, IS run in a fork. */ /* open correct socket */ while (!c) { /* reset error every time, or you get an can not connect to socket */ ngeclient_error = NULL; c = ngeclient_connect(NGE_REAL); usleep(100); } /* if open_socket fails, ngeclient_error is set */ if (ngeclient_error) { usplash("QUIT"); fprintf(stderr, "NGECLIENT ERROR: %s\n", ngeclient_error); exit(1); } assert(c); while ((e = get_next_event(c, 200000))) { /*printf("Got an event: %i!\n", e->state_type); */ handle_event(e); ngeclient_event_free(e); } /* clean up */ ngeclient_close(c); /* check so there is no ngeclient_error set */ if (ngeclient_error) { usplash("QUIT"); fprintf(stderr, "NGECLIENT ERROR: %s\n", ngeclient_error); exit(1); } /* stop usplash daemon */ usplash("QUIT"); exit(0); }
bool get_next_rdma_event(rdma_cm_event & event, boost::system::error_code &ec) { return get_next_event(event_channel_, event, this, ec); }
void run_script(struct config *config, struct script *script) { char *error = NULL; struct state *state = NULL; struct netdev *netdev = NULL; struct event *event = NULL; DEBUGP("run_script: running script\n"); set_scheduling_priority(); lock_memory(); /* This interpreter loop runs for local mode or wire client mode. */ assert(!config->is_wire_server); /* How we use the network is of course a little different in * each of the two cases.... */ if (config->is_wire_client) netdev = wire_client_netdev_new(config); else netdev = local_netdev_new(config); state = state_new(config, script, netdev); if (config->is_wire_client) { state->wire_client = wire_client_new(); wire_client_init(state->wire_client, config, script, state); } if (script->init_command != NULL) { if (safe_system(script->init_command->command_line, &error)) { die("%s: error executing init command: %s\n", config->script_path, error); } } signal(SIGPIPE, SIG_IGN); /* ignore EPIPE */ state->live_start_time_usecs = schedule_start_time_usecs(); DEBUGP("live_start_time_usecs is %lld\n", state->live_start_time_usecs); if (state->wire_client != NULL) wire_client_send_client_starting(state->wire_client); while (1) { if (get_next_event(state, &error)) die("%s", error); event = state->event; if (event == NULL) break; if (state->wire_client != NULL) wire_client_next_event(state->wire_client, event); /* In wire mode, we adjust relative times after * getting notification that previous packet events * have completed, if any. */ adjust_relative_event_times(state, event); switch (event->type) { case PACKET_EVENT: /* For wire clients, the server handles packets. */ if (!config->is_wire_client) { run_local_packet_event(state, event, event->event.packet); } break; case SYSCALL_EVENT: run_system_call_event(state, event, event->event.syscall); break; case COMMAND_EVENT: run_command_event(state, event, event->event.command); break; case CODE_EVENT: run_code_event(state, event, event->event.code->text); break; case INVALID_EVENT: case NUM_EVENT_TYPES: assert(!"bogus type"); break; /* We omit default case so compiler catches missing values. */ } } /* Wait for any outstanding packet events we requested on the server. */ if (state->wire_client != NULL) wire_client_next_event(state->wire_client, NULL); if (code_execute(state->code, &error)) { die("%s: error executing code: %s\n", state->config->script_path, error); free(error); } state_free(state); DEBUGP("run_script: done running\n"); }
// app event loop static void check_events(void) { static event_t e; // u8 launch = 0; // print_dbg("\r\n checking events..."); if( get_next_event(&e) ) { /* print_dbg("\r\n handling event, type: "); */ /* print_dbg_hex(e.eventType); */ /* print_dbg("\r\n , data: "); */ /* print_dbg_hex(e.eventData); */ if(startup) { if( e.eventType == kEventSwitch0 || e.eventType == kEventSwitch1 || e.eventType == kEventSwitch2 || e.eventType == kEventSwitch3 || e.eventType == kEventSwitch4 ) { startup = 0; print_dbg("\r\n key pressed, launching "); // return 1 if app completed firstrun tasks // launch = app_launch(firstrun); delay_ms(10); if( firstrun) { // if(launch) { // successfully launched on firstrun, so write magic number to flash flash_write_firstrun(); // return; // } else { // firstrun, but app launch failed, so clear magic number to try again // flash_clear_firstrun(); // } } } } else { switch(e.eventType) { case kEventRefresh: // refresh the screen hardware // screen_refresh(); /// draw ADC values break; case kEventMonomePoll : // poll monome serial input and spawn relevant events monome_read_serial(); break; case kEventMonomeRefresh : // refresh monome device from led state buffer monome_grid_refresh(); break; //-------------------------------------- case kEventFtdiConnect: // perform setup tasks for new ftdi device connection. // won't work if called from an interrupt. ftdi_setup(); break; case kEventFtdiDisconnect: break; case kEventHidConnect : break; case kEventHidDisconnect : break; case kEventMidiConnect : break; case kEventMidiDisconnect : break; case kEventEncoder0 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventEncoder0"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); dac_inc(0, scale_knob_value(e.eventData)); break; case kEventEncoder1 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventEncoder1"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); dac_inc(1, scale_knob_value(e.eventData)); break; case kEventEncoder2 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventEncoder2"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); dac_inc(2, scale_knob_value(e.eventData)); break; case kEventEncoder3 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventEncoder3"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); dac_inc(3, scale_knob_value(e.eventData)); break; case kEventSwitch0 : // fn print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch0"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventSwitch1 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch1"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventSwitch2 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch2"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventSwitch3 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch3"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventSwitch4 : // mode print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch4"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventSwitch5 : // power print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch5"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventSwitch6 : // foot print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch6"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventSwitch7 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventSwitch7"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventAdc0 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventAdc0"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventAdc1 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventAdc1"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventAdc2 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventAdc2"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventAdc3 : print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventAdc3"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); break; case kEventMonomeGridKey: print_dbg("\r\n ( 0x"); print_dbg_hex((u32)tcTicks); print_dbg(" ) kEventMonomeGridKey"); print_dbg(" : 0x"); print_dbg_hex((u32) e.eventData); handle_monome_grid_key((u32)e.eventData); break; default: // (*appEventHandler)(&e); break; } // event switch } // startup } // got event }
int main(int argc, char *argv[]) { ssl_init(); OrderBook order_book(3); Orders<1000> orders; auto poller = Poller::create(); Url diff_url("wss://ws.pusherapp.com/app/de504dc5763aeef9ff52?protocol=5"); auto diff_socket = create_tcp_socket(diff_url.host(), 80); diff_socket->set_callbacks<DiffLogic<1000>>(std::ref(diff_url), std::ref(orders)); poller->update_socket(diff_socket, EPOLLIN | EPOLLOUT); Url order_book_url("https://www.bitstamp.net/api/order_book"); auto order_book_socket = create_tcp_socket(order_book_url.host(), 443); order_book_socket->set_callbacks<ReceiveOrderBookLogic>(std::ref(order_book_url), std::ref(order_book)); poller->update_socket(order_book_socket, EPOLLOUT | EPOLLIN); //---------------------- std::shared_ptr<Order> order; Timer reconect_timer; Timer update_timer; Timer stop_timer; stop_timer.reset(); uint64_t last_time = 0; const uint64_t RECONECT_INTERVAL = 20; bool order_book_ready = false; for (;;) { poller->poll(); for (;;) { auto event = poller->get_next_event(); if (!event.action) break; try { if (event.action & PollerEvent::READ) event.socket->read(); if (event.action & PollerEvent::WRITE) event.socket->write(); if (event.action & PollerEvent::CLOSE) event.socket->close(event.close_reason); } catch (const std::exception & e) { std::cerr << "Exception in callback: " << e.what() << std::endl << "Closing socket." << std::endl; event.socket->close(); } } if (!order_book) { if (!order_book_socket.get() && reconect_timer.elapsed_seconds() > RECONECT_INTERVAL) { std::cerr << "creating new order_book_socket" << std::endl; order_book_socket = create_tcp_socket(order_book_url.host(), 443); order_book_socket->set_callbacks<ReceiveOrderBookLogic>(std::ref(order_book_url), std::ref(order_book)); poller->update_socket(order_book_socket, EPOLLOUT | EPOLLIN); } continue; } if (!order_book_ready) { uint64_t first_diff_timestamp = orders.get_first_timestamp(); uint64_t last_book_timestamp = order_book.get_last_timestamp(); std::cerr << first_diff_timestamp << "/" << last_book_timestamp << std::endl; if (last_book_timestamp < first_diff_timestamp) { order_book.clear(); reconect_timer.reset(); order_book_socket.reset(); continue; } order_book_ready = true; } while (order = orders.get_order()) order_book.add(*order); if (update_timer.elapsed_seconds() != last_time) { last_time = update_timer.elapsed_seconds(); order_book.print(); } } ssl_destroy(); return 0; }
/** * @brief * simulate the minimum amount of a resource list * for an event list until a point in time. The * comparison we are simulating the minimum for is * (resources_available.foo - resources_assigned.foo) * The minimum is simulated by holding resources_available * constant and maximizing the resources_assigned value * * @note * This function only simulates START and END events. If at some * point in the future we start simulating events such as * qmgr -c 's s resources_available.ncpus + =5' this function will * will have to be revisited. * * @param[in] reslist - resource list to simulate * @param[in] end - end time * @param[in] calendar - calendar to simulate * @param[in] incl_arr - only use events for resresvs in this array (can be NULL) * @param[in] exclude - job/resv to ignore (possibly NULL) * * @return static pointer to amount of resources available during * @retval the entire length from now to end * @retval NULL : on error * * @par MT-safe: No */ schd_resource * simulate_resmin(schd_resource *reslist, time_t end, event_list *calendar, resource_resv **incl_arr, resource_resv *exclude) { static schd_resource *retres = NULL; /* return pointer */ schd_resource *cur_res; schd_resource *cur_resmin; resource_req *req; schd_resource *res; schd_resource *resmin = NULL; timed_event *te; resource_resv *resresv; unsigned int event_mask = (TIMED_RUN_EVENT | TIMED_END_EVENT); if (reslist == NULL) return NULL; /* if there is no calendar, then there is nothing to do */ if (calendar == NULL) return reslist; /* If there are no run events in the calendar between now and the end time * then there is nothing to do. Nothing will reduce resources (only increase) */ if (exists_run_event(calendar, end) == 0) return reslist; if (retres != NULL) { free_resource_list(retres); retres = NULL; } if ((res = dup_resource_list(reslist)) == NULL) return NULL; if ((resmin = dup_resource_list(reslist)) == NULL) { free_resource_list(res); return NULL; } te = get_next_event(calendar); for (te = find_init_timed_event(te, IGNORE_DISABLED_EVENTS, event_mask); te != NULL && (end == 0 || te->event_time < end); te = find_next_timed_event(te, IGNORE_DISABLED_EVENTS, event_mask)) { resresv = (resource_resv*) te->event_ptr; if (incl_arr == NULL || find_resource_resv_by_rank(incl_arr, resresv->rank) !=NULL) { if (resresv != exclude) { req = resresv->resreq; for (; req != NULL; req = req->next) { if (req->type.is_consumable) { cur_res = find_alloc_resource(res, req->def); if (cur_res == NULL) { free_resource_list(res); free_resource_list(resmin); return NULL; } if (te->event_type == TIMED_RUN_EVENT) cur_res->assigned += req->amount; else cur_res->assigned -= req->amount; cur_resmin = find_alloc_resource(resmin, req->def); if (cur_resmin == NULL) { free_resource_list(res); free_resource_list(resmin); return NULL; } if (cur_res->assigned > cur_resmin->assigned) cur_resmin->assigned = cur_res->assigned; } } } } } free_resource_list(res); retres = resmin; return retres; }
static INLINE void send_delta_events(part_evtlist_t *evlist, memsize_t cur_size, memsize_t prev_size, bool (*compare_func)(memsize_t delta, memsize_t last_sz, memsize_t cur_sz)) { elistdata_t eld_p; mempart_evt_t *reg_event = get_first_event(evlist, &eld_p); while (reg_event != NULL) { struct evt_info_s *evt = ®_event->evt_reg; if (reg_event->onlist == &evlist->active) { memsize_t *delta_p = GET_DELTA_P(evt); CRASHCHECK(delta_p == NULL); initial_delta_conditions_check(reg_event, prev_size, (void *)compare_func); /* if this event has been deactivated, don't send it */ if (evt->flags & evtflags_DEACTIVATE) { deactivate_event(evlist, (part_evt_t *)reg_event); } /* check for event send conditions */ else if ((reg_event->evt_dest.rcvid > 0) && ((compare_func == NULL) || (compare_func(*delta_p, reg_event->evt_data.size, cur_size) == bool_t_TRUE))) { int r; struct sigevent se = evt->sig; // make a local copy /* * if the caller has set evtflags_SIGEV_FLAG_SIGINFO, we * can return some useful information */ if (evt->flags & evtflags_SIGEV_FLAG_SIGINFO) { /* * if the 'cur_size' is too large to fit in the sival_int field * then send back UINT_MAX. This otherwise illegal size value * (because UINT_MAX & (__PAGESIZE - 1) != 0) will be an indication * to the event receiver that o information was provided and * that they need to request the current size if they need it */ if (cur_size > UINT_MAX) { se.sigev_value.sival_int = UINT_MAX; } else { se.sigev_value.sival_int = (_Uint32t)cur_size; } } r = apm_deliver_event(®_event->evt_dest, &se); if (r == EOK) reg_event->undeliverable_count = 0; else if (r == ESRCH) ++reg_event->undeliverable_count; if ((reg_event->undeliverable_count > ORPHAN_RETRY_COUNT) || (!(evt->flags & evtflags_REARM))) { /* remove the event from the list */ deactivate_event(evlist, (part_evt_t *)reg_event); } else { reg_event->evt_data.size = cur_size; } } } reg_event = get_next_event(evlist, reg_event, &eld_p); } }