static cairo_test_status_t
record_replay (cairo_t *cr,
cairo_t *(*func)(cairo_t *,
cairo_surface_t *(*pattern)(cairo_t *)),
cairo_surface_t *(*pattern)(cairo_t *),
int width, int height)
{
cairo_surface_t *surface;
int x, y;
surface = record_get (func (record_create (cr), pattern));
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface (cr, surface, 0, 0);
cairo_surface_destroy (surface);
cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_NONE);
for (y = 0; y < height; y += 2) {
for (x = 0; x < width; x += 2) {
cairo_rectangle (cr, x, y, 2, 2);
cairo_clip (cr);
cairo_paint (cr);
cairo_reset_clip (cr);
}
}
return CAIRO_TEST_SUCCESS;
}
alarm_handle_t alarm_alarm(alarm_handler_t handler, env_t env) {
alarm_handle_t h = record_create(alarm_handle_t, h) ;
h->upcall = handler ;
h->env = env ;
h->count = 0 ;
h->live = TRUE ;
return h ;
}
/* bool create_record(id, table_name, sid, o) */
static int cc_create_record(lua_State* L)
{
int id;
int64_t sid;
size_t len;
const char* data;
const char* table_name;
bool retcode;
database_handler_t* database_handler;
worker_handler_t* handler = find_handler_by_stack(L);
int args = lua_gettop(L);
if (args < 4)
{
error_log("`%s` parameter lack:%d\n", __FUNCTION__, args);
return 0;
}
if (!lua_isnumber(L, -args))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -args)));
return 0;
}
if (!lua_isstring(L, -(args-1)))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -(args-1))));
return 0;
}
if (!lua_isnumber(L, -(args-2)))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -(args-2))));
return 0;
}
if (!lua_isstring(L, -(args-3)))
{
error_log("`%s` parameter error:%s\n", __FUNCTION__, lua_typename(L, lua_type(L, -(args-3))));
return 0;
}
id = lua_tointeger(L, -args);
table_name = lua_tostring(L, -(args-1));
sid = lua_tonumber(L, -(args-2));
len = 0;
data = lua_tolstring(L, -(args-3), &len);
database_handler = hash_table_find(handler->database_table, id);
if (!database_handler)
{
error_log("`%s` not found database:%d\n", __FUNCTION__, id);
return 0;
}
retcode = record_create(database_handler, table_name, sid, data, len);
lua_pushboolean(L, retcode ? 1 : 0);
return 1;
}
inline
refbuf_t refbuf_alloc_full(refbuf_free_t rfree, env_t env, buf_t buf) {
refbuf_t rbuf = record_create(refbuf_t, rbuf) ;
nactive ++ ;
rbuf->buf = buf ;
rbuf->count = 1 ;
rbuf->free = rfree ;
rbuf->env = env ;
return rbuf ;
}
equeue_t equeue_create(debug_t debug, int size) {
equeue_t q ;
q = record_create(equeue_t, q) ;
q->debug = debug ;
q->size = size ;
q->alen = 1<<5 ; /* must be a power of 2 */
q->head = 0 ;
q->len = 0 ;
q->arr = sys_alloc(size * q->alen) ;
memset(q->arr, 0, size * q->alen) ;
return q ;
}
static void up_handler(state_t s, event_t e, unmarsh_t abv) {
endpt_id_t origin ;
unmarsh_endpt_id(abv, &origin) ;
if (s->partition) {
sys_abort() ;
} else {
etime_t delay ;
if (!distrib(s, &delay)) {
up_free(e, abv) ;
} else {
etime_t when = time_add(alarm_gettime(s->alarm), delay) ;
item_t item = record_create(item_t, item) ;
/*eprintf("type=%s\n", event_type_to_string(event_type(e))) ;*/
item->type = DROP_UP ;
item->u.up.event = e ;
item->u.up.abv = abv ;
priq_add(s->priq, when, item) ;
dnnm(s, event_timer_time(when)) ;
}
}
}
iq_t iq_create(debug_t debug, iq_free_t free) {
iq_t iq = record_create(iq_t, iq) ;
iq->lo = 0 ;
iq->hi = 0 ;
iq->alen = 1 ;
iq->read = 0 ;
iq->name = debug ;
iq->mask = 0 ;
iq->arr = sys_alloc(sizeof(iq->arr[0])) ;
iq->free = free ;
assert(iq->arr) ;
memset(iq->arr, 0, sizeof(iq->arr[0])) ;
iq->arr[0].msg = NULL ;
#if 0
#ifdef USE_GC
gc_tag(iq, debug) ;
gc_tag(iq->arr, debug) ;
#endif
#endif
return iq ;
}
alarm_t alarm_create(
name_t name,
alarm_gettime_t gettime,
alarm_schedule_t schedule,
alarm_check_t check,
alarm_min_t min,
alarm_add_sock_recv_t add_sock_recv,
alarm_rmv_sock_recv_t rmv_sock_recv,
alarm_add_sock_xmit_t add_sock_xmit,
alarm_rmv_sock_xmit_t rmv_sock_xmit,
alarm_add_poll_t add_poll,
alarm_rmv_poll_t rmv_poll,
alarm_block_t block,
alarm_block_extern_t block_extern,
alarm_poll_t poll,
env_t env
) {
alarm_t a = record_create(alarm_t, a) ;
record_clear(a) ;
a->last_time = time_zero() ;
a->name = name ;
a->env = env ;
a->gettime = gettime ;
a->schedule = schedule ;
a->check = check ;
a->min = min ;
a->add_sock_recv = add_sock_recv ;
a->rmv_sock_recv = rmv_sock_recv ;
a->add_sock_xmit = add_sock_xmit ;
a->rmv_sock_xmit = rmv_sock_xmit ;
a->add_poll = add_poll ;
a->rmv_poll = rmv_poll ;
a->block = block ;
a->block_extern = block_extern ;
a->poll = poll ;
return a ;
}
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 ;
}
}
