static void check_deferred(script_info *info)
{
info->status &= ~STATUS_ACTIVE;
if(info->status & STATUS_DEFERRED_UNLOAD)
{
run_unload_hooks(info, NULL);
g_ptr_array_remove_fast(scripts, info);
}
else if(info->status & STATUS_DEFERRED_RELOAD)
{
if(info == interp)
{
run_unload_hooks(interp, NULL);
destroy_interpreter();
create_interpreter();
}
else
{
char *filename = g_strdup(info->filename);
run_unload_hooks(info, NULL);
g_ptr_array_remove_fast(scripts, info);
load_script(filename);
g_free(filename);
}
}
}
void
graph_remove_edge (Graph *self, GraphEdge *edge)
{
gboolean found_edge = g_ptr_array_remove_fast (self->edges, edge);
g_assert (found_edge);
found_edge = g_ptr_array_remove_fast (edge->from_node->out_edges, edge);
g_assert (found_edge);
found_edge = g_ptr_array_remove_fast (edge->to_node->in_edges, edge);
g_assert (found_edge);
g_free (edge);
}
gboolean
remove_socket_from_array(GIOChannel *chan) {
gboolean ret = 0;
ret = g_ptr_array_remove_fast(uzbl.comm.connect_chan, chan);
if(!ret)
ret = g_ptr_array_remove_fast(uzbl.comm.client_chan, chan);
if(ret)
g_io_channel_unref (chan);
return ret;
}
static int unregister_hook(hook_info *hook)
{
script_info *info = get_info(hook->state);
if(g_ptr_array_remove_fast(info->hooks, hook))
return 1;
if(g_ptr_array_remove_fast(info->unload_hooks, hook))
return 1;
return 0;
}
void
flow_joiner_remove_input_pad (FlowJoiner *joiner, FlowInputPad *input_pad)
{
FlowElement *element = (FlowElement *) joiner;
gboolean was_removed;
g_return_if_fail (FLOW_IS_JOINER (joiner));
g_return_if_fail (FLOW_IS_INPUT_PAD (input_pad));
if (element->dispatch_depth)
{
was_removed = flow_g_ptr_array_remove_sparse (element->input_pads, input_pad);
element->input_pad_removed = TRUE; /* Can't use was_removed because it may already be TRUE */
}
else
{
was_removed = g_ptr_array_remove_fast (element->input_pads, input_pad);
}
if (!was_removed)
{
g_warning ("Tried to remove unknown input pad from joiner!");
return;
}
element->pending_inputs = g_slist_remove (element->pending_inputs, input_pad);
g_object_unref (input_pad);
}
static void
remove_wsq (MonoWSQ *wsq)
{
gpointer data;
if (wsq == NULL)
return;
EnterCriticalSection (&wsqs_lock);
if (wsqs == NULL) {
LeaveCriticalSection (&wsqs_lock);
return;
}
g_ptr_array_remove_fast (wsqs, wsq);
data = NULL;
/*
* Only clean this up when shutting down, any other case will error out
* if we're removing a queue that still has work items.
*/
if (mono_runtime_is_shutting_down ()) {
while (mono_wsq_local_pop (&data)) {
threadpool_jobs_dec (data);
data = NULL;
}
}
mono_wsq_destroy (wsq);
LeaveCriticalSection (&wsqs_lock);
}
/**
* gst_vaapi_surface_associate_subpicture:
* @surface: a #GstVaapiSurface
* @subpicture: a #GstVaapiSubpicture
* @src_rect: the sub-rectangle of the source subpicture
* image to extract and process. If %NULL, the entire image will be used.
* @dst_rect: the sub-rectangle of the destination
* surface into which the image is rendered. If %NULL, the entire
* surface will be used.
*
* Associates the @subpicture with the @surface. The @src_rect
* coordinates and size are relative to the source image bound to
* @subpicture. The @dst_rect coordinates and size are relative to the
* target @surface. Note that the @surface holds an additional
* reference to the @subpicture.
*
* Return value: %TRUE on success
*/
gboolean
gst_vaapi_surface_associate_subpicture (GstVaapiSurface * surface,
GstVaapiSubpicture * subpicture,
const GstVaapiRectangle * src_rect, const GstVaapiRectangle * dst_rect)
{
gboolean success;
g_return_val_if_fail (surface != NULL, FALSE);
g_return_val_if_fail (subpicture != NULL, FALSE);
if (!surface->subpictures) {
surface->subpictures = g_ptr_array_new ();
if (!surface->subpictures)
return FALSE;
}
if (g_ptr_array_remove_fast (surface->subpictures, subpicture)) {
success = _gst_vaapi_surface_deassociate_subpicture (surface, subpicture);
gst_vaapi_object_unref (subpicture);
if (!success)
return FALSE;
}
success = _gst_vaapi_surface_associate_subpicture (surface,
subpicture, src_rect, dst_rect);
if (!success)
return FALSE;
g_ptr_array_add (surface->subpictures, gst_vaapi_object_ref (subpicture));
return TRUE;
}
/**
* gst_vaapi_surface_deassociate_subpicture:
* @surface: a #GstVaapiSurface
* @subpicture: a #GstVaapiSubpicture
*
* Deassociates @subpicture from @surface. Other associations are kept.
*
* Return value: %TRUE on success
*/
gboolean
gst_vaapi_surface_deassociate_subpicture (GstVaapiSurface * surface,
GstVaapiSubpicture * subpicture)
{
gboolean success;
g_return_val_if_fail (surface != NULL, FALSE);
g_return_val_if_fail (subpicture != NULL, FALSE);
if (!surface->subpictures)
return TRUE;
/* First, check subpicture was really associated with this surface */
if (!g_ptr_array_remove_fast (surface->subpictures, subpicture)) {
GST_DEBUG ("subpicture %" GST_VAAPI_ID_FORMAT " was not bound to "
"surface %" GST_VAAPI_ID_FORMAT,
GST_VAAPI_ID_ARGS (GST_VAAPI_OBJECT_ID (subpicture)),
GST_VAAPI_ID_ARGS (GST_VAAPI_OBJECT_ID (surface)));
return TRUE;
}
success = _gst_vaapi_surface_deassociate_subpicture (surface, subpicture);
gst_vaapi_object_unref (subpicture);
return success;
}
void
ipc_endpoint_connect_to_socket(ipc_endpoint_t *ipc, int sock)
{
g_assert(ipc);
g_assert(ipc->status == IPC_ENDPOINT_DISCONNECTED);
ipc_recv_state_t *state = &ipc->recv_state;
state->queued_ipcs = g_ptr_array_new();
GIOChannel *channel = g_io_channel_unix_new(sock);
g_io_channel_set_encoding(channel, NULL, NULL);
g_io_channel_set_buffered(channel, FALSE);
state->watch_in_id = g_io_add_watch(channel, G_IO_IN, (GIOFunc)ipc_recv, ipc);
state->watch_hup_id = g_io_add_watch(channel, G_IO_HUP, (GIOFunc)ipc_hup, ipc);
/* Atomically update ipc->channel. This is done because on the web extension
* thread, logging spawns a message send thread, which may attempt to write
* to the uninitialized channel after it has been created with
* g_io_channel_unix_new(), but before it has been set up fully */
g_atomic_pointer_set(&ipc->channel, channel);
ipc->status = IPC_ENDPOINT_CONNECTED;
if (!endpoints)
endpoints = g_ptr_array_sized_new(1);
/* Add the endpoint; it should never be present already */
g_assert(!g_ptr_array_remove_fast(endpoints, ipc));
g_ptr_array_add(endpoints, ipc);
}
void unregister_ability(Client *cli, const gchar *func)
{
GPtrArray *workers = g_hash_table_lookup(g_workers, func);
if (workers) {
g_ptr_array_remove_fast(workers, cli);
}
client_remove_ability(cli, func);
}
// remove from a channel's handler list
static void
map_remove_handler_callback(gpointer _key, gpointer _value,
gpointer _data)
{
lcm_subscription_t *h = (lcm_subscription_t*) _data;
GPtrArray *handlers = (GPtrArray*) _value;
g_ptr_array_remove_fast(handlers, h);
}
static gint gv_manager_raster_destroy_cb( GObject * raster_in,
gpointer cb_data )
{
GvManager *manager = GV_MANAGER(cb_data);
GvRaster *raster = GV_RASTER(raster_in);
GvDataset *ds = NULL;
int i, active_rasters = 0;
/*
* Find in our list. The dataset must already be "under management".
*/
for( i = 0; i < manager->datasets->len; i++ )
{
ds = (GvDataset *) g_ptr_array_index(manager->datasets, i);
if( raster->dataset == ds->dataset )
break;
}
if( i == manager->datasets->len )
{
g_warning( "gv_manager_raster_destroy_cb(): can't find dataset." );
return FALSE;
}
/*
* Find our GvRaster.
*/
for( i = 0; i < GDALGetRasterCount(ds->dataset); i++ )
{
if( ds->rasters[i] == raster ) {
/* MB: still not sure if we need to unref here... */
// if (G_OBJECT(raster)->ref_count > 1)
// g_object_unref(ds->rasters[i]);
ds->rasters[i] = NULL;
}
else if( ds->rasters[i] != NULL )
active_rasters++;
}
/*
* We apparently no longer need this GDALDataset. Dereference it, and
* remove from the list.
*/
if (active_rasters == 0)
{
if (GDALDereferenceDataset(ds->dataset) < 1) {
GDALClose(ds->dataset);
}
g_free(ds->rasters);
g_free(ds);
g_ptr_array_remove_fast(manager->datasets, ds);
}
return FALSE;
}
int return_mem_block(mem_superblock_t *msb, void *p) {
unsigned int i;
for (i=0; i<msb->blocks->len; i++) {
mem_block_t *mb=g_ptr_array_index(msb->blocks,i);
if (g_ptr_array_remove_fast(mb->used, p)==TRUE) {
g_ptr_array_add(mb->free,p);
return 0;
}
}
return -1;
}
void
graph_remove_node (Graph *self, GraphNode *node)
{
// IMPROVEME: for symmetry it might be nice to have a
// graph_node_free method.
g_assert (node->in_edges->len == 0 && node->out_edges->len == 0);
g_ptr_array_free (node->out_edges, TRUE);
g_ptr_array_free (node->in_edges, TRUE);
gboolean found_node = g_ptr_array_remove_fast (self->nodes, node);
g_free (node);
g_assert (found_node);
}
/**
* media_channel_closed_cb:
* Signal callback for when a media channel is closed. Removes the references
* that #RakiaMediaManager holds to them.
*/
static void
call_channel_closed_cb (RakiaCallChannel *chan, gpointer user_data)
{
RakiaMediaManager *fac = RAKIA_MEDIA_MANAGER (user_data);
RakiaMediaManagerPrivate *priv = RAKIA_MEDIA_MANAGER_GET_PRIVATE (fac);
tp_channel_manager_emit_channel_closed_for_object (fac,
TP_EXPORTABLE_CHANNEL (chan));
if (priv->channels)
{
g_ptr_array_remove_fast (priv->channels, chan);
}
}
/**
* ggn_account_list_accounts_clear:
* @alist: The account list to modify.
*
* Clears the entries #GPtrArray of a given #GgnAccountList. private only.
*
* Returns: void.
**/
void ggn_account_list_accounts_clear (GgnAccountList *alist) {
/* define a helping variable. */
gpointer ptr;
/* loop until the pointer array is empty. */
while (alist->priv->accounts->len > 0) {
/* remove the first pointer. */
ptr = g_ptr_array_index (alist->priv->accounts, 0);
g_ptr_array_remove_fast (alist->priv->accounts, ptr);
/* free the entry (pointer). */
ggn_account_free ((GgnAccount *) ptr);
}
}
static void
content_ready (GObject *object, GAsyncResult *res, gpointer user_data)
{
TfCallChannel *self = TF_CALL_CHANNEL (user_data);
TfCallContent *content = TF_CALL_CONTENT (object);
if (g_async_initable_init_finish (G_ASYNC_INITABLE (object), res, NULL))
{
g_signal_emit (self, signals[SIGNAL_CONTENT_ADDED], 0, content);
}
else
{
g_ptr_array_remove_fast (self->contents, content);
}
g_object_unref (self);
}
static void _downloadmanager_download_free(downloadmanager_t* pDownloadManager, download_t* pDownload)
{
// Empty struct
g_free(pDownload->pszRemoteFilePath);
g_free(pDownload->pszLocalFilePath);
if(pDownload->pGnomeVFSHandle != NULL) {
// XXX: do we need to close this?
// gnome_vfs_async_close(pDownload->pGnomeVFSHandle, _downloader_gnome_vfs_close_callback, NULL);
}
// XXX: store a 'state' so we know which array it's in?
g_ptr_array_remove_fast(pDownloadManager->pActiveArray, pDownload);
g_ptr_array_remove(pDownloadManager->pPendingArray, pDownload);
// Free struct
g_free(pDownload);
}
/**
* asb_plugin_appdata_remove_file:
*/
static void
asb_plugin_appdata_remove_file (AsbPlugin *plugin, const gchar *filename)
{
const gchar *tmp;
guint i;
g_mutex_lock (&plugin->priv->filenames_mutex);
for (i = 0; i < plugin->priv->filenames->len; i++) {
tmp = g_ptr_array_index (plugin->priv->filenames, i);
if (g_strcmp0 (tmp, filename) == 0) {
g_ptr_array_remove_fast (plugin->priv->filenames,
(gpointer) tmp);
break;
}
}
g_mutex_unlock (&plugin->priv->filenames_mutex);
}
static int unload_script(char const *filename)
{
script_info *script = get_script_by_file(filename);
if (!script)
return 0;
if(script->status & STATUS_ACTIVE)
script->status |= STATUS_DEFERRED_UNLOAD;
else
{
run_unload_hooks(script, NULL);
g_ptr_array_remove_fast(scripts, script);
}
return 1;
}
void stop_all_listening(Client *cli)
{
if (!cli->listening)
return;
int i;
Job *job;
for(i = 0; i < cli->listening->len; i++) {
job = g_ptr_array_index(cli->listening, i);
g_ptr_array_remove_fast(job->listeners, cli);
if (!job->background && job->listeners->len == 0) {
#if DEBUG
g_debug("[%s] removing non-background job with no listeners: %s", cli->id, job->handle);
#endif
remove_job(job);
}
}
client_clear_listening(cli);
}
static void
clipman_free (XfcePanelPlugin *plugin,
ClipmanPlugin *clipman)
{
guint i;
ClipmanClip *clip;
GtkWidget *dialog;
dialog = g_object_get_data (G_OBJECT (plugin), "dialog");
if (dialog)
gtk_widget_destroy (dialog);
/* Stop the check loop */
clipman->killTimeout = TRUE;
if (clipman->TimeoutId != 0)
{
g_source_remove(clipman->TimeoutId);
clipman->TimeoutId = 0;
}
/* Remove clipboard items */
for (i = clipman->clips->len; i--;)
{
clip = g_ptr_array_index (clipman->clips, i);
g_ptr_array_remove_fast (clipman->clips, clip);
clipman_free_clip (clip);
}
g_ptr_array_free (clipman->clips, TRUE);
gtk_tooltips_set_tip (clipman->tooltip, clipman->button, NULL, NULL);
g_object_unref (clipman->tooltip);
gtk_widget_destroy (clipman->icon);
gtk_widget_destroy (clipman->button);
clipman->plugin = NULL;
DBG ("Plugin Freed");
g_free (clipman);
}
static int reload_script(char const *filename)
{
script_info *script = get_script_by_file(filename);
if (!script)
return 0;
if(script->status & STATUS_ACTIVE)
{
script->status |= STATUS_DEFERRED_RELOAD;
}
else
{
char *filename = g_strdup(script->filename);
run_unload_hooks(script, NULL);
g_ptr_array_remove_fast(scripts, script);
load_script(filename);
g_free(filename);
}
return 1;
}
static void
egg_state_machine__style_object_weak_notify (gpointer data,
GObject *where_object_was)
{
EggStateStyle *style_prop = data;
EggStateMachine *self = style_prop->state_machine;
EggStateMachinePrivate *priv = egg_state_machine_get_instance_private (self);
GHashTableIter iter;
EggState *state;
g_assert (EGG_IS_STATE_MACHINE (self));
g_assert (where_object_was != NULL);
style_prop->widget = NULL;
g_hash_table_iter_init (&iter, priv->states);
while (g_hash_table_iter_next (&iter, NULL, (gpointer)&state))
{
if (g_ptr_array_remove_fast (state->styles, style_prop))
return;
}
g_critical ("Failed to find style for %p", where_object_was);
}
RESULT ptrarray_remove_fast()
{
GPtrArray *array = g_ptr_array_new();
gchar *letters [] = { "A", "B", "C", "D", "E" };
if (g_ptr_array_remove_fast (array, NULL))
return FAILED ("Removing NULL succeeded");
g_ptr_array_add(array, letters[0]);
if (!g_ptr_array_remove_fast (array, letters[0]) || array->len != 0)
return FAILED ("Removing last element failed");
g_ptr_array_add(array, letters[0]);
g_ptr_array_add(array, letters[1]);
g_ptr_array_add(array, letters[2]);
g_ptr_array_add(array, letters[3]);
g_ptr_array_add(array, letters[4]);
if (!g_ptr_array_remove_fast (array, letters[0]) || array->len != 4)
return FAILED ("Removing first element failed");
if (array->pdata [0] != letters [4])
return FAILED ("First element wasn't replaced with last upon removal");
if (g_ptr_array_remove_fast (array, letters[0]))
return FAILED ("Succedeed removing a non-existing element");
if (!g_ptr_array_remove_fast (array, letters[3]) || array->len != 3)
return FAILED ("Failed removing \"D\"");
if (!g_ptr_array_remove_fast (array, letters[1]) || array->len != 2)
return FAILED ("Failed removing \"B\"");
if (array->pdata [0] != letters [4] || array->pdata [1] != letters [2])
return FAILED ("Last two elements are wrong");
g_ptr_array_free(array, TRUE);
return OK;
}
static void
fs_rtp_conference_handle_message (
GstBin * bin,
GstMessage * message)
{
FsRtpConference *self = FS_RTP_CONFERENCE (bin);
if (!self->rtpbin)
goto out;
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ELEMENT:
{
const GstStructure *s = gst_message_get_structure (message);
/* we change the structure name and add the session ID to it */
if (gst_structure_has_name (s, "application/x-rtp-source-sdes") &&
gst_structure_has_field_typed (s, "session", G_TYPE_UINT) &&
gst_structure_has_field_typed (s, "ssrc", G_TYPE_UINT) &&
gst_structure_has_field_typed (s, "cname", G_TYPE_STRING))
{
guint session_id;
guint ssrc;
const GValue *val;
FsRtpSession *session;
const gchar *cname;
val = gst_structure_get_value (s, "session");
session_id = g_value_get_uint (val);
val = gst_structure_get_value (s, "ssrc");
ssrc = g_value_get_uint (val);
cname = gst_structure_get_string (s, "cname");
if (!ssrc || !cname)
{
GST_WARNING_OBJECT (self,
"Got GstRTPBinSDES without a ssrc or a cname (ssrc:%u cname:%p)",
ssrc, cname);
break;
}
session = fs_rtp_conference_get_session_by_id (self, session_id);
if (session) {
fs_rtp_session_associate_ssrc_cname (session, ssrc, cname);
g_object_unref (session);
} else {
GST_WARNING_OBJECT (self,"Our RtpBin announced a new association"
"for non-existent session %u for ssrc: %u and cname %s",
session_id, ssrc, cname);
}
}
else if (gst_structure_has_name (s, "dtmf-event-processed") ||
gst_structure_has_name (s, "dtmf-event-dropped"))
{
GList *item;
guint cookie;
GST_OBJECT_LOCK (self);
restart:
cookie = self->priv->sessions_cookie;
for (item = self->priv->sessions; item; item = item->next)
{
GST_OBJECT_UNLOCK (self);
if (fs_rtp_session_handle_dtmf_event_message (item->data, message))
{
gst_message_unref (message);
message = NULL;
goto out;
}
GST_OBJECT_LOCK (self);
if (cookie != self->priv->sessions_cookie)
goto restart;
}
GST_OBJECT_UNLOCK (self);
}
}
break;
case GST_MESSAGE_STREAM_STATUS:
{
GstStreamStatusType type;
guint i;
gst_message_parse_stream_status (message, &type, NULL);
switch (type)
{
case GST_STREAM_STATUS_TYPE_ENTER:
GST_OBJECT_LOCK (self);
for (i = 0; i < self->priv->threads->len; i++)
{
if (g_ptr_array_index (self->priv->threads, i) ==
g_thread_self ())
goto done;
}
g_ptr_array_add (self->priv->threads, g_thread_self ());
done:
GST_OBJECT_UNLOCK (self);
break;
case GST_STREAM_STATUS_TYPE_LEAVE:
GST_OBJECT_LOCK (self);
while (g_ptr_array_remove_fast (self->priv->threads,
g_thread_self ()));
GST_OBJECT_UNLOCK (self);
break;
default:
/* Do nothing */
break;
}
}
break;
default:
break;
}
out:
/* forward all messages to the parent */
if (message)
GST_BIN_CLASS (fs_rtp_conference_parent_class)->handle_message (bin,
message);
}
void li_stat_cache_entry_release(liVRequest *vr, liStatCacheEntry *sce) {
g_ptr_array_remove_fast(sce->vrequests, vr);
g_ptr_array_remove_fast(vr->stat_cache_entries, sce);
stat_cache_entry_release(sce);
}
static void
async_invoke_thread (gpointer data)
{
MonoDomain *domain;
MonoWSQ *wsq;
ThreadPool *tp;
gboolean must_die;
tp = data;
wsq = NULL;
if (!tp->is_io)
wsq = add_wsq ();
set_tp_thread_info (tp);
if (tp_start_func)
tp_start_func (tp_hooks_user_data);
data = NULL;
for (;;) {
MonoAsyncResult *ar;
MonoClass *klass;
gboolean is_io_task;
gboolean is_socket;
int n_naps = 0;
is_io_task = FALSE;
ar = (MonoAsyncResult *) data;
if (ar) {
InterlockedIncrement (&tp->busy_threads);
domain = ((MonoObject *)ar)->vtable->domain;
#ifndef DISABLE_SOCKETS
klass = ((MonoObject *) data)->vtable->klass;
is_io_task = !is_corlib_asyncresult (domain, klass);
is_socket = FALSE;
if (is_io_task) {
MonoSocketAsyncResult *state = (MonoSocketAsyncResult *) data;
is_socket = is_socketasyncresult (domain, klass);
ar = state->ares;
switch (state->operation) {
case AIO_OP_RECEIVE:
state->total = ICALL_RECV (state);
break;
case AIO_OP_SEND:
state->total = ICALL_SEND (state);
break;
}
}
#endif
/* worker threads invokes methods in different domains,
* so we need to set the right domain here */
g_assert (domain);
if (mono_domain_is_unloading (domain) || mono_runtime_is_shutting_down ()) {
threadpool_jobs_dec ((MonoObject *)ar);
data = NULL;
ar = NULL;
InterlockedDecrement (&tp->busy_threads);
} else {
mono_thread_push_appdomain_ref (domain);
if (threadpool_jobs_dec ((MonoObject *)ar)) {
data = NULL;
ar = NULL;
mono_thread_pop_appdomain_ref ();
InterlockedDecrement (&tp->busy_threads);
continue;
}
if (mono_domain_set (domain, FALSE)) {
MonoObject *exc;
if (tp_item_begin_func)
tp_item_begin_func (tp_item_user_data);
exc = mono_async_invoke (tp, ar);
if (tp_item_end_func)
tp_item_end_func (tp_item_user_data);
if (exc)
mono_internal_thread_unhandled_exception (exc);
if (is_socket && tp->is_io) {
MonoSocketAsyncResult *state = (MonoSocketAsyncResult *) data;
if (state->completed && state->callback) {
MonoAsyncResult *cb_ares;
cb_ares = create_simple_asyncresult ((MonoObject *) state->callback,
(MonoObject *) state);
icall_append_job ((MonoObject *) cb_ares);
}
}
mono_domain_set (mono_get_root_domain (), TRUE);
}
mono_thread_pop_appdomain_ref ();
InterlockedDecrement (&tp->busy_threads);
clear_thread_state ();
}
}
ar = NULL;
data = NULL;
must_die = should_i_die (tp);
if (must_die) {
mono_wsq_suspend (wsq);
} else {
if (tp->is_io || !mono_wsq_local_pop (&data))
dequeue_or_steal (tp, &data, wsq);
}
n_naps = 0;
while (!must_die && !data && n_naps < 4) {
gboolean res;
InterlockedIncrement (&tp->waiting);
// Another thread may have added a job into its wsq since the last call to dequeue_or_steal
// Check all the queues again before entering the wait loop
dequeue_or_steal (tp, &data, wsq);
if (data) {
InterlockedDecrement (&tp->waiting);
break;
}
mono_gc_set_skip_thread (TRUE);
#if defined(__OpenBSD__)
while (mono_cq_count (tp->queue) == 0 && (res = mono_sem_wait (&tp->new_job, TRUE)) == -1) {// && errno == EINTR) {
#else
while (mono_cq_count (tp->queue) == 0 && (res = mono_sem_timedwait (&tp->new_job, 2000, TRUE)) == -1) {// && errno == EINTR) {
#endif
if (mono_runtime_is_shutting_down ())
break;
check_for_interruption_critical ();
}
InterlockedDecrement (&tp->waiting);
mono_gc_set_skip_thread (FALSE);
if (mono_runtime_is_shutting_down ())
break;
must_die = should_i_die (tp);
dequeue_or_steal (tp, &data, wsq);
n_naps++;
}
if (!data && !tp->is_io && !mono_runtime_is_shutting_down ()) {
mono_wsq_local_pop (&data);
if (data && must_die) {
InterlockedCompareExchange (&tp->destroy_thread, 1, 0);
pulse_on_new_job (tp);
}
}
if (!data) {
gint nt;
gboolean down;
while (1) {
nt = tp->nthreads;
down = mono_runtime_is_shutting_down ();
if (!down && nt <= tp->min_threads)
break;
if (down || InterlockedCompareExchange (&tp->nthreads, nt - 1, nt) == nt) {
#ifndef DISABLE_PERFCOUNTERS
mono_perfcounter_update_value (tp->pc_nthreads, TRUE, -1);
#endif
if (!tp->is_io) {
remove_wsq (wsq);
}
fire_profiler_thread_end ();
if (tp_finish_func)
tp_finish_func (tp_hooks_user_data);
if (!tp->is_io) {
if (threads) {
mono_mutex_lock (&threads_lock);
if (threads)
g_ptr_array_remove_fast (threads, mono_thread_current ()->internal_thread);
mono_mutex_unlock (&threads_lock);
}
}
return;
}
}
}
}
g_assert_not_reached ();
}
void
ves_icall_System_Threading_ThreadPool_GetAvailableThreads (gint *workerThreads, gint *completionPortThreads)
{
*workerThreads = async_tp.max_threads - async_tp.busy_threads;
*completionPortThreads = async_io_tp.max_threads - async_io_tp.busy_threads;
}
/* Build a menu of the given bookmarks categorised by the given topics.
* Shows categorisation using subdivisions, submenus, or a mix of both. */
static void
append_menu (GString *string, const GPtrArray *topics, const GPtrArray *bookmarks, guint flags)
{
GPtrArray *uncovered;
guint i, j;
gboolean use_subdivis = flags & BUILD_SUBDIVIS;
gboolean use_submenus = flags & BUILD_SUBMENUS;
if (use_subdivis || use_submenus)
{
GPtrArray *subset, *covering, *subdivisions, *submenus, *unused;
GArray *sizes = 0;
EphyNode *topic;
gint size, total;
gboolean separate = FALSE;
char name[EPHY_TOPIC_ACTION_NAME_BUFFER_SIZE];
/* Get the subtopics, uncovered bookmarks, and subtopic sizes. */
sizes = g_array_sized_new (FALSE, FALSE, sizeof(int), topics->len);
uncovered = g_ptr_array_sized_new (bookmarks->len);
covering = ephy_nodes_get_covering (topics, bookmarks, 0, uncovered, sizes);
/* Preallocate arrays for submenus, subdivisions, and bookmark subsets. */
subdivisions = g_ptr_array_sized_new (topics->len);
submenus = g_ptr_array_sized_new (topics->len);
subset = g_ptr_array_sized_new (bookmarks->len);
unused = g_ptr_array_sized_new (bookmarks->len);
/* Get the total number of items in the menu. */
total = uncovered->len;
for (i = 0; i < covering->len; i++)
total += g_array_index (sizes, int, i);
/* Seperate covering into list of submenus and subdivisions */
for (i = 0; i < covering->len; i++)
{
topic = g_ptr_array_index (covering, i);
size = g_array_index (sizes, int, i);
if (!use_submenus || (use_subdivis && (size < MIN_MENU_SIZE || total < MAX_MENU_SIZE)))
{
g_ptr_array_add (subdivisions, topic);
}
else
{
g_ptr_array_add (submenus, topic);
total = total - size + 1;
}
}
/* Sort the list of submenus and subdivisions. */
g_ptr_array_sort (submenus, ephy_bookmarks_compare_topic_pointers);
g_ptr_array_sort (subdivisions, ephy_bookmarks_compare_topic_pointers);
if (flags & BUILD_CHILD_SUBDIVIS) flags |= BUILD_SUBDIVIS;
if (flags & BUILD_CHILD_SUBMENUS) flags |= BUILD_SUBMENUS;
/* Create each of the submenus. */
for (i = 0; i < submenus->len; i++)
{
topic = g_ptr_array_index (submenus, i);
ephy_nodes_get_covered (topic, bookmarks, subset);
EPHY_TOPIC_ACTION_NAME_PRINTF (name, topic);
g_string_append_printf (string, "<menu action=\"%s\">",
name);
append_menu (string, topics, subset, flags);
g_string_append (string, "</menu>");
separate = TRUE;
}
/* Build a list of bookmarks which don't appear in any subdivision yet. */
for (i = 0; i < bookmarks->len; i++)
{
g_ptr_array_add (unused, g_ptr_array_index (bookmarks, i));
}
/* Create each of the subdivisions. */
for (i = 0; i < subdivisions->len; i++)
{
topic = g_ptr_array_index (subdivisions, i);
ephy_nodes_get_covered (topic, unused, subset);
g_ptr_array_sort (subset, ephy_bookmarks_compare_bookmark_pointers);
if (separate) g_string_append (string, "<separator/>");
append_bookmarks (string, subset);
separate = TRUE;
/* Record that each bookmark has been added. */
for (j = 0; j < subset->len; j++)
{
g_ptr_array_remove_fast (unused, g_ptr_array_index (subset, j));
}
}
g_array_free (sizes, TRUE);
g_ptr_array_free (covering, TRUE);
g_ptr_array_free (subdivisions, TRUE);
g_ptr_array_free (submenus, TRUE);
g_ptr_array_free (subset, TRUE);
g_ptr_array_free (unused, TRUE);
if (separate && uncovered->len) g_string_append (string, "<separator/>");
}
/******************************************************************
* This function is called when an event occurs on a client socket
******************************************************************/
void client_cb(int fd, short events, void *arg)
{
assert(arg != NULL);
Client *cli = arg;
int free = 0;
// g_hash_table_foreach(g_jobqueue, _print_queue, NULL);
if ((events & EV_WRITE) != 0) {
event_del(&cli->evt);
cli->evt.ev_events = EV_READ|EV_PERSIST;
event_add(&cli->evt, NULL);
if (client_flush(cli) < 0) {
free = 1;
}
}
if ((events & EV_READ) != 0) {
int ret = 0;
if (!cli->buffer_in) {
cli->buffer_in = getBlock(HEADER_SIZE);
incRef(cli->buffer_in);
ret = client_recv(cli, HEADER_SIZE);
}
if (ret >= 0) {
/* Make sure we don't over-read into the next packet */
int psize = HEADER_SIZE;
if (cli->buffer_in->nbytes >= HEADER_SIZE) {
if (ntohl(*(uint32_t*)(cli->buffer_in->bytes + HEADER_OFFSET_MAGIC)) != MAGIC_REQUEST) {
free = 1;
g_warning("[%s] Invalid MAGIC", cli->id);
goto free_client;
}
psize = HEADER_SIZE + ntohl(*(uint32_t*)(cli->buffer_in->bytes + HEADER_OFFSET_SIZE));
/* If the input block isn't large enough to receive the
entire packet then switch to one that is */
if (psize > cli->buffer_in->size) {
#if DEBUG
g_debug("Switching to bigger block (pktsize=%d)", psize);
#endif
/* Create new (bigger) block */
MemBlock *block = getBlock(psize + 1); /* +1 for terminating NULL to make args easier to work with */
if (!block) {
g_error("Failed to get block of size %d", psize);
free = 1;
goto free_client;
}
incRef(block);
/* Copy bytes into new block */
block->nbytes = cli->buffer_in->nbytes;
memmove(block->bytes, cli->buffer_in->bytes, cli->buffer_in->nbytes);
/* Swap blocks */
decRef(cli->buffer_in);
cli->buffer_in = block;
}
}
int num = psize - cli->buffer_in->nbytes;
if (num > 0)
ret = client_recv(cli, num);
}
if (ret < 0) {
#if DEBUG
g_debug("[%s] Connection on closed", cli->id);
#endif
free = 1;
} else if (ret >= 0) {
if (process_client(cli) != 0) {
g_warning("[%s] Processing of client failed", cli->id);
free = 1;
}
}
}
/*if ((events & (EV_READ|EV_WRITE)) == 0) {
g_warning("[%s] unhandled event %d", __func__, events);
}*/
free_client:
if (free != 0) {
#if DEBUG
g_message("[%s] Client disconnected", cli->id);
#endif
/*printf("[%s] Removing client %d\n", __func__, cli->fd);*/
close(cli->fd);
cli->fd = -1;
fail_working_jobs(cli);
stop_all_listening(cli);
unregister_all_abilities(cli);
event_del(&cli->evt);
g_ptr_array_remove_fast(g_clients, cli);
client_free(cli);
}
}
