summaryrefslogtreecommitdiffstats
path: root/flow/gsl/gslcommon.c
diff options
context:
space:
mode:
Diffstat (limited to 'flow/gsl/gslcommon.c')
-rw-r--r--flow/gsl/gslcommon.c1651
1 files changed, 1651 insertions, 0 deletions
diff --git a/flow/gsl/gslcommon.c b/flow/gsl/gslcommon.c
new file mode 100644
index 0000000..cb16b05
--- /dev/null
+++ b/flow/gsl/gslcommon.c
@@ -0,0 +1,1651 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+#include <string.h>
+#include <sched.h>
+#include <errno.h>
+#include <sys/poll.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#include "gslcommon.h"
+#include "gsldatacache.h"
+
+/* some systems don't have ERESTART (which is what linux returns for system
+ * calls on pipes which are being interrupted). most propably just use EINTR,
+ * and maybe some can return both. so we check for both in the below code,
+ * and alias ERESTART to EINTR if it's not present. compilers are supposed
+ * to catch and optimize the doubled check arising from this.
+ */
+#ifndef ERESTART
+#define ERESTART EINTR
+#endif
+
+
+#define PREALLOC (8)
+#define SIMPLE_CACHE_SIZE (64)
+#define TS8_SIZE (MAX (sizeof (GTrashStack), 8))
+#define DBG8_SIZE (MAX (sizeof (gsize), 8))
+
+
+/* --- variables --- */
+volatile guint64 gsl_externvar_tick_stamp = 0;
+static guint64 tick_stamp_system_time = 0;
+static guint global_tick_stamp_leaps = 0;
+static GslDebugFlags gsl_debug_flags = 0;
+
+
+/* --- memory allocation --- */
+static GslMutex global_memory = { 0, };
+static GTrashStack *simple_cache[SIMPLE_CACHE_SIZE] = { 0, 0, 0, /* ... */ };
+static gulong memory_allocated = 0;
+
+const guint
+gsl_alloc_upper_power2 (const gulong number)
+{
+ return number ? 1 << g_bit_storage (number - 1) : 0;
+}
+
+static inline gpointer
+low_alloc (gsize mem_size)
+{
+ gpointer mem;
+
+ if (mem_size >= TS8_SIZE && mem_size / 8 < SIMPLE_CACHE_SIZE)
+ {
+ guint cell;
+
+ mem_size = (mem_size + 7) & ~0x7;
+ cell = (mem_size >> 3) - 1;
+ GSL_SPIN_LOCK (&global_memory);
+ mem = g_trash_stack_pop (simple_cache + cell);
+ GSL_SPIN_UNLOCK (&global_memory);
+ if (!mem)
+ {
+ guint8 *cache_mem = g_malloc (mem_size * PREALLOC);
+ guint i;
+
+ GSL_SPIN_LOCK (&global_memory);
+ memory_allocated += mem_size * PREALLOC;
+ for (i = 0; i < PREALLOC - 1; i++)
+ {
+ g_trash_stack_push (simple_cache + cell, cache_mem);
+ cache_mem += mem_size;
+ }
+ GSL_SPIN_UNLOCK (&global_memory);
+ mem = cache_mem;
+ }
+ }
+ else
+ {
+ mem = g_malloc (mem_size);
+ GSL_SPIN_LOCK (&global_memory);
+ memory_allocated += mem_size;
+ GSL_SPIN_UNLOCK (&global_memory);
+ }
+ return mem;
+}
+
+static inline void
+low_free (gsize mem_size,
+ gpointer mem)
+{
+ if (mem_size >= TS8_SIZE && mem_size / 8 < SIMPLE_CACHE_SIZE)
+ {
+ guint cell;
+
+ mem_size = (mem_size + 7) & ~0x7;
+ cell = (mem_size >> 3) - 1;
+ GSL_SPIN_LOCK (&global_memory);
+ g_trash_stack_push (simple_cache + cell, mem);
+ GSL_SPIN_UNLOCK (&global_memory);
+ }
+ else
+ {
+ g_free (mem);
+ GSL_SPIN_LOCK (&global_memory);
+ memory_allocated -= mem_size;
+ GSL_SPIN_UNLOCK (&global_memory);
+ }
+}
+
+gpointer
+gsl_alloc_memblock (gsize block_size)
+{
+ guint8 *cmem;
+ gsize *debug_size;
+
+ g_return_val_if_fail (block_size >= sizeof (gpointer), NULL); /* cache-link size */
+
+ cmem = low_alloc (block_size + DBG8_SIZE);
+ debug_size = (gsize*) cmem;
+ *debug_size = block_size;
+ cmem += DBG8_SIZE;
+
+ return cmem;
+}
+
+void
+gsl_free_memblock (gsize block_size,
+ gpointer mem)
+{
+ gsize *debug_size;
+ guint8 *cmem;
+
+ g_return_if_fail (mem != NULL);
+
+ cmem = mem;
+ cmem -= DBG8_SIZE;
+ debug_size = (gsize*) cmem;
+ g_return_if_fail (block_size == *debug_size);
+
+ low_free (block_size + DBG8_SIZE, cmem);
+}
+
+void
+gsl_alloc_report (void)
+{
+ guint cell, cached = 0;
+
+ GSL_SPIN_LOCK (&global_memory);
+ for (cell = 0; cell < SIMPLE_CACHE_SIZE; cell++)
+ {
+ GTrashStack *trash = simple_cache[cell];
+ guint memsize, n = 0;
+
+ while (trash)
+ {
+ n++;
+ trash = trash->next;
+ }
+
+ if (n)
+ {
+ memsize = (cell + 1) << 3;
+ g_message ("cell %4u): %u bytes in %u nodes", memsize, memsize * n, n);
+ cached += memsize * n;
+ }
+ }
+ g_message ("%lu bytes allocated from system, %u bytes unused in cache", memory_allocated, cached);
+ GSL_SPIN_UNLOCK (&global_memory);
+}
+
+gpointer
+gsl_alloc_memblock0 (gsize block_size)
+{
+ gpointer mem = gsl_alloc_memblock (block_size);
+
+ memset (mem, 0, block_size);
+
+ return mem;
+}
+
+static void
+gsl_free_node_list (gpointer mem,
+ gsize node_size)
+{
+ struct { gpointer next, data; } *tmp, *node = mem;
+
+ g_return_if_fail (node != NULL);
+ g_return_if_fail (node_size >= 2 * sizeof (gpointer));
+
+ /* FIXME: this can be optimized to an O(1) operation with T-style links in mem-caches */
+ do
+ {
+ tmp = node->next;
+
+ gsl_free_memblock (node_size, node);
+ node = tmp;
+ }
+ while (node);
+}
+
+
+/* --- ring (circular-list) --- */
+static inline GslRing*
+gsl_ring_prepend_i (GslRing *head,
+ gpointer data)
+{
+ GslRing *ring = gsl_new_struct (GslRing, 1);
+
+ ring->data = data;
+ if (!head)
+ {
+ ring->prev = ring;
+ ring->next = ring;
+ }
+ else
+ {
+ ring->prev = head->prev;
+ ring->next = head;
+ head->prev->next = ring;
+ head->prev = ring;
+ }
+ return ring;
+}
+
+GslRing*
+gsl_ring_prepend (GslRing *head,
+ gpointer data)
+{
+ return gsl_ring_prepend_i (head, data);
+}
+
+GslRing*
+gsl_ring_prepend_uniq (GslRing *head,
+ gpointer data)
+{
+ GslRing *walk;
+
+ for (walk = head; walk; walk = gsl_ring_walk (head, walk))
+ if (walk->data == data)
+ return head;
+ return gsl_ring_prepend_i (head, data);
+}
+
+GslRing*
+gsl_ring_append (GslRing *head,
+ gpointer data)
+{
+ GslRing *ring;
+
+ ring = gsl_ring_prepend_i (head, data);
+
+ return head ? head : ring;
+}
+
+GslRing*
+gsl_ring_concat (GslRing *head1,
+ GslRing *head2)
+{
+ GslRing *tail1, *tail2;
+
+ if (!head1)
+ return head2;
+ if (!head2)
+ return head1;
+ tail1 = head1->prev;
+ tail2 = head2->prev;
+ head1->prev = tail2;
+ tail2->next = head1;
+ head2->prev = tail1;
+ tail1->next = head2;
+
+ return head1;
+}
+
+GslRing*
+gsl_ring_remove_node (GslRing *head,
+ GslRing *node)
+{
+ if (!head)
+ g_return_val_if_fail (head == NULL && node == NULL, NULL);
+ if (!head || !node)
+ return NULL;
+
+ /* special case one item ring */
+ if (head->prev == head)
+ {
+ g_return_val_if_fail (node == head, head);
+
+ gsl_delete_struct (GslRing, node);
+ return NULL;
+ }
+ g_return_val_if_fail (node != node->next, head); /* node can't be a one item ring here */
+
+ node->next->prev = node->prev;
+ node->prev->next = node->next;
+ if (head == node)
+ head = node->next;
+ gsl_delete_struct (GslRing, node);
+
+ return head;
+}
+
+GslRing*
+gsl_ring_remove (GslRing *head,
+ gpointer data)
+{
+ GslRing *walk;
+
+ if (!head)
+ return NULL;
+
+ /* make tail data removal an O(1) operation */
+ if (head->prev->data == data)
+ return gsl_ring_remove_node (head, head->prev);
+
+ for (walk = head; walk; walk = gsl_ring_walk (head, walk))
+ if (walk->data == data)
+ return gsl_ring_remove_node (head, walk);
+
+ g_warning (G_STRLOC ": couldn't find data item (%p) to remove from ring (%p)", data, head);
+
+ return head;
+}
+
+guint
+gsl_ring_length (GslRing *head)
+{
+ GslRing *ring;
+ guint i = 0;
+
+ for (ring = head; ring; ring = gsl_ring_walk (head, ring))
+ i++;
+
+ return i;
+}
+
+GslRing*
+gsl_ring_find (GslRing *head,
+ gconstpointer data)
+{
+ GslRing *ring;
+
+ for (ring = head; ring; ring = gsl_ring_walk (head, ring))
+ if (ring->data == (gpointer) data)
+ return ring;
+
+ return NULL;
+}
+
+GslRing*
+gsl_ring_nth (GslRing *head,
+ guint n)
+{
+ GslRing *ring = head;
+
+ while (n-- && ring)
+ ring = gsl_ring_walk (head, ring);
+
+ return ring;
+}
+
+gpointer
+gsl_ring_nth_data (GslRing *head,
+ guint n)
+{
+ GslRing *ring = head;
+
+ while (n-- && ring)
+ ring = gsl_ring_walk (head, ring);
+
+ return ring ? ring->data : ring;
+}
+
+void
+gsl_ring_free (GslRing *head)
+{
+ if (head)
+ {
+ head->prev->next = NULL;
+ gsl_free_node_list (head, sizeof (*head));
+ }
+}
+
+gpointer
+gsl_ring_pop_head (GslRing **head_p)
+{
+ gpointer data;
+
+ g_return_val_if_fail (head_p != NULL, NULL);
+
+ if (!*head_p)
+ return NULL;
+ data = (*head_p)->data;
+ *head_p = gsl_ring_remove_node (*head_p, *head_p);
+
+ return data;
+}
+
+gpointer
+gsl_ring_pop_tail (GslRing **head_p)
+{
+ gpointer data;
+
+ g_return_val_if_fail (head_p != NULL, NULL);
+
+ if (!*head_p)
+ return NULL;
+ data = (*head_p)->prev->data;
+ *head_p = gsl_ring_remove_node (*head_p, (*head_p)->prev);
+
+ return data;
+}
+
+GslRing*
+gsl_ring_insert_sorted (GslRing *head,
+ gpointer data,
+ GCompareFunc func)
+{
+ gint cmp;
+
+ g_return_val_if_fail (func != NULL, head);
+
+ if (!head)
+ return gsl_ring_prepend (head, data);
+
+ /* typedef gint (*GCompareFunc) (gconstpointer a,
+ * gconstpointer b);
+ */
+ cmp = func (data, head->data);
+
+ if (cmp >= 0) /* insert after head */
+ {
+ GslRing *tmp, *tail = head->prev;
+
+ /* make appending an O(1) operation */
+ if (head == tail || func (data, tail->data) >= 0)
+ return gsl_ring_append (head, data);
+
+ /* walk forward while data >= tmp (skipping equal nodes) */
+ for (tmp = head->next; tmp != tail; tmp = tmp->next)
+ if (func (data, tmp->data) < 0)
+ break;
+
+ /* insert before sibling which is greater than data */
+ gsl_ring_prepend (tmp, data); /* keep current head */
+ return head;
+ }
+ else /* cmp < 0 */
+ return gsl_ring_prepend (head, data);
+}
+
+
+/* --- GslThread --- */
+typedef struct
+{
+ GslThreadFunc func;
+ gpointer data;
+ gint wpipe[2];
+ volatile gint abort;
+ guint64 awake_stamp;
+ GslDebugFlags auxlog_reporter;
+ const gchar *auxlog_section;
+} ThreadData;
+static GslMutex global_thread = { 0, };
+static GslRing *global_thread_list = NULL;
+static GslCond global_thread_cond = { 0, };
+static GslRing *awake_tdata_list = NULL;
+static ThreadData *main_thread_tdata = NULL;
+static GslThread *main_thread = NULL;
+
+static inline ThreadData*
+thread_data_from_gsl_thread (GslThread *thread)
+{
+ GThread *gthread = (GThread*) thread;
+
+ /* if gthread->data==NULL, we assume this is the main thread */
+
+ return gthread->data ? gthread->data : main_thread_tdata;
+}
+
+static gpointer
+thread_wrapper (gpointer arg)
+{
+ GslThread *self = gsl_thread_self ();
+ ThreadData *tdata = arg;
+
+ g_assert (tdata == thread_data_from_gsl_thread (gsl_thread_self ()));
+
+ GSL_SYNC_LOCK (&global_thread);
+ global_thread_list = gsl_ring_prepend (global_thread_list, self);
+ gsl_cond_broadcast (&global_thread_cond);
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ tdata->func (tdata->data);
+
+ GSL_SYNC_LOCK (&global_thread);
+ global_thread_list = gsl_ring_remove (global_thread_list, self);
+ if (tdata->awake_stamp)
+ awake_tdata_list = gsl_ring_remove (awake_tdata_list, tdata);
+ gsl_cond_broadcast (&global_thread_cond);
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ close (tdata->wpipe[0]);
+ tdata->wpipe[0] = -1;
+ close (tdata->wpipe[1]);
+ tdata->wpipe[1] = -1;
+ gsl_delete_struct (ThreadData, tdata);
+
+ return NULL;
+}
+
+static ThreadData*
+create_tdata (void)
+{
+ ThreadData *tdata;
+ glong d_long;
+ gint error;
+
+ tdata = gsl_new_struct0 (ThreadData, 1);
+ tdata->func = NULL;
+ tdata->data = NULL;
+ tdata->wpipe[0] = -1;
+ tdata->wpipe[1] = -1;
+ tdata->abort = FALSE;
+ tdata->auxlog_reporter = 0;
+ tdata->auxlog_section = NULL;
+ error = pipe (tdata->wpipe);
+ if (error == 0)
+ {
+ d_long = fcntl (tdata->wpipe[0], F_GETFL, 0);
+ /* g_printerr ("pipe-readfd, blocking=%ld\n", d_long & O_NONBLOCK); */
+ d_long |= O_NONBLOCK;
+ error = fcntl (tdata->wpipe[0], F_SETFL, d_long);
+ }
+ if (error == 0)
+ {
+ d_long = fcntl (tdata->wpipe[1], F_GETFL, 0);
+ /* g_printerr ("pipe-writefd, blocking=%ld\n", d_long & O_NONBLOCK); */
+ d_long |= O_NONBLOCK;
+ error = fcntl (tdata->wpipe[1], F_SETFL, d_long);
+ }
+ if (error)
+ {
+ close (tdata->wpipe[0]);
+ close (tdata->wpipe[1]);
+ gsl_delete_struct (ThreadData, tdata);
+ tdata = NULL;
+ }
+ return tdata;
+}
+
+GslThread*
+gsl_thread_new (GslThreadFunc func,
+ gpointer user_data)
+{
+ gpointer gthread = NULL;
+ ThreadData *tdata;
+ GError *gerror = NULL;
+
+ g_return_val_if_fail (func != NULL, FALSE);
+
+ tdata = create_tdata ();
+
+ if (tdata)
+ {
+ const gboolean joinable = FALSE;
+
+ /* don't dare setting joinable to TRUE, that prevents the thread's
+ * resources from being freed, since we don't offer pthread_join().
+ * so we'd just rn out of stack at some point.
+ */
+ tdata->func = func;
+ tdata->data = user_data;
+ gthread = g_thread_create_full (thread_wrapper, tdata, 0, joinable, FALSE,
+ G_THREAD_PRIORITY_NORMAL, &gerror);
+ }
+
+ if (gthread)
+ {
+ GSL_SYNC_LOCK (&global_thread);
+ while (!gsl_ring_find (global_thread_list, gthread))
+ gsl_cond_wait (&global_thread_cond, &global_thread);
+ GSL_SYNC_UNLOCK (&global_thread);
+ }
+ else
+ {
+ if (tdata)
+ {
+ close (tdata->wpipe[0]);
+ close (tdata->wpipe[1]);
+ gsl_delete_struct (ThreadData, tdata);
+ }
+ g_warning ("Failed to create thread: %s", gerror->message);
+ g_error_free (gerror);
+ }
+
+ return gthread;
+}
+
+GslThread*
+gsl_thread_self (void)
+{
+ gpointer gthread = g_thread_self ();
+
+ if (!gthread)
+ g_error ("gsl_thread_self() failed");
+
+ return gthread;
+}
+
+GslThread*
+gsl_thread_main (void)
+{
+ return main_thread;
+}
+
+guint
+gsl_threads_get_count (void)
+{
+ guint count;
+
+ GSL_SYNC_LOCK (&global_thread);
+ count = gsl_ring_length (global_thread_list);
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ return count;
+}
+
+static void
+thread_wakeup_I (ThreadData *tdata)
+{
+ guint8 data = 'W';
+ gint r;
+
+ do
+ r = write (tdata->wpipe[1], &data, 1);
+ while (r < 0 && (errno == EINTR || errno == ERESTART));
+}
+
+/**
+ * gsl_thread_wakeup
+ * @thread: thread to wake up
+ * Wake up a currently sleeping thread. In practice, this
+ * function simply causes the next call to gsl_thread_sleep()
+ * within @thread to last for 0 seconds.
+ */
+void
+gsl_thread_wakeup (GslThread *thread)
+{
+ ThreadData *tdata;
+
+ g_return_if_fail (thread != NULL);
+
+ GSL_SYNC_LOCK (&global_thread);
+ g_assert (gsl_ring_find (global_thread_list, thread));
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ tdata = thread_data_from_gsl_thread (thread);
+ thread_wakeup_I (tdata);
+}
+
+/**
+ * gsl_thread_abort
+ * @thread: thread to abort
+ * Abort a currently running thread. This function does not
+ * return until the thread in question terminated execution.
+ * Note that the thread handle gets invalidated with invocation
+ * of gsl_thread_abort() or gsl_thread_queue_abort().
+ */
+void
+gsl_thread_abort (GslThread *thread)
+{
+ ThreadData *tdata;
+
+ g_return_if_fail (thread != NULL);
+ g_return_if_fail (thread != main_thread);
+
+ GSL_SYNC_LOCK (&global_thread);
+ g_assert (gsl_ring_find (global_thread_list, thread));
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ tdata = thread_data_from_gsl_thread (thread);
+
+ GSL_SYNC_LOCK (&global_thread);
+ tdata->abort = TRUE;
+ thread_wakeup_I (tdata);
+
+ while (gsl_ring_find (global_thread_list, thread))
+ gsl_cond_wait (&global_thread_cond, &global_thread);
+ GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_thread_queue_abort
+ * @thread: thread to abort
+ * Same as gsl_thread_abort(), but returns as soon as possible,
+ * even if thread hasn't stopped execution yet.
+ * Note that the thread handle gets invalidated with invocation
+ * of gsl_thread_abort() or gsl_thread_queue_abort().
+ */
+void
+gsl_thread_queue_abort (GslThread *thread)
+{
+ ThreadData *tdata;
+
+ g_return_if_fail (thread != NULL);
+ g_return_if_fail (thread != main_thread);
+
+ GSL_SYNC_LOCK (&global_thread);
+ g_assert (gsl_ring_find (global_thread_list, thread));
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ tdata = thread_data_from_gsl_thread (thread);
+
+ GSL_SYNC_LOCK (&global_thread);
+ tdata->abort = TRUE;
+ thread_wakeup_I (tdata);
+ GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_thread_aborted
+ * @returns: %TRUE if the thread should abort execution
+ * Find out if the currently running thread should be aborted (the thread is
+ * supposed to return from its main thread function).
+ */
+gboolean
+gsl_thread_aborted (void)
+{
+ ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+ gboolean aborted;
+
+ GSL_SYNC_LOCK (&global_thread);
+ aborted = tdata->abort != FALSE;
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ return aborted;
+}
+
+/**
+ * gsl_thread_sleep
+ * @max_msec: maximum amount of milli seconds to sleep (-1 for infinite time)
+ * @returns: %TRUE if the thread should continue execution
+ * Sleep for the amount of time given. This function may get interrupted
+ * by wakeup or abort requests, it returns whether the thread is supposed
+ * to continue execution after waking up. This function also processes
+ * remaining data from the thread's poll fd.
+ */
+gboolean
+gsl_thread_sleep (glong max_msec)
+{
+ ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+ struct pollfd pfd;
+ gint r, aborted;
+
+ pfd.fd = tdata->wpipe[0];
+ pfd.events = G_IO_IN;
+ pfd.revents = 0;
+
+ r = poll (&pfd, 1, max_msec);
+
+ if (r < 0 && errno != EINTR)
+ g_message (G_STRLOC ": poll() error: %s\n", g_strerror (errno));
+ else if (pfd.revents & G_IO_IN)
+ {
+ guint8 data[64];
+
+ do
+ r = read (tdata->wpipe[0], data, sizeof (data));
+ while ((r < 0 && (errno == EINTR || errno == ERESTART)) || r == sizeof (data));
+ }
+
+ GSL_SYNC_LOCK (&global_thread);
+ aborted = tdata->abort != FALSE;
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ return !aborted;
+}
+
+/**
+ * gsl_thread_awake_after
+ * RETURNS: GPollFD for the current thread
+ * Get the GPollfd for the current thread which is used
+ * to signal thread wakeups (e.g. due to
+ * gsl_thread_abort() or gsl_thread_wakeup()).
+ */
+void
+gsl_thread_get_pollfd (GPollFD *pfd)
+{
+ ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+
+ pfd->fd = tdata->wpipe[0];
+ pfd->events = G_IO_IN;
+ pfd->revents = 0;
+}
+
+/**
+ * gsl_thread_awake_after
+ * @tick_stamp: tick stamp update to trigger wakeup
+ * Wakeup the currently running thread after the global tick stamp
+ * (see gsl_tick_stamp()) has been updated to @tick_stamp.
+ * (If the moment of wakeup has already passed by, the thread is
+ * woken up at the next global tick stamp update.)
+ */
+void
+gsl_thread_awake_after (guint64 tick_stamp)
+{
+ ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+
+ g_return_if_fail (tick_stamp > 0);
+
+ GSL_SYNC_LOCK (&global_thread);
+ if (!tdata->awake_stamp)
+ {
+ awake_tdata_list = gsl_ring_prepend (awake_tdata_list, tdata);
+ tdata->awake_stamp = tick_stamp;
+ }
+ else
+ tdata->awake_stamp = MIN (tdata->awake_stamp, tick_stamp);
+ GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_thread_awake_before
+ * @tick_stamp: tick stamp update to trigger wakeup
+ * Wakeup the currently running thread upon the last global tick stamp
+ * update (see gsl_tick_stamp()) that happens prior to updating the
+ * global tick stamp to @tick_stamp.
+ * (If the moment of wakeup has already passed by, the thread is
+ * woken up at the next global tick stamp update.)
+ */
+void
+gsl_thread_awake_before (guint64 tick_stamp)
+{
+ g_return_if_fail (tick_stamp > 0);
+
+ if (tick_stamp > global_tick_stamp_leaps)
+ gsl_thread_awake_after (tick_stamp - global_tick_stamp_leaps);
+ else
+ gsl_thread_awake_after (tick_stamp);
+}
+
+/**
+ * gsl_tick_stamp
+ * @RETURNS: GSL's execution tick stamp as unsigned 64bit integer
+ *
+ * Retrive the GSL global tick stamp.
+ * GSL increments its global tick stamp at certain intervals,
+ * by specific amounts (refer to gsl_engine_init() for further
+ * details). The tick stamp is a non-wrapping, unsigned 64bit
+ * integer greater than 0. Threads can schedule sleep interruptions
+ * at certain tick stamps with gsl_thread_awake_after() and
+ * gsl_thread_awake_before(). Tick stamp updating occours at
+ * GSL engine block processing boundaries, so code that can
+ * guarantee to not run across those boundaries (for instance
+ * GslProcessFunc() functions) may use the macro %GSL_TICK_STAMP
+ * to retrive the current tick in a faster manner (not involving
+ * mutex locking). See also gsl_module_tick_stamp().
+ * This function is MT-safe and may be called from any thread.
+ */
+guint64
+gsl_tick_stamp (void)
+{
+ guint64 stamp;
+
+ GSL_SYNC_LOCK (&global_thread);
+ stamp = gsl_externvar_tick_stamp;
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ return stamp;
+}
+
+void
+_gsl_tick_stamp_set_leap (guint ticks)
+{
+ GSL_SYNC_LOCK (&global_thread);
+ global_tick_stamp_leaps = ticks;
+ GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_time_system
+ * @RETURNS: Current system time in micro seconds
+ *
+ * Get the current system time in micro seconds.
+ * Subsequent calls to this function do not necessarily
+ * return growing values. In fact, a second call may return
+ * a value smaller than the first call under certainsystem
+ * conditions.
+ * This function is MT-safe and may be called from any thread.
+ */
+guint64
+gsl_time_system (void)
+{
+ struct timeval tv;
+ guint64 csys_time;
+ gint error;
+
+ error = gettimeofday (&tv, NULL);
+ if (error)
+ g_error ("gettimeofday() failed: %s", g_strerror (errno));
+ csys_time = tv.tv_sec;
+ csys_time = csys_time * 1000000 + tv.tv_usec;
+
+ return csys_time;
+}
+
+/**
+ * gsl_tick_stamp_last
+ * @RETURNS: Current tick stamp and system time in micro seconds
+ *
+ * Get the system time of the last GSL global tick stamp update.
+ * This function is MT-safe and may be called from any thread.
+ */
+GslTickStampUpdate
+gsl_tick_stamp_last (void)
+{
+ GslTickStampUpdate ustamp;
+
+ GSL_SYNC_LOCK (&global_thread);
+ ustamp.tick_stamp = gsl_externvar_tick_stamp;
+ ustamp.system_time = tick_stamp_system_time;
+ GSL_SYNC_UNLOCK (&global_thread);
+
+ return ustamp;
+}
+
+void
+_gsl_tick_stamp_inc (void)
+{
+ volatile guint64 newstamp;
+ GslRing *ring;
+ guint64 systime;
+
+ g_return_if_fail (global_tick_stamp_leaps > 0);
+
+ systime = gsl_time_system ();
+ newstamp = gsl_externvar_tick_stamp + global_tick_stamp_leaps;
+
+ GSL_SYNC_LOCK (&global_thread);
+ gsl_externvar_tick_stamp = newstamp;
+ tick_stamp_system_time = systime;
+ for (ring = awake_tdata_list; ring; )
+ {
+ ThreadData *tdata = ring->data;
+
+ if (tdata->awake_stamp <= GSL_TICK_STAMP)
+ {
+ GslRing *next = gsl_ring_walk (awake_tdata_list, ring);
+
+ tdata->awake_stamp = 0;
+ awake_tdata_list = gsl_ring_remove (awake_tdata_list, tdata);
+
+ thread_wakeup_I (tdata);
+ ring = next;
+ }
+ else
+ ring = gsl_ring_walk (awake_tdata_list, ring);
+ }
+ GSL_SYNC_UNLOCK (&global_thread);
+}
+
+
+/* --- GslMutex --- */
+static gboolean is_smp_system = FALSE;
+
+static void
+default_mutex_init (GslMutex *mutex)
+{
+ g_return_if_fail (mutex != NULL);
+
+ mutex->mutex_pointer = g_mutex_new ();
+}
+
+static int
+default_mutex_trylock (GslMutex *mutex)
+{
+ return g_mutex_trylock (mutex->mutex_pointer) ? 0 : -1;
+}
+
+static void
+default_mutex_lock (GslMutex *mutex)
+{
+ /* spin locks should be held only very short times,
+ * so frequently we should succeed here
+ */
+ if (g_mutex_trylock (mutex->mutex_pointer))
+ return;
+
+ if (!is_smp_system)
+ {
+ /* on uni processor systems, there's no point in busy spinning */
+ do
+ {
+#if defined(_POSIX_PRIORITY_SCHEDULING)
+ sched_yield ();
+#endif
+ if (g_mutex_trylock (mutex->mutex_pointer))
+ return;
+ }
+ while (TRUE);
+ }
+ else
+ {
+ /* for multi processor systems, mutex_lock() is hopefully implemented
+ * via spinning. note that we can't implement spinning ourselves with
+ * mutex_trylock(), since on some architectures that'd block memory
+ * bandwith due to constant bus locks
+ */
+ g_mutex_lock (mutex->mutex_pointer);
+ }
+}
+
+static void
+default_mutex_unlock (GslMutex *mutex)
+{
+ g_mutex_unlock (mutex->mutex_pointer);
+}
+
+static void
+default_mutex_destroy (GslMutex *mutex)
+{
+ g_mutex_free (mutex->mutex_pointer);
+ memset (mutex, 0, sizeof (*mutex));
+}
+
+static void
+default_rec_mutex_init (GslRecMutex *rec_mutex)
+{
+ rec_mutex->depth = 0;
+ rec_mutex->owner = NULL;
+ gsl_mutex_init (&rec_mutex->sync_mutex);
+}
+
+static int
+default_rec_mutex_trylock (GslRecMutex *rec_mutex)
+{
+ gpointer self = gsl_thread_self ();
+
+ if (rec_mutex->owner == self)
+ {
+ g_assert (rec_mutex->depth > 0); /* paranoid */
+ rec_mutex->depth += 1;
+ return 0;
+ }
+ else
+ {
+ if (gsl_mutex_trylock (&rec_mutex->sync_mutex))
+ {
+ g_assert (rec_mutex->owner == NULL && rec_mutex->depth == 0); /* paranoid */
+ rec_mutex->owner = self;
+ rec_mutex->depth = 1;
+ return 0;
+ }
+ }
+ return -1;
+}
+
+static void
+default_rec_mutex_lock (GslRecMutex *rec_mutex)
+{
+ gpointer self = gsl_thread_self ();
+
+ if (rec_mutex->owner == self)
+ {
+ g_assert (rec_mutex->depth > 0); /* paranoid */
+ rec_mutex->depth += 1;
+ }
+ else
+ {
+ GSL_SYNC_LOCK (&rec_mutex->sync_mutex);
+ g_assert (rec_mutex->owner == NULL && rec_mutex->depth == 0); /* paranoid */
+ rec_mutex->owner = self;
+ rec_mutex->depth = 1;
+ }
+}
+
+static void
+default_rec_mutex_unlock (GslRecMutex *rec_mutex)
+{
+ gpointer self = gsl_thread_self ();
+
+ if (rec_mutex->owner == self && rec_mutex->depth > 0)
+ {
+ rec_mutex->depth -= 1;
+ if (!rec_mutex->depth)
+ {
+ rec_mutex->owner = NULL;
+ GSL_SYNC_UNLOCK (&rec_mutex->sync_mutex);
+ }
+ }
+ else
+ g_warning ("unable to unlock recursive mutex with self %p != %p or depth %u < 1",
+ rec_mutex->owner, self, rec_mutex->depth);
+}
+
+static void
+default_rec_mutex_destroy (GslRecMutex *rec_mutex)
+{
+ if (rec_mutex->owner || rec_mutex->depth)
+ {
+ g_warning (G_STRLOC ": recursive mutex still locked during destruction");
+ return;
+ }
+ gsl_mutex_destroy (&rec_mutex->sync_mutex);
+ g_assert (rec_mutex->owner == NULL && rec_mutex->depth == 0);
+}
+
+static void
+default_cond_init (GslCond *cond)
+{
+ cond->cond_pointer = g_cond_new ();
+}
+
+static void
+default_cond_wait (GslCond *cond,
+ GslMutex *mutex)
+{
+ /* infinite wait */
+ g_cond_wait (cond->cond_pointer, mutex->mutex_pointer);
+}
+
+static void
+default_cond_signal (GslCond *cond)
+{
+ g_cond_signal (cond->cond_pointer);
+}
+
+static void
+default_cond_broadcast (GslCond *cond)
+{
+ g_cond_broadcast (cond->cond_pointer);
+}
+
+static void
+default_cond_destroy (GslCond *cond)
+{
+ g_cond_free (cond->cond_pointer);
+}
+
+static void
+default_cond_wait_timed (GslCond *cond,
+ GslMutex *mutex,
+ gulong abs_secs,
+ gulong abs_usecs)
+{
+ GTimeVal gtime;
+
+ gtime.tv_sec = abs_secs;
+ gtime.tv_usec = abs_usecs;
+ g_cond_timed_wait (cond->cond_pointer, mutex->mutex_pointer, &gtime);
+}
+
+GslMutexTable gsl_mutex_table = {
+ default_mutex_init,
+ default_mutex_lock,
+ default_mutex_trylock,
+ default_mutex_unlock,
+ default_mutex_destroy,
+ default_rec_mutex_init,
+ default_rec_mutex_lock,
+ default_rec_mutex_trylock,
+ default_rec_mutex_unlock,
+ default_rec_mutex_destroy,
+ default_cond_init,
+ default_cond_signal,
+ default_cond_broadcast,
+ default_cond_wait,
+ default_cond_wait_timed,
+ default_cond_destroy,
+};
+
+void
+gsl_cond_wait_timed (GslCond *cond,
+ GslMutex *mutex,
+ glong max_useconds)
+{
+ if (max_useconds < 0)
+ gsl_cond_wait (cond, mutex);
+ else
+ {
+ struct timeval now;
+ glong secs;
+
+ gettimeofday (&now, NULL);
+ secs = max_useconds / 1000000;
+ now.tv_sec += secs;
+ max_useconds -= secs * 1000000;
+ now.tv_usec += max_useconds;
+ if (now.tv_usec >= 1000000)
+ {
+ now.tv_usec -= 1000000;
+ now.tv_sec += 1;
+ }
+
+ /* linux on x86 with pthread has actually 10ms resolution */
+ gsl_mutex_table.cond_wait_timed (cond, mutex, now.tv_sec, now.tv_usec);
+ }
+}
+
+
+/* --- GslMessage --- */
+const gchar*
+gsl_strerror (GslErrorType error)
+{
+ switch (error)
+ {
+ case GSL_ERROR_NONE: return "Everything went well";
+ case GSL_ERROR_INTERNAL: return "Internal error (please report)";
+ case GSL_ERROR_UNKNOWN: return "Unknown error";
+ case GSL_ERROR_IO: return "I/O error";
+ case GSL_ERROR_PERMS: return "Insufficient permission";
+ case GSL_ERROR_BUSY: return "Resource currently busy";
+ case GSL_ERROR_EXISTS: return "Resource exists already";
+ case GSL_ERROR_TEMP: return "Temporary error";
+ case GSL_ERROR_EOF: return "File empty or premature EOF";
+ case GSL_ERROR_NOT_FOUND: return "Resource not found";
+ case GSL_ERROR_OPEN_FAILED: return "Open failed";
+ case GSL_ERROR_SEEK_FAILED: return "Seek failed";
+ case GSL_ERROR_READ_FAILED: return "Read failed";
+ case GSL_ERROR_WRITE_FAILED: return "Write failed";
+ case GSL_ERROR_FORMAT_INVALID: return "Invalid format";
+ case GSL_ERROR_FORMAT_UNKNOWN: return "Unknown format";
+ case GSL_ERROR_DATA_CORRUPT: return "Data corrupt";
+ case GSL_ERROR_CONTENT_GLITCH: return "Data glitch (junk) detected";
+ case GSL_ERROR_NO_RESOURCE: return "Out of memory, disk space or similar resource";
+ case GSL_ERROR_CODEC_FAILURE: return "CODEC failure";
+ default: return NULL;
+ }
+}
+
+static const GDebugKey gsl_static_debug_keys[] = {
+ { "notify", GSL_MSG_NOTIFY },
+ { "dcache", GSL_MSG_DATA_CACHE },
+ { "dhandle", GSL_MSG_DATA_HANDLE },
+ { "loader", GSL_MSG_LOADER },
+ { "osc", GSL_MSG_OSC },
+ { "engine", GSL_MSG_ENGINE },
+ { "jobs", GSL_MSG_JOBS },
+ { "fjobs", GSL_MSG_FJOBS },
+ { "sched", GSL_MSG_SCHED },
+ { "master", GSL_MSG_MASTER },
+ { "slave", GSL_MSG_SLAVE },
+};
+
+static const gchar*
+reporter_name (GslDebugFlags reporter)
+{
+ switch (reporter)
+ {
+ case GSL_MSG_NOTIFY: return "Notify";
+ case GSL_MSG_DATA_CACHE: return "DataCache";
+ case GSL_MSG_DATA_HANDLE: return "DataHandle";
+ case GSL_MSG_LOADER: return "Loader";
+ case GSL_MSG_OSC: return "Oscillator";
+ case GSL_MSG_ENGINE: return "Engine"; /* Engine */
+ case GSL_MSG_JOBS: return "Jobs"; /* Engine */
+ case GSL_MSG_FJOBS: return "FlowJobs"; /* Engine */
+ case GSL_MSG_SCHED: return "Sched"; /* Engine */
+ case GSL_MSG_MASTER: return "Master"; /* Engine */
+ case GSL_MSG_SLAVE: return "Slave"; /* Engine */
+ default: return "Custom";
+ }
+}
+
+const GDebugKey *gsl_debug_keys = gsl_static_debug_keys;
+const guint gsl_n_debug_keys = G_N_ELEMENTS (gsl_static_debug_keys);
+
+void
+gsl_message_send (GslDebugFlags reporter,
+ const gchar *section,
+ GslErrorType error,
+ const gchar *messagef,
+ ...)
+{
+ struct {
+ GslDebugFlags reporter;
+ gchar reporter_name[64];
+ gchar section[64]; /* auxillary information about reporter code portion */
+ GslErrorType error;
+ const gchar *error_str; /* gsl_strerror() of error */
+ gchar message[1024];
+ } tmsg, *msg = &tmsg;
+ gchar *string;
+ va_list args;
+
+ g_return_if_fail (messagef != NULL);
+
+ /* create message */
+ memset (msg, 0, sizeof (*msg));
+ msg->reporter = reporter;
+ strncpy (msg->reporter_name, reporter_name (msg->reporter), 63);
+ if (section)
+ strncpy (msg->section, section, 63);
+ msg->error = error;
+ msg->error_str = error ? gsl_strerror (msg->error) : NULL;
+
+ /* vsnprintf() replacement */
+ va_start (args, messagef);
+ string = g_strdup_vprintf (messagef, args);
+ va_end (args);
+ strncpy (msg->message, string, 1023);
+ g_free (string);
+
+ /* in current lack of a decent message queue, puke the message to stderr */
+ g_printerr ("GSL-%s%s%s: %s%s%s\n",
+ msg->reporter_name,
+ msg->section ? ":" : "",
+ msg->section ? msg->section : "",
+ msg->message,
+ msg->error_str ? ": " : "",
+ msg->error_str ? msg->error_str : "");
+}
+
+void
+gsl_debug_enable (GslDebugFlags dbg_flags)
+{
+ gsl_debug_flags |= dbg_flags;
+}
+
+void
+gsl_debug_disable (GslDebugFlags dbg_flags)
+{
+ gsl_debug_flags &= dbg_flags;
+}
+
+gboolean
+gsl_debug_check (GslDebugFlags dbg_flags)
+{
+ return (gsl_debug_flags & dbg_flags) != 0;
+}
+
+void
+gsl_debug (GslDebugFlags reporter,
+ const gchar *section,
+ const gchar *format,
+ ...)
+{
+ g_return_if_fail (format != NULL);
+
+ if (reporter & gsl_debug_flags)
+ {
+ va_list args;
+ gchar *string;
+
+ va_start (args, format);
+ string = g_strdup_vprintf (format, args);
+ va_end (args);
+ g_printerr ("DEBUG:GSL-%s%s%s: %s\n",
+ reporter_name (reporter),
+ section ? ":" : "",
+ section ? section : "",
+ string);
+ g_free (string);
+ }
+}
+
+void
+gsl_auxlog_push (GslDebugFlags reporter,
+ const gchar *section)
+{
+ ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+
+ if (tdata)
+ {
+ tdata->auxlog_reporter = reporter;
+ tdata->auxlog_section = section;
+ }
+}
+
+void
+gsl_auxlog_debug (const gchar *format,
+ ...)
+{
+ ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+ GslDebugFlags reporter = GSL_MSG_NOTIFY;
+ const gchar *section = NULL;
+ va_list args;
+ gchar *string;
+
+ if (tdata)
+ {
+ reporter = tdata->auxlog_reporter;
+ section = tdata->auxlog_section;
+ tdata->auxlog_reporter = 0;
+ tdata->auxlog_section = NULL;
+ }
+
+ g_return_if_fail (format != NULL);
+
+ va_start (args, format);
+ string = g_strdup_vprintf (format, args);
+ va_end (args);
+ gsl_debug (reporter, section, "%s", string);
+ g_free (string);
+}
+
+void
+gsl_auxlog_message (GslErrorType error,
+ const gchar *format,
+ ...)
+{
+ ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+ GslDebugFlags reporter = GSL_MSG_NOTIFY;
+ const gchar *section = NULL;
+ va_list args;
+ gchar *string;
+
+ if (tdata)
+ {
+ reporter = tdata->auxlog_reporter;
+ section = tdata->auxlog_section;
+ tdata->auxlog_reporter = 0;
+ tdata->auxlog_section = NULL;
+ }
+
+ g_return_if_fail (format != NULL);
+
+ va_start (args, format);
+ string = g_strdup_vprintf (format, args);
+ va_end (args);
+ gsl_message_send (reporter, section, error, "%s", string);
+ g_free (string);
+}
+
+
+/* --- misc --- */
+const gchar*
+gsl_byte_order_to_string (guint byte_order)
+{
+ g_return_val_if_fail (byte_order == G_LITTLE_ENDIAN || byte_order == G_BIG_ENDIAN, NULL);
+
+ if (byte_order == G_LITTLE_ENDIAN)
+ return "little_endian";
+ if (byte_order == G_BIG_ENDIAN)
+ return "big_endian";
+
+ return NULL;
+}
+
+guint
+gsl_byte_order_from_string (const gchar *string)
+{
+ g_return_val_if_fail (string != NULL, 0);
+
+ while (*string == ' ')
+ string++;
+ if (strncasecmp (string, "little", 6) == 0)
+ return G_LITTLE_ENDIAN;
+ if (strncasecmp (string, "big", 3) == 0)
+ return G_BIG_ENDIAN;
+ return 0;
+}
+
+GslErrorType
+gsl_check_file (const gchar *file_name,
+ const gchar *mode)
+{
+ guint access_mask = 0;
+ guint check_file, check_dir, check_link;
+
+ if (strchr (mode, 'r')) /* readable */
+ access_mask |= R_OK;
+ if (strchr (mode, 'w')) /* writable */
+ access_mask |= W_OK;
+ if (strchr (mode, 'x')) /* executable */
+ access_mask |= X_OK;
+
+ if (access_mask && access (file_name, access_mask) < 0)
+ goto have_errno;
+
+ check_file = strchr (mode, 'f') != NULL; /* open as file */
+ check_dir = strchr (mode, 'd') != NULL; /* open as directory */
+ check_link = strchr (mode, 'l') != NULL; /* open as link */
+
+ if (check_file || check_dir || check_link)
+ {
+ struct stat st;
+
+ if (check_link)
+ {
+ if (lstat (file_name, &st) < 0)
+ goto have_errno;
+ }
+ else if (stat (file_name, &st) < 0)
+ goto have_errno;
+
+ if ((check_file && !S_ISREG (st.st_mode)) ||
+ (check_dir && !S_ISDIR (st.st_mode)) ||
+ (check_link && !S_ISLNK (st.st_mode)))
+ return GSL_ERROR_OPEN_FAILED;
+ }
+
+ return GSL_ERROR_NONE;
+
+ have_errno:
+ return gsl_error_from_errno (errno, GSL_ERROR_OPEN_FAILED);
+}
+
+GslErrorType
+gsl_error_from_errno (gint sys_errno,
+ GslErrorType fallback)
+{
+ switch (sys_errno)
+ {
+ case ELOOP:
+ case ENAMETOOLONG:
+ case ENOTDIR:
+ case ENOENT: return GSL_ERROR_NOT_FOUND;
+ case EROFS:
+ case EPERM:
+ case EACCES: return GSL_ERROR_PERMS;
+ case ENOMEM:
+ case ENOSPC:
+ case EFBIG:
+ case ENFILE:
+ case EMFILE: return GSL_ERROR_NO_RESOURCE;
+ case EISDIR:
+ case ESPIPE:
+ case EIO: return GSL_ERROR_IO;
+ case EEXIST: return GSL_ERROR_EXISTS;
+ case ETXTBSY:
+ case EBUSY: return GSL_ERROR_BUSY;
+ case EAGAIN:
+ case EINTR: return GSL_ERROR_TEMP;
+ case EINVAL:
+ case EFAULT:
+ case EBADF: return GSL_ERROR_INTERNAL;
+ default: return fallback;
+ }
+}
+
+
+/* --- global initialization --- */
+static guint
+get_n_processors (void)
+{
+#ifdef _SC_NPROCESSORS_ONLN
+ {
+ gint n = sysconf (_SC_NPROCESSORS_ONLN);
+
+ if (n > 0)
+ return n;
+ }
+#endif
+ return 1;
+}
+
+static const GslConfig *gsl_config = NULL;
+
+const GslConfig*
+gsl_get_config (void)
+{
+ return gsl_config;
+}
+
+#define ROUND(dblval) ((GslLong) ((dblval) + .5))
+
+void
+gsl_init (const GslConfigValue values[],
+ GslMutexTable *mtable)
+{
+ const GslConfigValue *config = values;
+ static GslConfig pconfig = { /* DEFAULTS */
+ 1, /* n_processors */
+ 2, /* wave_chunk_padding */
+ 4, /* wave_chunk_big_pad */
+ 512, /* dcache_block_size */
+ 1024 * 1024, /* dcache_cache_memory */
+ 69, /* midi_kammer_note */
+ 440, /* kammer_freq */
+ };
+
+ g_return_if_fail (gsl_config == NULL); /* assert single initialization */
+
+ /* get mutexes going first */
+ if (mtable)
+ gsl_mutex_table = *mtable;
+
+ gsl_externvar_tick_stamp = 1;
+
+ /* configure permanent config record */
+ if (config)
+ while (config->value_name)
+ {
+ if (strcmp ("wave_chunk_padding", config->value_name) == 0)
+ pconfig.wave_chunk_padding = ROUND (config->value);
+ else if (strcmp ("wave_chunk_big_pad", config->value_name) == 0)
+ pconfig.wave_chunk_big_pad = ROUND (config->value);
+ else if (strcmp ("dcache_cache_memory", config->value_name) == 0)
+ pconfig.dcache_cache_memory = ROUND (config->value);
+ else if (strcmp ("dcache_block_size", config->value_name) == 0)
+ pconfig.dcache_block_size = ROUND (config->value);
+ else if (strcmp ("midi_kammer_note", config->value_name) == 0)
+ pconfig.midi_kammer_note = ROUND (config->value);
+ else if (strcmp ("kammer_freq", config->value_name) == 0)
+ pconfig.kammer_freq = config->value;
+ config++;
+ }
+
+ /* constrain (user) config */
+ pconfig.wave_chunk_padding = MAX (1, pconfig.wave_chunk_padding);
+ pconfig.wave_chunk_big_pad = MAX (2 * pconfig.wave_chunk_padding, pconfig.wave_chunk_big_pad);
+ pconfig.dcache_block_size = MAX (2 * pconfig.wave_chunk_big_pad + sizeof (GslDataType), pconfig.dcache_block_size);
+ pconfig.dcache_block_size = gsl_alloc_upper_power2 (pconfig.dcache_block_size - 1);
+ /* pconfig.dcache_cache_memory = gsl_alloc_upper_power2 (pconfig.dcache_cache_memory); */
+
+ /* non-configurable config updates */
+ pconfig.n_processors = get_n_processors ();
+
+ /* export GSL configuration */
+ gsl_config = &pconfig;
+
+ /* initialize subsystems */
+ is_smp_system = GSL_CONFIG (n_processors) > 1;
+ gsl_mutex_init (&global_memory);
+ gsl_mutex_init (&global_thread);
+ gsl_cond_init (&global_thread_cond);
+ main_thread_tdata = create_tdata ();
+ g_assert (main_thread_tdata != NULL);
+ main_thread = gsl_thread_self ();
+ global_thread_list = gsl_ring_prepend (global_thread_list, main_thread);
+ _gsl_init_signal ();
+ _gsl_init_fd_pool ();
+ _gsl_init_data_caches ();
+ _gsl_init_engine_utils ();
+ _gsl_init_loader_gslwave ();
+ _gsl_init_loader_wav ();
+ _gsl_init_loader_oggvorbis ();
+ _gsl_init_loader_mad ();
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-30 22:04:04 +0000