enum pause_reason do_stuff(void)
{
struct thread *thread;
volatile int timer;
volatile bool do_select = true;
assert (!InInterpreter);
do {
if (do_select)
check_fds(false);
else
do_select = true;
PauseReason = pause_NoReason;
thread = thread_pick_next();
if (thread) {
timer = OPS_PER_TIME_SLICE;
InInterpreter = true;
set_interrupt_handler(set_pause_interrupted);
_setjmp(Catcher);
if (PauseReason == pause_NoReason)
while (timer-- > 0) {
#if SLOW_FUNCTION_POINTERS
if (thread->advance)
thread->advance(thread);
else
interpret_next_byte(thread);
#else
thread->advance(thread);
#endif
}
InInterpreter = false;
clear_interrupt_handler();
if (TimeToGC)
collect_garbage(false);
}
else if (all_threads() == NULL)
PauseReason = pause_NothingToRun;
else {
set_interrupt_handler(set_pause_interrupted);
check_fds(true);
do_select = false;
clear_interrupt_handler();
}
} while (PauseReason == pause_NoReason
|| PauseReason == pause_PickNewThread);
return PauseReason;
}
enum pause_reason single_step(struct thread *thread)
{
assert(!InInterpreter);
assert(thread->status == status_Running);
assert(thread->suspend_count == 0);
check_fds(false);
thread_set_current(thread);
InInterpreter = true;
PauseReason = pause_NoReason;
set_interrupt_handler(set_pause_interrupted);
if (_setjmp(Catcher) == 0) {
#if SLOW_FUNCTION_POINTERS
if (thread->advance)
thread->advance(thread);
else
interpret_next_byte(thread);
#else
thread->advance(thread);
#endif
}
InInterpreter = false;
clear_interrupt_handler();
if (TimeToGC)
collect_garbage(false);
return PauseReason;
}
int main()
{
uint8_t buf[BUFSIZE];
ssize_t size;
fd_set fds;
struct timeval tv;
struct framebuffer fb;
struct terminal term;
/* init */
setlocale(LC_ALL, "");
if (atexit(tty_die) != 0)
fatal("atexit failed");
tty_init();
fb_init(&fb, term.color_palette);
check_env(&fb);
term_init(&term, fb.res, fb.rotate);
/* fork and exec shell */
eforkpty(&term.fd, term.lines, term.cols);
/* main loop */
while (tty.loop_flag) {
if (tty.redraw_flag) {
redraw(&term);
refresh(&fb, &term);
tty.redraw_flag = false;
}
check_fds(&fds, &tv, STDIN_FILENO, term.fd);
if (FD_ISSET(STDIN_FILENO, &fds)) {
size = read(STDIN_FILENO, buf, BUFSIZE);
if (size > 0)
ewrite(term.fd, buf, size);
}
if (FD_ISSET(term.fd, &fds)) {
size = read(term.fd, buf, BUFSIZE);
if (size > 0) {
if (DEBUG)
ewrite(STDOUT_FILENO, buf, size);
parse(&term, buf, size);
if (tty.lazy_draw && size == BUFSIZE)
continue;
refresh(&fb, &term);
}
}
}
/* die */
term_die(&term);
fb_die(&fb);
return EXIT_SUCCESS;
}
void game(t_env *env)
{
while (stop == 42)
{
init_fds(env);
do_select(env);
check_fds(env);
apply_timers(env);
do_actions(env);
}
}
int main()
{
int size;
fd_set fds;
struct timeval tv;
u8 buf[BUFSIZE];
XEvent ev;
xwindow xw;
terminal term;
/* init */
x_init(&xw);
term_init(&term, xw.res);
load_ctrl_func(ctrl_func, CTRL_CHARS);
load_esc_func(esc_func, ESC_CHARS);
load_csi_func(csi_func, ESC_CHARS);
/* fork */
eforkpty(&term.fd, term.lines, term.cols);
signal(SIGCHLD, sigchld);
setvbuf(stdout, NULL, _IONBF, 0);
/* main loop */
while (loop_flag) {
check_fds(&fds, &tv, term.fd);
while(XPending(xw.dsp)) {
XNextEvent(xw.dsp, &ev);
if(XFilterEvent(&ev, xw.win))
continue;
if (event_func[ev.type])
event_func[ev.type](&xw, &term, &ev);
}
if (FD_ISSET(term.fd, &fds)) {
size = read(term.fd, buf, BUFSIZE);
if (size > 0) {
if (DEBUG)
ewrite(STDOUT_FILENO, buf, size);
parse(&term, buf, size);
if (size == BUFSIZE)
continue;
refresh(&xw, &term);
}
}
}
term_die(&term);
x_die(&xw);
return 0;
}
int main_loop(t_cl_prop *cl)
{
while(1)
{
//printf("main_loop.\n");
printf("===============================================================\n");
init_fds(cl);
cl_select(cl);
check_fds(cl);
}
return (1);
}
int connect_to_server(t_graphic *c)
{
c->server.sin_family = AF_INET;
c->server.sin_port = htons(c->port);
if (((c->socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1 &&
my_perror(SYSCALL("socket"), FAILURE) == FAILURE) ||
(inet_aton(c->ip, IN_ADDR(&c->server.sin_addr.s_addr)) == -1 &&
my_perror(SYSCALL("inet_aton"), FAILURE) == FAILURE) ||
(connect(c->socket, C_SOCKADDR(&c->server), sizeof(c->server)) == -1 &&
my_perror(SYSCALL("connect"), FAILURE) == FAILURE))
return (close_graphic(c, FAILURE));
printf("Graphic trying to connect\n");
return (check_fds(c));
}
int main(int argc, char* argv[])
{
int ch;
pid_t pid = getpid();
acl::string action("fds");
while ((ch = getopt(argc, argv, "ha:p:")) > 0) {
switch (ch) {
case 'h':
usage(argv[0]);
return 0;
case 'a':
action = optarg;
break;
case 'p':
pid = (pid_t) atoi(optarg);
if (pid < 0)
pid = getpid();
break;
default:
break;
}
}
bool ret;
acl::log::stdout_open(true);
if (action == "fds") {
ret = check_fds(pid);
} else if (action == "mem") {
ret = check_mem(pid);
} else {
printf("action: %s not support yet!\r\n", action.c_str());
return 1;
}
return ret ? 0 : 1;
}
static void
test_gpoll (void)
{
SOCKET sockets[NUM_POLLEES];
GPollFD fds[NUM_POLLFDS];
SOCKET opp_sockets[NUM_POLLEES];
gint i;
gint activatable;
gint64 times[REPEAT][2];
#define BUCKET_COUNT 25
gint64 bucket_limits[BUCKET_COUNT] = {3, 5, 10, 15, 20, 25, 30, 35, 40, 50, 60, 70, 80, 90, 100, 120, 150, 180, 220, 280, 350, 450, 600, 800, 1000};
gint buckets[BUCKET_COUNT];
gint64 times_avg = 0, times_min = G_MAXINT64, times_max = 0;
prepare_sockets (sockets, opp_sockets, fds, NUM_POLLEES);
prepare_fds (sockets, fds, NUM_POLLEES);
times_avg = 0;
times_min = G_MAXINT64;
times_max = 0;
memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
for (i = 0; i < REPEAT; i++)
{
gint r;
gint64 diff;
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
times[i][0] = g_get_monotonic_time ();
r = g_poll (fds, NUM_POLLFDS, 0);
times[i][1] = g_get_monotonic_time ();
g_assert (r == 0);
diff = times[i][1] - times[i][0];
if (times_min > diff)
times_min = diff;
if (times_max < diff)
times_max = diff;
times_avg += diff;
bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
}
times_avg /= NUM_POLLEES;
g_print ("\nempty poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
print_buckets (buckets, bucket_limits, BUCKET_COUNT);
times_avg = 0;
times_min = G_MAXINT64;
times_max = 0;
memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
activatable = 0;
for (i = 0; i < REPEAT; i++)
{
gint r, s, v, t;
gint64 diff;
MSG msg;
gboolean found_app;
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
s = send (opp_sockets[activatable], (const char *) &t, 1, 0);
g_assert (PostMessage (NULL, WM_APP, 1, 2));
/* This is to ensure that all sockets catch up, otherwise some might not poll active */
g_usleep (G_USEC_PER_SEC / 1000);
times[i][0] = g_get_monotonic_time ();
r = g_poll (fds, NUM_POLLFDS, 1000);
times[i][1] = g_get_monotonic_time ();
check_fds (sockets, fds, NUM_POLLEES);
v = recv (sockets[activatable], (char *) &t, 1, 0);
found_app = FALSE;
while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)
found_app = TRUE;
g_assert (s == 1);
g_assert (r == 2);
g_assert (v == 1);
g_assert (found_app);
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
r = g_poll (fds, NUM_POLLFDS, 0);
check_fds (sockets, fds, NUM_POLLEES);
g_assert (r == 0);
diff = times[i][1] - times[i][0];
if (times_min > diff)
times_min = diff;
if (times_max < diff)
times_max = diff;
times_avg += diff;
activatable = (activatable + 1) % NUM_POLLEES;
bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
}
times_avg /= NUM_POLLEES;
g_print ("1-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
print_buckets (buckets, bucket_limits, BUCKET_COUNT);
times_avg = 0;
times_min = G_MAXINT64;
times_max = 0;
memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
activatable = 0;
for (i = 0; i < REPEAT; i++)
{
gint r, s, v, t;
gint64 diff;
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
s = send (opp_sockets[activatable], (const char *) &t, 1, 0);
g_usleep (G_USEC_PER_SEC / 1000);
times[i][0] = g_get_monotonic_time ();
r = g_poll (fds, NUM_POLLFDS, 1000);
times[i][1] = g_get_monotonic_time ();
check_fds (sockets, fds, NUM_POLLEES);
v = recv (sockets[activatable], (char *) &t, 1, 0);
g_assert (s == 1);
g_assert (r == 1);
g_assert (v == 1);
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
r = g_poll (fds, NUM_POLLFDS, 0);
check_fds (sockets, fds, NUM_POLLEES);
g_assert (r == 0);
diff = times[i][1] - times[i][0];
if (times_min > diff)
times_min = diff;
if (times_max < diff)
times_max = diff;
times_avg += diff;
activatable = (activatable + 1) % NUM_POLLEES;
bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
}
times_avg /= NUM_POLLEES;
g_print ("1-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
print_buckets (buckets, bucket_limits, BUCKET_COUNT);
times_avg = 0;
times_min = G_MAXINT64;
times_max = 0;
memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
for (i = 0; i < REPEAT; i++)
{
gint r, s, v, t;
gint64 diff;
gint j;
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
s = v = 0;
for (j = 0; j < NUM_POLLEES / 2; j++)
s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
g_usleep (G_USEC_PER_SEC / 1000);
times[i][0] = g_get_monotonic_time ();
r = g_poll (fds, NUM_POLLFDS, 1000);
times[i][1] = g_get_monotonic_time ();
check_fds (sockets, fds, NUM_POLLEES);
for (j = 0; j < NUM_POLLEES / 2; j++)
v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
g_assert (s == NUM_POLLEES / 2);
g_assert (r == NUM_POLLEES / 2);
g_assert (v == NUM_POLLEES / 2);
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
r = g_poll (fds, NUM_POLLFDS, 0);
check_fds (sockets, fds, NUM_POLLEES);
g_assert (r == 0);
diff = times[i][1] - times[i][0];
if (times_min > diff)
times_min = diff;
if (times_max < diff)
times_max = diff;
times_avg += diff;
bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
}
times_avg /= NUM_POLLEES;
g_print ("half-socket poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
print_buckets (buckets, bucket_limits, BUCKET_COUNT);
times_avg = 0;
times_min = G_MAXINT64;
times_max = 0;
memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
for (i = 0; i < REPEAT; i++)
{
gint r, s, v, t;
gint64 diff;
gint j;
MSG msg;
gboolean found_app;
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
s = v = 0;
for (j = 0; j < NUM_POLLEES / 2; j++)
s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
g_assert (PostMessage (NULL, WM_APP, 1, 2));
/* This is to ensure that all sockets catch up, otherwise some might not poll active */
g_usleep (G_USEC_PER_SEC / 1000);
times[i][0] = g_get_monotonic_time ();
r = g_poll (fds, NUM_POLLFDS, 1000);
times[i][1] = g_get_monotonic_time ();
check_fds (sockets, fds, NUM_POLLEES);
for (j = 0; j < NUM_POLLEES / 2; j++)
v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
found_app = FALSE;
while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)
found_app = TRUE;
g_assert (s == NUM_POLLEES / 2);
g_assert (r == NUM_POLLEES / 2 + 1);
g_assert (v == NUM_POLLEES / 2);
g_assert (found_app);
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
r = g_poll (fds, NUM_POLLFDS, 0);
check_fds (sockets, fds, NUM_POLLEES);
g_assert (r == 0);
diff = times[i][1] - times[i][0];
if (times_min > diff)
times_min = diff;
if (times_max < diff)
times_max = diff;
times_avg += diff;
bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
}
times_avg /= NUM_POLLEES;
g_print ("half-socket + msg poll time:\n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
print_buckets (buckets, bucket_limits, BUCKET_COUNT);
times_avg = 0;
times_min = G_MAXINT64;
times_max = 0;
memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
for (i = 0; i < REPEAT; i++)
{
gint r, s, v, t;
gint64 diff;
gint j;
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
s = v = 0;
for (j = 0; j < NUM_POLLEES; j++)
s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
g_usleep (G_USEC_PER_SEC / 1000);
times[i][0] = g_get_monotonic_time ();
r = g_poll (fds, NUM_POLLFDS, 1000);
times[i][1] = g_get_monotonic_time ();
check_fds (sockets, fds, NUM_POLLEES);
for (j = 0; j < NUM_POLLEES; j++)
v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
g_assert (s == NUM_POLLEES);
g_assert (r == NUM_POLLEES);
g_assert (v == NUM_POLLEES);
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
r = g_poll (fds, NUM_POLLFDS, 0);
check_fds (sockets, fds, NUM_POLLEES);
g_assert (r == 0);
diff = times[i][1] - times[i][0];
if (times_min > diff)
times_min = diff;
if (times_max < diff)
times_max = diff;
times_avg += diff;
bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
}
times_avg /= NUM_POLLEES;
g_print ("%d-socket poll time: \n%4lldns - %4lldns, average %4lldns\n", NUM_POLLEES, times_min, times_max, times_avg);
print_buckets (buckets, bucket_limits, BUCKET_COUNT);
activatable = 0;
times_avg = 0;
times_min = G_MAXINT64;
times_max = 0;
memset (buckets, 0, sizeof (gint) * BUCKET_COUNT);
for (i = 0; i < REPEAT; i++)
{
gint r, s, v, t;
gint64 diff;
gint j;
MSG msg;
gboolean found_app;
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
s = v = 0;
for (j = 0; j < activatable; j++)
s += send (opp_sockets[j], (const char *) &t, 1, 0) == 1 ? 1 : 0;
g_assert (PostMessage (NULL, WM_APP, 1, 2));
g_usleep (G_USEC_PER_SEC / 1000);
times[i][0] = g_get_monotonic_time ();
r = g_poll (fds, NUM_POLLFDS, 1000);
times[i][1] = g_get_monotonic_time ();
check_fds (sockets, fds, NUM_POLLEES);
for (j = 0; j < activatable; j++)
v += recv (sockets[j], (char *) &t, 1, 0) == 1 ? 1 : 0;
found_app = FALSE;
while (!found_app && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
if (msg.message == WM_APP && msg.wParam == 1 && msg.lParam == 2)
found_app = TRUE;
g_assert (s == activatable);
g_assert (r == activatable + 1);
g_assert (v == activatable);
g_assert (found_app);
reset_fds (fds, NUM_POLLEES);
reset_fds_msg (fds, NUM_POLLFDS);
r = g_poll (fds, NUM_POLLFDS, 0);
check_fds (sockets, fds, NUM_POLLEES);
g_assert (r == 0);
diff = times[i][1] - times[i][0];
if (times_min > diff)
times_min = diff;
if (times_max < diff)
times_max = diff;
times_avg += diff;
bucketize (diff, buckets, bucket_limits, BUCKET_COUNT);
activatable = (activatable + 1) % NUM_POLLEES;
}
times_avg /= NUM_POLLEES;
g_print ("variable socket number + msg poll time: \n%4lldns - %4lldns, average %4lldns\n", times_min, times_max, times_avg);
print_buckets (buckets, bucket_limits, BUCKET_COUNT);
cleanup_sockets (sockets, opp_sockets, NUM_POLLEES);
}
