mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-09 13:30:06 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Work on event loop

Browse source 
Make a new epoll based event loop and use it for the data tranport.
Simplify the spa event api a little and rename to SpaLoop
This commit is contained in:
Wim Taymans 2016-11-18 17:46:01 +01:00
parent 0d2fa5ebc8
commit ae93f15965
33 changed files with 1286 additions and 954 deletions
Download patch file Download diff file Expand all files Collapse all files

96
pinos/server/client-node.c
View file

@ -24,7 +24,6 @@
#include <unistd.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <poll.h>
#include <sys/socket.h>
#include <sys/mman.h>
#include <sys/eventfd.h>
@ -94,18 +93,16 @@ struct _SpaProxy
SpaIDMap *map;
SpaLog *log;
SpaPoll *main_loop;
SpaPoll *data_loop;
SpaLoop *main_loop;
SpaLoop *data_loop;
SpaNodeEventCallback event_cb;
void *user_data;
SpaPollFd ctrl_fds[1];
SpaPollItem ctrl_poll;
SpaSource ctrl_source;
PinosConnection *conn;
SpaPollFd data_fds[1];
SpaPollItem data_poll;
SpaSource data_source;
unsigned int max_inputs;
unsigned int n_inputs;
@ -858,7 +855,7 @@ spa_proxy_node_port_reuse_buffer (SpaNode *node,
rb.buffer_id = buffer_id;
pinos_transport_add_event (pnode->transport, &rb.event);
cmd = PINOS_TRANSPORT_CMD_HAVE_EVENT;
write (this->data_fds[0].fd, &cmd, 1);
write (this->data_source.fd, &cmd, 1);
return SPA_RESULT_OK;
}
@ -927,7 +924,7 @@ spa_proxy_node_process_input (SpaNode *node)
return SPA_RESULT_ERROR;
cmd = PINOS_TRANSPORT_CMD_HAVE_DATA;
write (this->data_fds[0].fd, &cmd, 1);
write (this->data_source.fd, &cmd, 1);
return SPA_RESULT_OK;
}
@ -1089,27 +1086,25 @@ parse_connection (SpaProxy *this)
return SPA_RESULT_OK;
}
static int
proxy_on_fd_events (SpaPollNotifyData *data)
static void
proxy_on_fd_events (SpaSource *source)
{
SpaProxy *this = data->user_data;
SpaProxy *this = source->data;
if (data->fds[0].revents & POLLIN) {
if (source->rmask & SPA_IO_IN)
parse_connection (this);
}
return 0;
}
static int
proxy_on_data_fd_events (SpaPollNotifyData *data)
static void
proxy_on_data_fd_events (SpaSource *source)
{
SpaProxy *this = data->user_data;
SpaProxy *this = source->data;
PinosNode *pnode = this->pnode;
if (data->fds[0].revents & POLLIN) {
if (source->rmask & SPA_IO_IN) {
uint8_t cmd;
read (this->data_fds[0].fd, &cmd, 1);
read (this->data_source.fd, &cmd, 1);
if (cmd & PINOS_TRANSPORT_CMD_HAVE_EVENT) {
SpaNodeEvent event;
@ -1134,7 +1129,6 @@ proxy_on_data_fd_events (SpaPollNotifyData *data)
this->event_cb (&this->node, &ni.event, this->user_data);
}
}
return 0;
}
static const SpaNode proxy_node = {
@ -1176,9 +1170,9 @@ proxy_init (SpaProxy *this,
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_LOG_URI) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_POLL__MainLoop) == 0)
else if (strcmp (support[i].uri, SPA_LOOP__MainLoop) == 0)
this->main_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_POLL__DataLoop) == 0)
else if (strcmp (support[i].uri, SPA_LOOP__DataLoop) == 0)
this->data_loop = support[i].data;
}
if (this->data_loop == NULL) {
@ -1190,29 +1184,17 @@ proxy_init (SpaProxy *this,
this->node = proxy_node;
this->ctrl_fds[0].fd = -1;
this->ctrl_fds[0].events = POLLIN | POLLPRI | POLLERR;
this->ctrl_fds[0].revents = 0;
this->ctrl_poll.id = 0;
this->ctrl_poll.enabled = true;
this->ctrl_poll.fds = this->ctrl_fds;
this->ctrl_poll.n_fds = 1;
this->ctrl_poll.idle_cb = NULL;
this->ctrl_poll.before_cb = NULL;
this->ctrl_poll.after_cb = proxy_on_fd_events;
this->ctrl_poll.user_data = this;
this->ctrl_source.func = proxy_on_fd_events;
this->ctrl_source.data = this;
this->ctrl_source.fd = -1;
this->ctrl_source.mask = SPA_IO_IN | SPA_IO_ERR;
this->ctrl_source.rmask = 0;
this->data_fds[0].fd = -1;
this->data_fds[0].events = POLLIN | POLLPRI | POLLERR;
this->data_fds[0].revents = 0;
this->data_poll.id = 0;
this->data_poll.enabled = true;
this->data_poll.fds = this->data_fds;
this->data_poll.n_fds = 1;
this->data_poll.idle_cb = NULL;
this->data_poll.before_cb = NULL;
this->data_poll.after_cb = proxy_on_data_fd_events;
this->data_poll.user_data = this;
this->data_source.func = proxy_on_data_fd_events;
this->data_source.data = this;
this->data_source.fd = -1;
this->data_source.mask = SPA_IO_IN | SPA_IO_ERR;
this->data_source.rmask = 0;
return SPA_RESULT_RETURN_ASYNC (this->seq++);
}
@ -1243,7 +1225,7 @@ on_loop_changed (PinosListener *listener,
PinosNode *node)
{
PinosClientNodeImpl *impl = SPA_CONTAINER_OF (listener, PinosClientNodeImpl, loop_changed);
impl->proxy.data_loop = &node->data_loop->poll;
impl->proxy.data_loop = node->data_loop->loop->loop;
}
static SpaResult
@ -1259,13 +1241,13 @@ proxy_clear (SpaProxy *this)
if (this->out_ports[i].valid)
clear_port (this, &this->out_ports[i], SPA_DIRECTION_OUTPUT, i);
}
if (this->ctrl_fds[0].fd != -1) {
spa_poll_remove_item (this->main_loop, &this->ctrl_poll);
close (this->ctrl_fds[0].fd);
if (this->ctrl_source.fd != -1) {
spa_loop_remove_source (this->main_loop, &this->ctrl_source);
close (this->ctrl_source.fd);
}
if (this->data_fds[0].fd != -1) {
spa_poll_remove_item (this->data_loop, &this->data_poll);
close (this->data_fds[0].fd);
if (this->data_source.fd != -1) {
spa_loop_remove_source (this->data_loop, &this->data_source);
close (this->data_source.fd);
}
return SPA_RESULT_OK;
@ -1380,9 +1362,9 @@ pinos_client_node_get_ctrl_socket (PinosClientNode *this,
if (socketpair (AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, fd) != 0)
return SPA_RESULT_ERRNO;
impl->proxy.ctrl_fds[0].fd = fd[0];
impl->proxy.conn = pinos_connection_new (impl->proxy.ctrl_fds[0].fd);
spa_poll_add_item (impl->proxy.main_loop, &impl->proxy.ctrl_poll);
impl->proxy.ctrl_source.fd = fd[0];
impl->proxy.conn = pinos_connection_new (impl->proxy.ctrl_source.fd);
spa_loop_add_source (impl->proxy.main_loop, &impl->proxy.ctrl_source);
impl->ctrl_fd = fd[1];
}
*fd = impl->ctrl_fd;
@ -1411,8 +1393,8 @@ pinos_client_node_get_data_socket (PinosClientNode *this,
if (socketpair (AF_UNIX, SOCK_STREAM, 0, fd) != 0)
return SPA_RESULT_ERRNO;
impl->proxy.data_fds[0].fd = fd[0];
spa_poll_add_item (impl->proxy.data_loop, &impl->proxy.data_poll);
impl->proxy.data_source.fd = fd[0];
spa_loop_add_source (impl->proxy.data_loop, &impl->proxy.data_source);
impl->data_fd = fd[1];
}
*fd = impl->data_fd;

10
pinos/server/core.c
View file

@ -47,13 +47,15 @@ pinos_core_new (PinosMainLoop *main_loop)
impl->support[0].data = this->registry.map;
impl->support[1].uri = SPA_LOG_URI;
impl->support[1].data = pinos_log_get ();
impl->support[2].uri = SPA_POLL__DataLoop;
impl->support[2].data = &this->data_loop->poll;
impl->support[3].uri = SPA_POLL__MainLoop;
impl->support[3].data = this->main_loop->poll;
impl->support[2].uri = SPA_LOOP__DataLoop;
impl->support[2].data = this->data_loop->loop->loop;
impl->support[3].uri = SPA_LOOP__MainLoop;
impl->support[3].data = this->main_loop->loop;
this->support = impl->support;
this->n_support = 4;
pinos_data_loop_start (this->data_loop);
spa_list_init (&this->global_list);
spa_list_init (&this->client_list);
spa_list_init (&this->node_list);

1
pinos/server/core.h
View file

@ -28,6 +28,7 @@ typedef struct _PinosCore PinosCore;
typedef struct _PinosGlobal PinosGlobal;
#include <spa/include/spa/log.h>
#include <pinos/server/main-loop.h>
#include <pinos/server/data-loop.h>
#include <pinos/server/registry.h>

339
pinos/server/data-loop.c
View file

@ -28,39 +28,15 @@
#include <sys/resource.h>
#include <pthread.h>
#include "spa/include/spa/ringbuffer.h"
#include "pinos/client/log.h"
#include "pinos/client/rtkit.h"
#include "pinos/server/data-loop.h"
#define DATAS_SIZE (4096 * 8)
typedef struct {
size_t item_size;
SpaPollInvokeFunc func;
uint32_t seq;
size_t size;
void *data;
void *user_data;
} InvokeItem;
typedef struct
{
PinosDataLoop this;
SpaRingbuffer buffer;
uint8_t buffer_data[DATAS_SIZE];
unsigned int n_poll;
SpaPollItem poll[16];
int idx[16];
bool rebuild_fds;
SpaPollFd fds[32];
unsigned int n_fds;
uint32_t counter;
uint32_t seq;
PinosSource *event;
bool running;
pthread_t thread;
@ -111,266 +87,31 @@ make_realtime (PinosDataLoop *this)
}
static void *
loop (void *user_data)
do_loop (void *user_data)
{
PinosDataLoopImpl *impl = user_data;
PinosDataLoop *this = &impl->this;
SpaPoll *p = &this->poll;
unsigned int i, j;
SpaResult res;
make_realtime (this);
pinos_log_debug ("data-loop %p: enter thread", this);
while (impl->running) {
SpaPollNotifyData ndata;
unsigned int n_idle = 0;
int r;
/* prepare */
for (i = 0; i < impl->n_poll; i++) {
SpaPollItem *p = &impl->poll[i];
if (p->enabled && p->idle_cb) {
ndata.fds = NULL;
ndata.n_fds = 0;
ndata.user_data = p->user_data;
if (SPA_RESULT_IS_ERROR (p->idle_cb (&ndata)))
p->enabled = false;
n_idle++;
}
}
// if (n_idle > 0)
// continue;
/* rebuild */
if (impl->rebuild_fds) {
impl->n_fds = 1;
for (i = 0; i < impl->n_poll; i++) {
SpaPollItem *p = &impl->poll[i];
if (!p->enabled)
continue;
for (j = 0; j < p->n_fds; j++)
impl->fds[impl->n_fds + j] = p->fds[j];
impl->idx[i] = impl->n_fds;
impl->n_fds += p->n_fds;
}
impl->rebuild_fds = false;
}
/* before */
for (i = 0; i < impl->n_poll; i++) {
SpaPollItem *p = &impl->poll[i];
if (p->enabled && p->before_cb) {
ndata.fds = &impl->fds[impl->idx[i]];
ndata.n_fds = p->n_fds;
ndata.user_data = p->user_data;
if (SPA_RESULT_IS_ERROR (p->before_cb (&ndata)))
p->enabled = false;
}
}
r = poll ((struct pollfd *) impl->fds, impl->n_fds, -1);
if (r < 0) {
if (errno == EINTR)
continue;
break;
}
if (r == 0) {
pinos_log_warn ("data-loop %p: select timeout should not happen", this);
continue;
}
/* check wakeup */
if (impl->fds[0].revents & POLLIN) {
uint64_t u;
size_t offset;
if (read (impl->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
pinos_log_warn ("data-loop %p: failed to read fd: %s", this, strerror (errno));
while (spa_ringbuffer_get_read_offset (&impl->buffer, &offset) > 0) {
InvokeItem *item = SPA_MEMBER (impl->buffer_data, offset, InvokeItem);
item->func (p, true, item->seq, item->size, item->data, item->user_data);
spa_ringbuffer_read_advance (&impl->buffer, item->item_size);
}
continue;
}
/* after */
for (i = 0; i < impl->n_poll; i++) {
SpaPollItem *p = &impl->poll[i];
if (p->enabled && p->after_cb && (p->n_fds == 0 || impl->fds[impl->idx[i]].revents != 0)) {
ndata.fds = &impl->fds[impl->idx[i]];
ndata.n_fds = p->n_fds;
ndata.user_data = p->user_data;
if (SPA_RESULT_IS_ERROR (p->after_cb (&ndata)))
p->enabled = false;
}
}
if ((res = pinos_loop_iterate (this->loop, -1)) < 0)
pinos_log_warn ("data-loop %p: iterate error %d", this, res);
}
pinos_log_debug ("data-loop %p: leave thread", this);
return NULL;
}
static void
wakeup_thread (PinosDataLoopImpl *impl)
{
uint64_t u = 1;
if (write (impl->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
pinos_log_warn ("data-loop %p: failed to write fd: %s", impl, strerror (errno));
}
static void
start_thread (PinosDataLoopImpl *impl)
do_stop (PinosSource *source,
void *data)
{
int err;
if (!impl->running) {
impl->running = true;
if ((err = pthread_create (&impl->thread, NULL, loop, impl)) != 0) {
pinos_log_warn ("data-loop %p: can't create thread: %s", impl, strerror (err));
impl->running = false;
}
}
}
static void
stop_thread (PinosDataLoopImpl *impl, bool in_thread)
{
if (impl->running) {
impl->running = false;
if (!in_thread) {
wakeup_thread (impl);
pthread_join (impl->thread, NULL);
}
}
}
static SpaResult
do_add_item (SpaPoll *poll,
SpaPollItem *item)
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopImpl *impl = SPA_CONTAINER_OF (this, PinosDataLoopImpl, this);
bool in_thread = pthread_equal (impl->thread, pthread_self());
item->id = ++impl->counter;
impl->poll[impl->n_poll] = *item;
impl->n_poll++;
if (item->n_fds)
impl->rebuild_fds = true;
if (!in_thread) {
wakeup_thread (impl);
start_thread (impl);
}
return SPA_RESULT_OK;
}
static SpaResult
do_update_item (SpaPoll *poll,
SpaPollItem *item)
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopImpl *impl = SPA_CONTAINER_OF (this, PinosDataLoopImpl, this);
bool in_thread = pthread_equal (impl->thread, pthread_self());
unsigned int i;
for (i = 0; i < impl->n_poll; i++) {
if (impl->poll[i].id == item->id)
impl->poll[i] = *item;
}
if (item->n_fds)
impl->rebuild_fds = true;
if (!in_thread)
wakeup_thread (impl);
return SPA_RESULT_OK;
}
static SpaResult
do_remove_item (SpaPoll *poll,
SpaPollItem *item)
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopImpl *impl = SPA_CONTAINER_OF (this, PinosDataLoopImpl, this);
bool in_thread = pthread_equal (impl->thread, pthread_self());
unsigned int i;
for (i = 0; i < impl->n_poll; i++) {
if (impl->poll[i].id == item->id) {
impl->n_poll--;
for (; i < impl->n_poll; i++)
impl->poll[i] = impl->poll[i+1];
break;
}
}
if (item->n_fds) {
impl->rebuild_fds = true;
if (!in_thread)
wakeup_thread (impl);
}
return SPA_RESULT_OK;
}
static SpaResult
do_invoke (SpaPoll *poll,
SpaPollInvokeFunc func,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
PinosDataLoop *this = SPA_CONTAINER_OF (poll, PinosDataLoop, poll);
PinosDataLoopImpl *impl = SPA_CONTAINER_OF (this, PinosDataLoopImpl, this);
bool in_thread = pthread_equal (impl->thread, pthread_self());
SpaRingbufferArea areas[2];
InvokeItem *item;
SpaResult res;
if (in_thread) {
res = func (poll, false, seq, size, data, user_data);
} else {
spa_ringbuffer_get_write_areas (&impl->buffer, areas);
if (areas[0].len < sizeof (InvokeItem)) {
pinos_log_warn ("queue full");
return SPA_RESULT_ERROR;
}
item = SPA_MEMBER (impl->buffer_data, areas[0].offset, InvokeItem);
item->seq = seq;
item->func = func;
item->user_data = user_data;
item->size = size;
if (areas[0].len > sizeof (InvokeItem) + size) {
item->data = SPA_MEMBER (item, sizeof (InvokeItem), void);
item->item_size = sizeof (InvokeItem) + size;
if (areas[0].len < sizeof (InvokeItem) + item->item_size)
item->item_size = areas[0].len;
} else {
item->data = SPA_MEMBER (impl->buffer_data, areas[1].offset, void);
item->item_size = areas[0].len + 1 + size;
}
memcpy (item->data, data, size);
spa_ringbuffer_write_advance (&impl->buffer, item->item_size);
wakeup_thread (impl);
if (seq != SPA_ID_INVALID)
res = SPA_RESULT_RETURN_ASYNC (seq);
else
res = SPA_RESULT_OK;
}
return res;
PinosDataLoopImpl *impl = data;
impl->running = false;
}
/**
@ -387,38 +128,64 @@ pinos_data_loop_new (void)
PinosDataLoop *this;
impl = calloc (1, sizeof (PinosDataLoopImpl));
this = &impl->this;
pinos_log_debug ("data-loop %p: new", impl);
this->poll.size = sizeof (SpaPoll);
this->poll.info = NULL;
this->poll.add_item = do_add_item;
this->poll.update_item = do_update_item;
this->poll.remove_item = do_remove_item;
this->poll.invoke = do_invoke;
impl->fds[0].fd = eventfd (0, 0);
impl->fds[0].events = POLLIN | POLLPRI | POLLERR;
impl->fds[0].revents = 0;
impl->n_fds = 1;
spa_ringbuffer_init (&impl->buffer, DATAS_SIZE);
this = &impl->this;
this->loop = pinos_loop_new ();
pinos_signal_init (&this->destroy_signal);
impl->event = pinos_loop_add_event (this->loop,
do_stop,
impl);
return this;
}
void
pinos_data_loop_destroy (PinosDataLoop * loop)
pinos_data_loop_destroy (PinosDataLoop *loop)
{
PinosDataLoopImpl *impl = SPA_CONTAINER_OF (loop, PinosDataLoopImpl, this);
pinos_log_debug ("data-loop %p: destroy", impl);
stop_thread (impl, false);
close (impl->fds[0].fd);
pinos_signal_emit (&loop->destroy_signal, loop);
pinos_data_loop_stop (loop);
pinos_source_destroy (impl->event);
pinos_loop_destroy (loop->loop);
free (impl);
}
SpaResult
pinos_data_loop_start (PinosDataLoop *loop)
{
PinosDataLoopImpl *impl = SPA_CONTAINER_OF (loop, PinosDataLoopImpl, this);
if (!impl->running) {
int err;
impl->running = true;
if ((err = pthread_create (&impl->thread, NULL, do_loop, impl)) != 0) {
pinos_log_warn ("data-loop %p: can't create thread: %s", impl, strerror (err));
impl->running = false;
return SPA_RESULT_ERROR;
}
pinos_loop_set_thread (impl->this.loop, &impl->thread);
}
return SPA_RESULT_OK;
}
SpaResult
pinos_data_loop_stop (PinosDataLoop *loop)
{
PinosDataLoopImpl *impl = SPA_CONTAINER_OF (loop, PinosDataLoopImpl, this);
pinos_source_event_signal (impl->event);
pthread_join (impl->thread, NULL);
return SPA_RESULT_OK;
}
bool
pinos_data_loop_in_thread (PinosDataLoop *loop)
{

10
pinos/server/data-loop.h
View file

@ -24,7 +24,7 @@
extern "C" {
#endif
#include <spa/include/spa/poll.h>
#include <pinos/client/loop.h>
typedef struct _PinosDataLoop PinosDataLoop;
@ -34,12 +34,18 @@ typedef struct _PinosDataLoop PinosDataLoop;
* Pinos rt-loop object.
*/
struct _PinosDataLoop {
SpaPoll poll;
PinosLoop *loop;
PINOS_SIGNAL (destroy_signal, (PinosListener *listener,
PinosDataLoop *loop));
};
PinosDataLoop * pinos_data_loop_new (void);
void pinos_data_loop_destroy (PinosDataLoop *loop);
SpaResult pinos_data_loop_start (PinosDataLoop *loop);
SpaResult pinos_data_loop_stop (PinosDataLoop *loop);
bool pinos_data_loop_in_thread (PinosDataLoop *loop);
#ifdef __cplusplus

10
pinos/server/link.c
View file

@ -732,7 +732,7 @@ clear_port_buffers (PinosLink *link, PinosPort *port)
}
static SpaResult
do_link_remove_done (SpaPoll *poll,
do_link_remove_done (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -776,7 +776,7 @@ do_link_remove_done (SpaPoll *poll,
}
static SpaResult
do_link_remove (SpaPoll *poll,
do_link_remove (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -795,7 +795,7 @@ do_link_remove (SpaPoll *poll,
this->rt.output = NULL;
}
res = spa_poll_invoke (this->core->main_loop->poll,
res = spa_loop_invoke (this->core->main_loop->loop,
do_link_remove_done,
seq,
0,
@ -826,7 +826,7 @@ pinos_link_destroy (PinosLink * this)
pinos_signal_remove (&impl->input_port_destroy);
pinos_signal_remove (&impl->input_async_complete);
res = spa_poll_invoke (&this->input->node->data_loop->poll,
res = spa_loop_invoke (this->input->node->data_loop->loop->loop,
do_link_remove,
impl->seq++,
0,
@ -837,7 +837,7 @@ pinos_link_destroy (PinosLink * this)
pinos_signal_remove (&impl->output_port_destroy);
pinos_signal_remove (&impl->output_async_complete);
res = spa_poll_invoke (&this->output->node->data_loop->poll,
res = spa_loop_invoke (this->output->node->data_loop->loop->loop,
do_link_remove,
impl->seq++,
0,

188
pinos/server/main-loop.c
View file

@ -20,7 +20,6 @@
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <poll.h>
#include <sys/eventfd.h>
#include <gio/gio.h>
@ -34,12 +33,12 @@
#define DATAS_SIZE (4096 * 8)
typedef struct {
size_t item_size;
SpaPollInvokeFunc func;
uint32_t seq;
size_t size;
void *data;
void *user_data;
size_t item_size;
SpaInvokeFunc func;
uint32_t seq;
size_t size;
void *data;
void *user_data;
} InvokeItem;
typedef struct _WorkItem WorkItem;
@ -59,18 +58,17 @@ typedef struct
{
PinosMainLoop this;
SpaPoll poll;
SpaLoop loop;
GMainContext *context;
GMainLoop *loop;
GMainLoop *main_loop;
uint32_t counter;
SpaRingbuffer buffer;
uint8_t buffer_data[DATAS_SIZE];
SpaPollFd fds[1];
SpaPollItem wakeup;
SpaSource wakeup;
SpaList work_list;
SpaList free_list;
@ -79,103 +77,109 @@ typedef struct
} PinosMainLoopImpl;
typedef struct {
PinosMainLoop *loop;
SpaPollItem item;
} PollData;
PinosMainLoopImpl *impl;
SpaSource *source;
guint id;
} LoopData;
static bool
poll_event (GIOChannel *source,
GIOCondition condition,
void * user_data)
poll_event (GIOChannel *source,
GIOCondition condition,
void *user_data)
{
PollData *data = user_data;
SpaPollNotifyData d;
LoopData *data = user_data;
SpaSource *s = data->source;
d.user_data = data->item.user_data;
d.fds = data->item.fds;
d.fds[0].revents = condition;
d.n_fds = data->item.n_fds;
data->item.after_cb (&d);
s->rmask = 0;
if (condition & G_IO_IN)
s->rmask |= SPA_IO_IN;
if (condition & G_IO_OUT)
s->rmask |= SPA_IO_OUT;
if (condition & G_IO_ERR)
s->rmask |= SPA_IO_ERR;
if (condition & G_IO_HUP)
s->rmask |= SPA_IO_HUP;
s->func (s);
return TRUE;
}
static SpaResult
do_add_item (SpaPoll *poll,
SpaPollItem *item)
do_add_source (SpaLoop *loop,
SpaSource *source)
{
PinosMainLoop *this = SPA_CONTAINER_OF (poll, PinosMainLoop, poll);
PinosMainLoopImpl *impl = SPA_CONTAINER_OF (loop, PinosMainLoopImpl, loop);
GIOChannel *channel;
GSource *source;
PollData data;
GSource *s;
LoopData *data;
channel = g_io_channel_unix_new (item->fds[0].fd);
source = g_io_create_watch (channel, G_IO_IN);
channel = g_io_channel_unix_new (source->fd);
s = g_io_create_watch (channel, G_IO_IN);
g_io_channel_unref (channel);
data.loop = this;
data.item = *item;
data = g_new0 (LoopData, 1);
data->impl = impl;
data->source = source;
g_source_set_callback (source, (GSourceFunc) poll_event, g_slice_dup (PollData, &data) , NULL);
item->id = g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
g_source_set_callback (s, (GSourceFunc) poll_event, data, g_free);
data->id = g_source_attach (s, g_main_context_get_thread_default ());
g_source_unref (s);
pinos_log_debug ("added main poll %d", item->id);
source->loop_private = data;
source->loop = loop;
pinos_log_debug ("added main poll %d", data->id);
return SPA_RESULT_OK;
}
static SpaResult
do_update_item (SpaPoll *poll,
SpaPollItem *item)
do_update_source (SpaSource *source)
{
pinos_log_debug ("update main poll %d", item->id);
LoopData *data = source->loop_private;
pinos_log_debug ("update main poll %d", data->id);
return SPA_RESULT_OK;
}
static SpaResult
do_remove_item (SpaPoll *poll,
SpaPollItem *item)
static void
do_remove_source (SpaSource *source)
{
GSource *source;
GSource *gsource;
LoopData *data = source->loop_private;
pinos_log_debug ("remove main poll %d", item->id);
source = g_main_context_find_source_by_id (g_main_context_get_thread_default (), item->id);
g_source_destroy (source);
return SPA_RESULT_OK;
pinos_log_debug ("remove main poll %d", data->id);
gsource = g_main_context_find_source_by_id (g_main_context_get_thread_default (), data->id);
g_source_destroy (gsource);
}
static int
main_loop_dispatch (SpaPollNotifyData *data)
static void
main_loop_dispatch (SpaSource *source)
{
PinosMainLoopImpl *impl = data->user_data;
SpaPoll *p = &impl->poll;
LoopData *data = source->loop_private;
PinosMainLoopImpl *impl = data->impl;
uint64_t u;
size_t offset;
InvokeItem *item;
if (read (impl->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
if (read (impl->wakeup.fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
pinos_log_warn ("main-loop %p: failed to read fd", strerror (errno));
while (spa_ringbuffer_get_read_offset (&impl->buffer, &offset) > 0) {
item = SPA_MEMBER (impl->buffer_data, offset, InvokeItem);
item->func (p, true, item->seq, item->size, item->data, item->user_data);
item->func (&impl->loop, true, item->seq, item->size, item->data, item->user_data);
spa_ringbuffer_read_advance (&impl->buffer, item->item_size);
}
return 0;
}
static SpaResult
do_invoke (SpaPoll *poll,
SpaPollInvokeFunc func,
uint32_t seq,
size_t size,
void *data,
void *user_data)
do_invoke (SpaLoop *loop,
SpaInvokeFunc func,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
PinosMainLoopImpl *impl = SPA_CONTAINER_OF (poll, PinosMainLoopImpl, poll);
PinosMainLoopImpl *impl = SPA_CONTAINER_OF (loop, PinosMainLoopImpl, loop);
bool in_thread = false;
SpaRingbufferArea areas[2];
InvokeItem *item;
@ -183,7 +187,7 @@ do_invoke (SpaPoll *poll,
SpaResult res;
if (in_thread) {
res = func (poll, false, seq, size, data, user_data);
res = func (loop, false, seq, size, data, user_data);
} else {
spa_ringbuffer_get_write_areas (&impl->buffer, areas);
if (areas[0].len < sizeof (InvokeItem)) {
@ -191,10 +195,10 @@ do_invoke (SpaPoll *poll,
return SPA_RESULT_ERROR;
}
item = SPA_MEMBER (impl->buffer_data, areas[0].offset, InvokeItem);
item->seq = seq;
item->func = func;
item->user_data = user_data;
item->seq = seq;
item->size = size;
item->user_data = user_data;
if (areas[0].len > sizeof (InvokeItem) + size) {
item->data = SPA_MEMBER (item, sizeof (InvokeItem), void);
@ -209,10 +213,14 @@ do_invoke (SpaPoll *poll,
spa_ringbuffer_write_advance (&impl->buffer, item->item_size);
if (write (impl->fds[0].fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
if (write (impl->wakeup.fd, &u, sizeof(uint64_t)) != sizeof(uint64_t))
pinos_log_warn ("data-loop %p: failed to write fd", strerror (errno));
res = SPA_RESULT_RETURN_ASYNC (seq);
if (seq != SPA_ID_INVALID)
res = SPA_RESULT_RETURN_ASYNC (seq);
else
res = SPA_RESULT_OK;
}
return res;
}
@ -360,7 +368,7 @@ main_loop_quit (PinosMainLoop *loop)
{
PinosMainLoopImpl *impl = SPA_CONTAINER_OF (loop, PinosMainLoopImpl, this);
pinos_log_debug ("main-loop %p: quit", impl);
g_main_loop_quit (impl->loop);
g_main_loop_quit (impl->main_loop);
}
static void
@ -368,7 +376,7 @@ main_loop_run (PinosMainLoop *loop)
{
PinosMainLoopImpl *impl = SPA_CONTAINER_OF (loop, PinosMainLoopImpl, this);
pinos_log_debug ("main-loop %p: run", impl);
g_main_loop_run (impl->loop);
g_main_loop_run (impl->main_loop);
}
/**
@ -396,33 +404,25 @@ pinos_main_loop_new (void)
this->defer_complete = main_loop_defer_complete;
this->sync = main_loop_sync;
impl->poll.size = sizeof (SpaPoll);
impl->poll.info = NULL;
impl->poll.add_item = do_add_item;
impl->poll.update_item = do_update_item;
impl->poll.remove_item = do_remove_item;
impl->poll.invoke = do_invoke;
this->poll = &impl->poll;
impl->loop.size = sizeof (SpaLoop);
impl->loop.add_source = do_add_source;
impl->loop.update_source = do_update_source;
impl->loop.remove_source = do_remove_source;
impl->loop.invoke = do_invoke;
this->loop = &impl->loop;
spa_list_init (&impl->work_list);
spa_list_init (&impl->free_list);
spa_ringbuffer_init (&impl->buffer, DATAS_SIZE);
impl->loop = g_main_loop_new (impl->context, false);
impl->main_loop = g_main_loop_new (impl->context, false);
impl->fds[0].fd = eventfd (0, 0);
impl->fds[0].events = POLLIN | POLLPRI | POLLERR;
impl->fds[0].revents = 0;
impl->wakeup.id = SPA_ID_INVALID;
impl->wakeup.enabled = false;
impl->wakeup.fds = impl->fds;
impl->wakeup.n_fds = 1;
impl->wakeup.idle_cb = NULL;
impl->wakeup.before_cb = NULL;
impl->wakeup.after_cb = main_loop_dispatch;
impl->wakeup.user_data = impl;
do_add_item (&impl->poll, &impl->wakeup);
impl->wakeup.func = main_loop_dispatch;
impl->wakeup.data = impl;
impl->wakeup.fd = eventfd (0, 0);
impl->wakeup.mask = SPA_IO_IN | SPA_IO_ERR;
impl->wakeup.rmask = 0;
do_add_source (&impl->loop, &impl->wakeup);
return this;
}
@ -435,9 +435,9 @@ pinos_main_loop_destroy (PinosMainLoop *loop)
pinos_log_debug ("main-loop %p: destroy", impl);
g_main_loop_unref (impl->loop);
g_main_loop_unref (impl->main_loop);
close (impl->fds[0].fd);
close (impl->wakeup.fd);
spa_list_for_each_safe (item, tmp, &impl->free_list, link)
free (item);

4
pinos/server/main-loop.h
View file

@ -24,7 +24,7 @@
extern "C" {
#endif
#include <spa/include/spa/poll.h>
#include <spa/include/spa/loop.h>
typedef struct _PinosMainLoop PinosMainLoop;
@ -39,7 +39,7 @@ typedef void (*PinosDeferFunc) (void *obj,
* Pinos main-loop interface.
*/
struct _PinosMainLoop {
SpaPoll *poll;
SpaLoop *loop;
void (*run) (PinosMainLoop *loop);
void (*quit) (PinosMainLoop *loop);

14
pinos/server/node.c
View file

@ -251,7 +251,7 @@ send_clock_update (PinosNode *this)
}
static SpaResult
do_read_link (SpaPoll *poll,
do_read_link (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -315,7 +315,7 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
continue;
link->rt.in_ready++;
spa_poll_invoke (&link->rt.input->node->data_loop->poll,
spa_loop_invoke (link->rt.input->node->data_loop->loop->loop,
do_read_link,
SPA_ID_INVALID,
sizeof (PinosLink *),
@ -348,7 +348,7 @@ on_node_event (SpaNode *node, SpaNodeEvent *event, void *user_data)
link->queue[offset] = po->buffer_id;
spa_ringbuffer_write_advance (&link->ringbuffer, 1);
spa_poll_invoke (&link->rt.input->node->data_loop->poll,
spa_loop_invoke (link->rt.input->node->data_loop->loop->loop,
do_read_link,
SPA_ID_INVALID,
sizeof (PinosLink *),
@ -473,7 +473,7 @@ pinos_node_new (PinosCore *core,
}
static SpaResult
do_node_remove_done (SpaPoll *poll,
do_node_remove_done (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -502,7 +502,7 @@ do_node_remove_done (SpaPoll *poll,
}
static SpaResult
do_node_remove (SpaPoll *poll,
do_node_remove (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -530,7 +530,7 @@ do_node_remove (SpaPoll *poll,
}
}
res = spa_poll_invoke (this->core->main_loop->poll,
res = spa_loop_invoke (this->core->main_loop->loop,
do_node_remove_done,
seq,
0,
@ -559,7 +559,7 @@ pinos_node_destroy (PinosNode * this)
spa_list_remove (&this->link);
pinos_global_destroy (this->global);
res = spa_poll_invoke (&this->data_loop->poll,
res = spa_loop_invoke (this->data_loop->loop->loop,
do_node_remove,
impl->seq++,
0,

1
pinos/server/node.h
View file

@ -31,7 +31,6 @@ typedef struct _PinosNode PinosNode;
#include <spa/include/spa/node.h>
#include <pinos/client/introspect.h>
#include <pinos/client/mem.h>
#include <pinos/client/transport.h>

22
pinos/server/port.c
View file

@ -73,7 +73,7 @@ pinos_port_destroy (PinosPort *port)
}
static SpaResult
do_add_link (SpaPoll *poll,
do_add_link (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -169,13 +169,13 @@ pinos_port_link (PinosPort *output_port,
output_node->n_used_output_links++;
input_node->n_used_input_links++;
spa_poll_invoke (&output_node->data_loop->poll,
spa_loop_invoke (output_node->data_loop->loop->loop,
do_add_link,
SPA_ID_INVALID,
sizeof (PinosLink *),
&link,
output_port);
spa_poll_invoke (&input_node->data_loop->poll,
spa_loop_invoke (input_node->data_loop->loop->loop,
do_add_link,
SPA_ID_INVALID,
sizeof (PinosLink *),
@ -210,7 +210,7 @@ pinos_port_pause (PinosPort *port)
}
static SpaResult
do_remove_link_done (SpaPoll *poll,
do_remove_link_done (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -259,7 +259,7 @@ do_remove_link_done (SpaPoll *poll,
}
static SpaResult
do_remove_link (SpaPoll *poll,
do_remove_link (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -284,7 +284,7 @@ do_remove_link (SpaPoll *poll,
pinos_port_pause (port);
#endif
res = spa_poll_invoke (this->core->main_loop->poll,
res = spa_loop_invoke (this->core->main_loop->loop,
do_remove_link_done,
seq,
sizeof (PinosLink *),
@ -301,7 +301,7 @@ pinos_port_unlink (PinosPort *port, PinosLink *link)
pinos_log_debug ("port %p: start unlink %p", port, link);
res = spa_poll_invoke (&port->node->data_loop->poll,
res = spa_loop_invoke (port->node->data_loop->loop->loop,
do_remove_link,
impl->seq++,
sizeof (PinosLink *),
@ -311,7 +311,7 @@ pinos_port_unlink (PinosPort *port, PinosLink *link)
}
static SpaResult
do_clear_buffers_done (SpaPoll *poll,
do_clear_buffers_done (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -339,7 +339,7 @@ do_clear_buffers_done (SpaPoll *poll,
}
static SpaResult
do_clear_buffers (SpaPoll *poll,
do_clear_buffers (SpaLoop *loop,
bool async,
uint32_t seq,
size_t size,
@ -352,7 +352,7 @@ do_clear_buffers (SpaPoll *poll,
pinos_port_pause (port);
res = spa_poll_invoke (node->core->main_loop->poll,
res = spa_loop_invoke (node->core->main_loop->loop,
do_clear_buffers_done,
seq,
0, NULL,
@ -367,7 +367,7 @@ pinos_port_clear_buffers (PinosPort *port)
PinosPortImpl *impl = SPA_CONTAINER_OF (port, PinosPortImpl, this);
pinos_log_debug ("port %p: clear buffers", port);
res = spa_poll_invoke (&port->node->data_loop->poll,
res = spa_loop_invoke (port->node->data_loop->loop->loop,
do_clear_buffers,
impl->seq++,
0, NULL,