t_nodes perft(struct t_board *board, int depth) {
struct t_move_list move_list[1];
struct t_undo undo[1];
t_nodes total_nodes = 0;
t_nodes move_nodes = 0;
unsigned long start = time_now();
int i;
if (board->in_check)
generate_evade_check(board, move_list);
else
generate_moves(board, move_list);
for (i = move_list->count - 1; i >= 0; i--) {
if (make_move(board, move_list->pinned_pieces, move_list->move[i], undo)) {
move_nodes = 0;
if (depth > 1)
move_nodes += do_perft(board, depth - 1);
printf(move_as_str(move_list->move[i]));
printf(" = %u\n", move_nodes);
unmake_move(board, undo);
total_nodes += move_nodes;
}
}
unsigned long finish = time_now();
if (finish == start)
printf("Total Nodes: %I64d\n", total_nodes);
else
printf("Total Nodes: %I64d in %d milliseconds = nps %I64d\n", total_nodes, finish - start, 1000 * total_nodes / (finish - start));
return total_nodes;
}
void
GroupNodeImpl::handle_whisper(const std::string& uuid, zmsg_t* zmsg)
{
MessagePtr msg(new Message);
msg->header.stamp = time_now();
msg->header.context = uuid;
msg->header.src_uuid = uuid;
char* a_str = zmsg_popstr(zmsg);
msg->msg = a_str;
free(a_str);
auto range = whisper_handlers_.equal_range("w");
std::for_each(range.first, range.second,
[&](handlers_t::value_type& c){c.second.first(msg.get(), c.second.second);});
}
// returns true if our external IP changed
bool ip_voter::maybe_rotate()
{
ptime now = time_now();
// if we have more than or equal to 50 votes,
// we rotate. Also, if it's been more than 5 minutes
// and we have at least one vote, we also rotate.
// this is the inverse condition, since this is the case
// were we exit, without rotating
if (m_total_votes < 50
&& (now - m_last_rotate < minutes(5) || m_total_votes == 0)
&& m_valid_external)
return false;
// this shouldn't really happen if we have at least one
// vote.
if (m_external_addresses.empty()) return false;
// if there's just one vote, go with that
std::vector<external_ip_t>::iterator i;
if (m_external_addresses.size() == 1)
{
// avoid flapping. We need more votes to change our mind on the
// external IP
if (m_external_addresses[0].num_votes < 2) return false;
}
else
{
// find the top two votes.
std::partial_sort(m_external_addresses.begin()
, m_external_addresses.begin() + 2, m_external_addresses.end());
// if we don't have enough of a majority voting for the winning
// IP, don't rotate. This avoids flapping
if (m_external_addresses[0].num_votes * 2 / 3 <= m_external_addresses[1].num_votes)
return false;
}
i = m_external_addresses.begin();
bool ret = m_external_address != i->addr;
m_external_address = i->addr;
m_external_address_voters.clear();
m_total_votes = 0;
m_external_addresses.clear();
m_last_rotate = now;
m_valid_external = true;
return ret;
}
static struct command_result *waitsendpay_error(struct command *cmd,
const char *buf,
const jsmntok_t *error,
struct pay_command *pc)
{
const jsmntok_t *codetok, *scidtok, *dirtok;
int code;
attempt_failed_tok(pc, "waitsendpay", buf, error);
codetok = json_get_member(buf, error, "code");
if (!json_to_int(buf, codetok, &code))
plugin_err("waitsendpay error gave no 'code'? '%.*s'",
error->end - error->start, buf + error->start);
/* FIXME: Handle PAY_UNPARSEABLE_ONION! */
/* Many error codes are final. */
if (code != PAY_TRY_OTHER_ROUTE) {
return forward_error(cmd, buf, error, pc);
}
scidtok = json_delve(buf, error, ".data.erring_channel");
if (!scidtok)
plugin_err("waitsendpay error no erring_channel '%.*s'",
error->end - error->start, buf + error->start);
dirtok = json_delve(buf, error, ".data.erring_direction");
if (!dirtok)
plugin_err("waitsendpay error no erring_direction '%.*s'",
error->end - error->start, buf + error->start);
if (time_after(time_now(), pc->stoptime)) {
return waitsendpay_expired(cmd, pc);
}
/* If failure is in routehint part, try next one */
if (channel_in_routehint(pc->current_routehint, buf, scidtok))
return next_routehint(cmd, pc);
/* Otherwise, add erring channel to exclusion list. */
tal_arr_expand(&pc->excludes,
tal_fmt(pc->excludes, "%.*s/%c",
scidtok->end - scidtok->start,
buf + scidtok->start,
buf[dirtok->start]));
/* Try again. */
return start_pay_attempt(cmd, pc, "Excluded channel %s",
pc->excludes[tal_count(pc->excludes)-1]);
}
MODULE write_body_header (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
smtp_msg = tcb-> message; /* only for readability */
*strout = '\0'; /* clears out buffer */
/* Set the date and time of the message. */
xstrcat ( strout, "Date: ", encode_mime_time (date_now (), time_now ()),
" \r\n", NULL);
replacechrswith (smtp_msg-> dest_uids, ";", ',');
xstrcat (strout, "To: ", smtp_msg-> dest_uids, "\r\n", NULL);
if ( strstr( smtp_msg-> sender_uid, "<" ) != NULL &&
strstr( smtp_msg-> sender_uid, ">" ) != NULL )
xstrcat (strout, "Reply-To:", smtp_msg-> sender_uid, "\r\n", NULL);
else
xstrcat (strout, "Reply-To:<", smtp_msg-> sender_uid, ">\r\n", NULL);
xstrcat (strout, "Sender:", smtp_msg-> sender_uid, "\r\n", NULL);
xstrcat (strout, "From:", smtp_msg-> sender_uid, "\r\n", NULL);
xstrcat (strout, "X-Mailer: sflmail function\r\n", NULL);
/* Set the mime version. */
xstrcat (strout, "MIME-Version: 1.0\r\n",
"Content-Type: Multipart/Mixed; boundary=\"",
tcb-> message_boundary,
"\"\r\n",
NULL);
/* Send the subject and message body. */
ASSERT (smtp_msg-> subject != NULL); /* XXX I'm not too sure */
xstrcat (strout, "Subject:", smtp_msg-> subject, "\r\n\r\n", NULL);
/* Send the plain text body header */
xstrcat (strout, tcb-> plain_text_body_header, NULL);
send_smtsock_write(
&sockq,
0, /* Timeout in seconds, zero = none */
tcb-> sock_handle, /* Socket to write to */
(word) strlen (strout), /* Amount of data to write */
strout, /* Block of data to write */
FALSE, /* Whether to always reply */
(void *) SOCK_TAG_WRITE); /* User-defined request tag */
TRACE_SMTP (strout);
}
void timeout_handler::set_timeout(int completion_timeout, int read_timeout)
{
m_completion_timeout = completion_timeout;
m_read_timeout = read_timeout;
m_start_time = m_read_time = time_now();
if (m_abort) return;
int timeout = (std::min)(
m_read_timeout, (std::min)(m_completion_timeout, m_read_timeout));
error_code ec;
m_timeout.expires_at(m_read_time + seconds(timeout), ec);
m_timeout.async_wait(bind(
&timeout_handler::timeout_callback, self(), _1));
}
/** @brief adjust the time when a timer expires */
int tmr_adjust(tmr_t *timer, tmr_time_t t, uint32_t param, tmr_time_t r)
{
int i;
for (i = 0; i < ti; i++)
if (timer == timers[i])
break;
if (i >= ti)
return -1;
timer->expire = time_now() + t;
timer->restart = r;
timer->param = param;
cycles = z80_cc;
return 0;
}
bandwidth_manager::bandwidth_manager(int channel
#ifdef TORRENT_VERBOSE_BANDWIDTH_LIMIT
, bool log = false
#endif
)
: m_queued_bytes(0)
, m_channel(channel)
, m_abort(false)
{
#ifdef TORRENT_VERBOSE_BANDWIDTH_LIMIT
if (log)
m_log.open("bandwidth_limiter.log", std::ios::trunc);
m_start = time_now();
#endif
}
/**
* Inspect head of queue and wakeup a worker now or set alarm.
* Caller SHOULD hold schedule->schedule_lock. Failing to do so
* could possibly cause a thread to miss the wakeup.
*/
static void
set_alarm(schedule_type* schedule)
{
time_t now = time_now();
task_type *task = get_first_task(schedule);
if (!task || task->when == -1) {
ods_log_debug("[%s] no alarm set", schedule_str);
} else if (task->when == 0 || task->when <= now) {
ods_log_debug("[%s] signal now", schedule_str);
pthread_cond_signal(&schedule->schedule_cond);
} else {
ods_log_debug("[%s] SIGALRM set", schedule_str);
alarm(task->when - now);
}
}
Timer * Timer_set(double delay, TimerFn *fn, unsigned long data) {
// Get 'now'.
double now = time_now();
Timer *timer = NULL;
timer = ALLOCATE(Timer);
if(!timer) goto exit;
// Add delay to now to get expiry time.
timer->expiry = now + delay;
timer->fn = fn;
timer->data = data;
Timer_add(timer);
exit:
return timer;
}
void do_log_debug(const char *file, int line, char *format, ...) {
va_list ap;
va_start(ap, format);
char *timestamp = time_now();
char new_format[strlen(timestamp) +
strlen(format) +
strlen(file) +
5 + // (reasonable length for 'line')
6 + // space for PID
+ 23];
sprintf(new_format, "[%d] [%s] [DEBUG] %s:%d: %s\n", getpid(), timestamp, file, line, format);
vfprintf(RS_LOG_FILE, new_format, ap);
va_end(ap);
fflush(RS_LOG_FILE);
}
/** @brief allocate a new timer */
tmr_t *tmr_alloc(void (*callback)(uint32_t), tmr_time_t t, uint32_t param, tmr_time_t r)
{
tmr_t *timer;
if (ti >= MAX_TMR)
return NULL;
timers[ti] = timer = calloc(1, sizeof(tmr_t));
if (NULL == timer)
return NULL;
ti++;
timer->expire = time_now() + t;
timer->restart = r;
timer->param = param;
timer->callback = callback;
cycles = z80_cc;
return timer;
}
void udp_readcb(struct bufferevent *bev, void *c) {
UNUSED(c);
char buf[3] = {0};
struct evbuffer *input = bufferevent_get_input(bev);
while (evbuffer_get_length(input) >= 3) {
bufferevent_read(bev, buf, 3);
if (!strncmp(buf, "ACK", 3)) {
udp_last_ack = time_now();
if (!connection_valid) {
connection_valid = true;
log_notice("Connected to %s", config_get_remote_hostname());
}
}
}
return;
}
void wspace_last_mc_marker_work( Conclctor *last_marker ) {
GC *gc = last_marker->gc;
if( gc->gc_concurrent_status != GC_CON_TRACING )
return;
gc_con_update_stat_after_marking(gc); //calculate marked size
//just debugging
Con_Collection_Statistics *con_collection_stat = gc_ms_get_con_collection_stat((GC_MS*)gc);
con_collection_stat->marking_end_time = time_now();
int64 con_marking_time = con_collection_stat->marking_end_time - con_collection_stat->marking_start_time;
INFO2("gc.scheduler", "[MOSTLY_CON] con marking time=" << con_marking_time << " us");
state_transformation( gc, GC_CON_TRACING, GC_CON_TRACE_DONE );
//INFO2("gc.con.info", "<new state 3> first marking thread finished its job, GC is waiting for all the marking threads finish, current marker num is [" << gc->num_active_markers << "]" );
}
void
dp_run(struct datapath *dp) {
time_t now = time_now();
struct remote *r, *rn;
size_t i;
if (now != dp->last_timeout) {
dp->last_timeout = now;
meter_table_add_tokens(dp->meters);
pipeline_timeout(dp->pipeline);
}
poll_timer_wait(1000);
dp_ports_run(dp);
/* Talk to remotes. */
LIST_FOR_EACH_SAFE (r, rn, struct remote, node, &dp->remotes) {
remote_run(dp, r);
}
for (i = 0; i < dp->n_listeners; ) {
struct pvconn *pvconn = dp->listeners[i];
struct vconn *new_vconn;
int retval = pvconn_accept(pvconn, OFP_VERSION, &new_vconn);
if (!retval) {
struct rconn * rconn_aux = NULL;
if (dp->n_listeners_aux && dp->listeners_aux[i] != NULL) {
struct pvconn *pvconn_aux = dp->listeners_aux[i];
struct vconn *new_vconn_aux;
int retval_aux = pvconn_accept(pvconn_aux, OFP_VERSION, &new_vconn_aux);
if (!retval_aux)
rconn_aux = rconn_new_from_vconn("passive_aux", new_vconn_aux);
}
remote_create(dp, rconn_new_from_vconn("passive", new_vconn), rconn_aux);
}
else if (retval != EAGAIN) {
VLOG_WARN_RL(LOG_MODULE, &rl, "accept failed (%s)", strerror(retval));
dp->listeners[i] = dp->listeners[--dp->n_listeners];
if (dp->n_listeners_aux) {
dp->listeners_aux[i] = dp->listeners_aux[--dp->n_listeners_aux];
}
continue;
}
i++;
}
}
static int tcp_wait_for_events(tcp_context_t *tcp)
{
/* Wait for events. */
fdset_t *set = &tcp->set;
int nfds = poll(set->pfd, set->n, TCP_SWEEP_INTERVAL * 1000);
/* Mark the time of last poll call. */
time_now(&tcp->last_poll_time);
/* Process events. */
unsigned i = 0;
while (nfds > 0 && i < set->n) {
/* Terminate faulty connections. */
int fd = set->pfd[i].fd;
/* Active sockets. */
if (set->pfd[i].revents & POLLIN) {
--nfds; /* One less active event. */
/* Indexes <0, client_threshold) are master sockets. */
if (i < tcp->client_threshold) {
/* Faulty master sockets shall be sorted later. */
(void) tcp_event_accept(tcp, i);
} else {
if (tcp_event_serve(tcp, i) != KNOT_EOK) {
fdset_remove(set, i);
close(fd);
continue; /* Stay on the same index. */
}
}
}
if (set->pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL)) {
--nfds; /* One less active event. */
fdset_remove(set, i);
close(fd);
continue; /* Stay on the same index. */
}
/* Next socket. */
++i;
}
return nfds;
}
//called by the marker when it finishes
void gc_con_update_stat_after_marking(GC *gc)
{
POINTER_SIZE_INT num_live_obj = 0;
POINTER_SIZE_INT size_live_obj = 0;
POINTER_SIZE_INT num_dirty_obj_traced = 0;
unsigned int num_conclctors = gc->num_conclctors;
for( unsigned int i=0; i<num_conclctors; i++ ) {
Conclctor* conclctor = gc->conclctors[i];
if( conclctor->role != CONCLCTOR_ROLE_MARKER )
continue;
num_live_obj += conclctor->live_obj_num;
size_live_obj += conclctor->live_obj_size;
num_dirty_obj_traced += conclctor->num_dirty_slots_traced;
conclctor->live_obj_num = 0;
conclctor->live_obj_size = 0;
conclctor->num_dirty_slots_traced = 0;
}
unsigned int write_barrier_marked_size = gc_get_mutator_write_barrier_marked_size(gc);
Con_Collection_Statistics * con_collection_stat = gc_ms_get_con_collection_stat((GC_MS*)gc);
con_collection_stat->live_size_marked = size_live_obj + write_barrier_marked_size;
//INFO2("gc.con.scheduler", "[Mark Finish] live_marked_size: "<<con_collection_stat->live_size_marked<<" bytes");
/*statistics information update (marking_end_time, trace_rate) */
con_collection_stat->marking_end_time = time_now();
int64 marking_time = (unsigned int)(con_collection_stat->marking_end_time - con_collection_stat->marking_start_time);
unsigned int heap_size =
con_collection_stat->surviving_size_at_gc_end +
gc_get_mutator_new_obj_size(gc);
con_collection_stat->trace_rate = heap_size/trans_time_unit(marking_time);
/*
//statistics just for debugging
unsigned int marker_num = gc_get_conclcor_num(gc, CONCLCTOR_ROLE_MARKER);
float heap_used_rate = (float)heap_size/gc->committed_heap_size;
unsigned int new_obj_size_marking = gc_get_mutator_new_obj_size(gc) - con_collection_stat->alloc_size_before_alloc_live;
unsigned int alloc_rate_marking = new_obj_size_marking/trans_time_unit(con_collection_stat->marking_end_time - con_collection_stat->marking_start_time);
INFO2("gc.con.scheduler", "[Mark Finish] tracing time=" <<marking_time<<" us, trace rate=" << con_collection_stat->trace_rate<<"b/ms, current heap used="<<heap_used_rate );
INFO2("gc.con.scheduler", "[Mark Finish] marker num="<<marker_num << ", alloc factor=" << (float)alloc_rate_marking/con_collection_stat->alloc_rate);
*/
}
/** @brief reset the time when a timer expires */
int tmr_reset(tmr_t *timer, tmr_time_t t)
{
int i;
for (i = 0; i < ti; i++)
if (timer == timers[i])
break;
if (i >= ti)
return -1;
if (time_never == t) {
timer->expire = time_never;
} else {
timer->expire = time_now() + t;
}
cycles = z80_cc;
return 0;
}
/*****************************************************************************
函 数 名 : conf_dbg_dump
功能描述 : dump数据块的数据
参数列表 : const void *buffer
int buf_len
返 回 值 : void
*****************************************************************************/
void conf_dbg_dump(const void *buffer, int buf_len)
{
int i;
u8_t *ptr;
char str[17] = {0};
FILE *out;
asc_time_t now;
if ((dbg_level < DBG_DEBUG) || (buf_len == 0)) {
return;
}
out = (log_file != NULL) ? log_file : stderr;
pthread_mutex_lock(&out_mutex);
fprintf(out, "%s [DEBUG] Buffer length is %d.\n", time_now(&now), buf_len);
for (i = 0, ptr = (u8_t*)buffer; (i < buf_len) || ((i & 0xf) != 0); ++i) {
if ((i & 0xf) == 0) {
fprintf(out, " [%04d]", i);
} else if ((i & 0x7) == 0) {
fprintf(out, " ");
}
if (i < buf_len) {
fprintf(out, " %02x", (u8_t)(ptr[i]));
if ((0x20 <= ptr[i]) && (ptr[i] <= 0x7e)) {
str[i & 0xf] = ptr[i];
} else {
str[i & 0xf] = '.';
}
} else {
fprintf(out, " ");
str[i & 0xf] = 0;
}
if ((i & 0xf) == 0xf) {
fprintf(out, " | %s\n", str);
}
}
pthread_mutex_unlock(&out_mutex);
return;
}
task_type *
enforce_task(engine_type *engine, bool all)
{
task_id what_id;
const char *what = "enforce";
const char *who = "next zone";
struct enf_task_ctx *ctx = &enforcer_context;
if (!ctx) {
ods_log_error("Malloc failure, enforce task not scheduled");
return NULL;
}
ctx->engine = engine;
ctx->enforce_all = all;
what_id = task_register(what, module_str, enforce_task_perform);
return task_create(what_id, time_now(), who, what, ctx,
enforce_task_clean_ctx);
}
void
fail_open_start(struct secchan *secchan, const struct settings *s,
struct switch_status *ss,
struct rconn *local_rconn, struct rconn *remote_rconn)
{
struct fail_open_data *fail_open = xmalloc(sizeof *fail_open);
fail_open->s = s;
fail_open->local_rconn = local_rconn;
fail_open->remote_rconn = remote_rconn;
fail_open->lswitch = NULL;
fail_open->boot_deadline = time_now() + s->probe_interval * 3;
if (s->enable_stp) {
fail_open->boot_deadline += STP_EXTRA_BOOT_TIME;
}
switch_status_register_category(ss, "fail-open",
fail_open_status_cb, fail_open);
add_hook(secchan, &fail_open_hook_class, fail_open);
}
//return push queue count or J_ERR
int cevents_poll(cevents *cevts, msec_t ms) {
int rs, i, count = 0, flag = 0;
cevent_fired *fired;
cevent *evt;
if(cevts == NULL) {
ERROR("can't be happend\n");
abort();
}
LOCK(&cevts->lock);
rs = cevents_poll_impl(cevts, ms);
UNLOCK(&cevts->lock);
time_now(&cevts->poll_sec, &cevts->poll_ms);
if(rs > 0) {
for(i = 0; i < rs; i++) {
fired = cevts->fired + i;
evt = cevts->events + fired->fd;
if(!evt->mask)
continue;
if(evt->mask & CEV_PERSIST) {
fired->mask |= CEV_PERSIST;
if(evt->mask && (fired->mask & CEV_READ)) {
//just send read event to event queue.
if(evt->read_proc(cevts, fired->fd, evt->priv, fired->mask) == 0) {
cevents_del_event(cevts, fired->fd, CEV_READ);
cevents_push_fired(cevts, clone_cevent_fired(cevts, fired));
count++;
}
}
if(evt->mask && (fired->mask & CEV_WRITE)) {
evt->write_proc(cevts, fired->fd, evt->priv, fired->mask);
}
} else {
//unbind the events.
cevents_del_event(cevts, fired->fd, fired->mask);
cevents_push_fired(cevts, clone_cevent_fired(cevts, fired));
count++;
}
}
}
//must sleep, let other thread grant the lock. maybe removed when the time event added.
usleep(2);
return count;
}
static void
age_flow_entries( void *user_data ) {
const uint8_t table_id = *( uint8_t * ) user_data;
assert( valid_table_id( table_id ) );
if ( !lock_pipeline() ) {
return;
}
struct timespec now = { 0, 0 };
time_now( &now );
foreach_flow_entry( table_id, age_flow_entries_walker, &now );
if ( !unlock_pipeline() ) {
return;
}
}
static void test_time_whms(void)
{
a_time t_ = time_clone(time_now()), *t = &t_;
#define X(wday, hour, min, sec) do { \
time_whms(t, wday, hour, min, sec); \
time_t time = time_time(t); \
a_time t2; \
time_init(&t2, time); \
const struct tm *tm = time_tm(&t2); \
if (tm->tm_wday != wday) TFAILF(" %s", "wday mismatch"); \
if (tm->tm_sec != sec) TFAILF(" sec %d vs %d", tm->tm_sec, sec); \
if (tm->tm_min != min) TFAILF(" min %d vs %d", tm->tm_min, min); \
if (tm->tm_hour != hour) TFAILF(" hour %d vs %d", tm->tm_hour, hour); \
} while_0
X(0, 0, 0, 0);
X(1, 1, 1, 1);
X(6, 23, 59, 59);
#undef X
}
/* Write the time, client address, prefix, and string s to stderr atomically.
* s should end with a \n */
void
logline(struct in_addr *client, char *prefix, char *s)
{
double now = time_now();
char addr[INET_ADDRSTRLEN];
if (client) {
#ifdef _WIN32
strcpy(addr, inet_ntoa(*client));
#else
inet_ntop(AF_INET, client, addr, sizeof(addr));
#endif
} else {
addr[0] = '\0';
}
pthread_mutex_lock(&log_lock);
fprintf(stderr, "%s%15s %9.3f: %s", prefix, addr, now - start_time, s);
pthread_mutex_unlock(&log_lock);
}
int fileop_save_by_name( char *file_name )
{
FILE *fp;
char name[ MAX_TOKEN_LENGTH ];
char s[80];
strcpy( name, file_name );
file_handle_path( name, MAX_TOKEN_LENGTH );
if ( NULL == (fp = fopen( name, "w" )) )
{
cprintf( ERROR, CONT, "fail to save file \"%s\"\n", name );
return ( ERROR );
}
fprintf( fp, "###\n" );
fprintf( fp, "### CaFE file made by \"save\" command.\n" );
fprintf( fp, "### --- %s ---\n", version_string( s ) );
time_now( s );
fprintf( fp, "###\n### ### saved : %s\n###\n", s );
fprintf( fp, "\n\n### user stack operation functions\n\n" );
fprintf( fp, "0 >newlydefined_{\n" );
fprintf( fp, "0 >newlydefined_k}\n\n" );
fprintf( fp, "fisdef { if z :@ :{ =new =target ; 1 >newlydefined_{ ; pop\n\n" );
fprintf( fp, "fisdef k} if z :@ :k} =parent =target ; 1 >newlydefined_k} ; pop\n\n\n" );
fprintf( fp, "### content of stack\n\n" );
save_stack( NULL, fp );
fprintf( fp, "\n\n### content of stack end\n\n" );
fprintf( fp, "<newlydefined_{ if t :@ forget { ; pop\n" );
fprintf( fp, "<newlydefined_k} if t :@ forget k} ; pop\n" );
fclose( fp );
return ( NO_ERROR );
}
/** Set the process real-time timer to go off at a given expiry time.
* The timer will not be set to go off in less than 10 ms
* (even if the expiry time is sooner, or in the past).
*
* @param expiry time (in seconds)
* @return 0 on success, error code otherwise
*/
static int itimer_set(double expiry) {
struct itimerval val = {};
struct itimerval old = {};
double now, delay;
int err = 0;
if(expiry == 0.0) {
val.it_value.tv_sec = 0;
val.it_value.tv_usec = 0;
} else {
now = time_now();
delay = expiry - now;
if(delay < 0.01) delay = 0.01;
val.it_value.tv_sec = (long)delay;
val.it_value.tv_usec = (long)((delay - (double)(long)delay) * 1.0e6);
}
err = setitimer(ITIMER_REAL, &val, &old);
return err;
}
task_type*
schedule_pop_task(schedule_type* schedule)
{
time_t now = time_now();
task_type* task;
pthread_mutex_lock(&schedule->schedule_lock);
task = get_first_task(schedule);
if (!task || (!task->flush && (task->when == -1 || task->when > now))) {
/* nothing to do now, sleep and wait for signal */
pthread_cond_wait(&schedule->schedule_cond,
&schedule->schedule_lock);
task = NULL;
} else {
task = pop_first_task(schedule);
}
pthread_mutex_unlock(&schedule->schedule_lock);
return task;
}
int
schedule_flush_type(schedule_type* schedule, task_id id)
{
ldns_rbnode_t *node, *nextnode;
int nflushed = 0;
ods_log_debug("[%s] flush task", schedule_str);
if (!schedule || !schedule->tasks) return 0;
pthread_mutex_lock(&schedule->schedule_lock);
node = ldns_rbtree_first(schedule->tasks);
while (node && node != LDNS_RBTREE_NULL) {
nextnode = ldns_rbtree_next(node);
if (node->data && ((task_type*)node->data)->what == id) {
/* Merely setting flush is not enough. We must set it
* to the front of the queue as well. */
node = ldns_rbtree_delete(schedule->tasks, node->data);
if (!node) break; /* stange, bail out */
if (node->data) { /* task */
((task_type*)node->data)->flush = 1;
/* This is important for our tests only. If a task is
* set to flush it should not affect the current time.
* Otherwise timeleap will advance time. */
((task_type*)node->data)->when = time_now();
if (!ldns_rbtree_insert(schedule->tasks, node)) {
ods_log_crit("[%s] Could not reschedule task "
"after flush. A task has been lost!",
schedule_str);
free(node);
/* Do not free node->data it is still in use
* by the other rbtree. */
break;
}
nflushed++;
}
}
node = nextnode;
}
/* wakeup! work to do! */
pthread_cond_signal(&schedule->schedule_cond);
pthread_mutex_unlock(&schedule->schedule_lock);
return nflushed;
}
static unsigned int gc_con_heap_full_otf( GC *gc )
{
unsigned int partial_type; //for time measuring and debugging
int disable_count = vm_suspend_all_threads();
Con_Collection_Statistics *con_collection_stat = gc_ms_get_con_collection_stat((GC_MS*)gc);
con_collection_stat->pause_start_time = time_now();
switch(gc->gc_concurrent_status) {
case GC_CON_START_MARKERS :
case GC_CON_TRACING :
case GC_CON_TRACE_DONE :
partial_type = GC_PARTIAL_PMSS;
gc_partial_con_PMSS(gc);
break;
case GC_CON_BEFORE_SWEEP : // only when current sweep is set to false
partial_type = GC_PARTIAL_CMSS;
gc_partial_con_CMSS(gc);
break;
case GC_CON_SWEEPING :
case GC_CON_SWEEP_DONE :
partial_type = GC_PARTIAL_CMPS;
gc_partial_con_CMPS(gc);
break;
case GC_CON_BEFORE_FINISH : //heap can be exhausted when sweeping finishes, very rare
partial_type = GC_PARTIAL_FCSR;
gc_merge_free_list_global(gc);
gc_reset_after_con_collection(gc);
set_con_nil(gc);
break;
case GC_CON_RESET :
case GC_CON_NIL :
case GC_CON_STW_ENUM :
/*do nothing, if still in gc_con_reset, will wait to finish after resuming. this case happens rarely*/
partial_type = GC_PARTIAL_FCSR;
break;
/* other state is illegal here */
default:
INFO2("gc.con.info", "illegal state when the heap is out [" << gc->gc_concurrent_status << "]");
RAISE_ERROR;
}
vm_resume_all_threads(disable_count);
return partial_type;
}
