hyung-hwan/moo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use EPOLLET when modifying with epoll_ctl()

Browse Source
This commit is contained in:
hyunghwan.chung 2017-12-28 07:26:19 +00:00
parent edba0207fb
commit dbb38a5d31
3 changed files with 11 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
moo/kernel/Process.moo
View File

@ -129,64 +129,6 @@ TODO: how to prohibit wait and signal???
^block ensure: [ self signal ] ^block ensure: [ self signal ]
} }
} }
(*
xxx := Semaphore new.
xxx on: #signal do: [ ].
========= CASE 1 ====================
sg := SemaphoreGroup with (xxx, yyy, zzz).
System signal: xxx onInput: aaa.
System signal: yyy onInput: bbb.
System signal: zzz onOutput: ccc.
while (true)
{
sem := sg wait.
if (sem == xxx)
{
}
elsif (sem == yyy)
{
}
elsif (sem == zzz)
{
}.
}
============ CASE 2====================
### ASSOCIATE CALLBACK WITH SEMAPHORE.
sg := SemaphoreGroup with (xxx, yyy, zzz).
oldaction := xxx signalAction: [ ... ]. ### similar interface like unix system call signal()???? method signalAction: block {} , method signalAction { ^self.signalAction }
yyy signalAction: [ ... ].
zzz signalAction: [ ... ].
System signal: xxx onInput: aaa.
System signal: yyy onInput: bbb.
System signal: zzz onOutput: ccc.
while (true)
{
sem := sg wait. ### the action associated with the semaphore must get executed. => wait may be a primitive. the primitive handler may return failure... if so, the actual primitive body can execute the action easily
}
Semaphore>>method wait
{
<primitive: #Semaphore_wait>
if (errorCode == NO ERROR)
{
self.signalAction value. ## which is better???
self.sginalAction value: self.
}
}
*)
class SemaphoreGroup(Object) class SemaphoreGroup(Object)

8
moo/lib/exec.c
View File

@ -1354,14 +1354,14 @@ static void signal_io_semaphore (moo_t* moo, moo_ooi_t io_handle, moo_ooi_t mask
sem_io_index = moo->sem_io_map[io_handle]; sem_io_index = moo->sem_io_map[io_handle];
sem = moo->sem_io_tuple[sem_io_index].sem[MOO_SEMAPHORE_IO_TYPE_INPUT]; sem = moo->sem_io_tuple[sem_io_index].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT];
if (sem && (mask & (MOO_SEMAPHORE_IO_MASK_INPUT | MOO_SEMAPHORE_IO_MASK_HANGUP | MOO_SEMAPHORE_IO_MASK_ERROR))) if (sem && (mask & MOO_SEMAPHORE_IO_MASK_OUTPUT))
{ {
_signal_io_semaphore (moo, sem); _signal_io_semaphore (moo, sem);
} }
sem = moo->sem_io_tuple[sem_io_index].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT]; sem = moo->sem_io_tuple[sem_io_index].sem[MOO_SEMAPHORE_IO_TYPE_INPUT];
if (sem && (mask & MOO_SEMAPHORE_IO_MASK_OUTPUT)) if (sem && (mask & (MOO_SEMAPHORE_IO_MASK_INPUT | MOO_SEMAPHORE_IO_MASK_HANGUP | MOO_SEMAPHORE_IO_MASK_ERROR)))
{ {
_signal_io_semaphore (moo, sem); _signal_io_semaphore (moo, sem);
} }

8
moo/lib/main.c
View File

@ -1022,6 +1022,12 @@ static int _mod_poll_fd (moo_t* moo, int fd, int event_mask)
MOO_ASSERT (moo, xtn->ep >= 0); MOO_ASSERT (moo, xtn->ep >= 0);
memset (&ev, 0, MOO_SIZEOF(ev)); memset (&ev, 0, MOO_SIZEOF(ev));
ev.events = event_mask; ev.events = event_mask;
#if defined(USE_THREAD) && defined(EPOLLET)
/* epoll_wait may return again if the worker thread consumes events.
* switch to level-trigger. */
/* TODO: verify if EPOLLLET is desired */
ev.events |= EPOLLET;
#endif
ev.data.fd = fd; ev.data.fd = fd;
if (epoll_ctl (xtn->ep, EPOLL_CTL_MOD, fd, &ev) == -1) if (epoll_ctl (xtn->ep, EPOLL_CTL_MOD, fd, &ev) == -1)
{ {
@ -1402,7 +1408,7 @@ static void* iothr_main (void* arg)
dvp.dp_nfds = MOO_COUNTOF(xtn->ev.buf); dvp.dp_nfds = MOO_COUNTOF(xtn->ev.buf);
n = ioctl (xtn->ep, DP_POLL, &dvp); n = ioctl (xtn->ep, DP_POLL, &dvp);
#elif defined(USE_EPOLL) #elif defined(USE_EPOLL)
n = epoll_wait (xtn->ep, xtn->ev.buf, MOO_COUNTOF(xtn->ev.buf), 10000); n = epoll_wait (xtn->ep, xtn->ev.buf, MOO_COUNTOF(xtn->ev.buf), 10000); /* TODO: make this timeout value in the io thread */
#elif defined(USE_POLL) #elif defined(USE_POLL)
MUTEX_LOCK (&xtn->ev.reg.pmtx); MUTEX_LOCK (&xtn->ev.reg.pmtx);
memcpy (xtn->ev.buf, xtn->ev.reg.ptr, xtn->ev.reg.len * MOO_SIZEOF(*xtn->ev.buf)); memcpy (xtn->ev.buf, xtn->ev.reg.ptr, xtn->ev.reg.len * MOO_SIZEOF(*xtn->ev.buf));