void my_layer_shift_down_shape (MyLayer *self, MyShape *theShape) {
GQueue *shapes = MY_LAYER_GET_PRIVATE (self)->shapes;
guint shapeCount, j;
MyShape *shape;
shapeCount = my_layer_shape_count (self);
assert (theShape);
for (j = shapeCount - 1; j >= 0; j--) {
shape = my_layer_peek_nth (self, j);
if (shape == theShape) {
g_queue_pop_nth (shapes, j);
break;
}
}
assert (shape == theShape);
shape = g_queue_peek_nth (shapes, j - 1);
if (shape->isControlShape) {
g_queue_push_nth (shapes, theShape, j);
} else {
g_queue_push_nth (shapes, theShape, j - 1);
}
}
static void
on_druid_get_new_page (AnjutaAutogen* gen, gpointer data)
{
NPWDruid* druid = (NPWDruid *)data;
gint current;
NPWPage* page;
current = gtk_assistant_get_current_page (GTK_ASSISTANT (druid->window));
page = g_queue_peek_nth (druid->page_list, current - (druid->no_selection ? 0 : 1));
if (npw_page_get_name (page) == NULL)
{
/* no page, display finish page */
npw_druid_fill_summary_page (druid);
page = g_queue_pop_nth (druid->page_list, current - (druid->no_selection ? 0 : 1));
if (page != NULL) npw_page_free (page);
gtk_container_remove (GTK_CONTAINER (druid->window), gtk_assistant_get_nth_page (GTK_ASSISTANT (druid->window), current + 1));
gtk_assistant_set_current_page (GTK_ASSISTANT (druid->window), current + 1);
}
else
{
/* display property page */
npw_druid_fill_property_page (druid, page);
gtk_assistant_set_current_page (GTK_ASSISTANT (druid->window), current + 1);
}
}
/**
* \param id MessageID of requested message
*
* Reads data from message queue until message with matching id is found.
*
* \return GString containing unpacked message.
**/
GString *get_message_by_id(MessageID id)
{
GString *data = NULL;
guint x, len;
gboolean found = FALSE;
g_mutex_lock(message_queue_mutex);
do {
len = g_queue_get_length(message_queue);
for (x = 0; x<len; x++) {
data = g_queue_peek_nth(message_queue, x);
if (get_message_id(data) == id) {
found = TRUE;
g_queue_pop_nth(message_queue, x);
break;
}
}
if (found == FALSE)
g_cond_wait(message_queue_cond, message_queue_mutex);
} while (found == FALSE);
g_mutex_unlock(message_queue_mutex);
unpack_message(data);
return data;
}
static int _remove_timeout_dev(void)
{
GQueue *queue = &gl_ctx.queue;
int len = g_queue_get_length(queue);
int id;
VS_DEV_T *pdev;
for (id = 0; id < len; ) {
pdev = g_queue_peek_nth(queue, id);
if (!pdev)
break;
if (pdev->idle_time > 10) {
dev_offline(pdev->id);
g_queue_pop_nth(queue, id);
hsb_debug("device offline %s\n", inet_ntoa(pdev->ip));
g_slice_free(VS_DEV_T, pdev);
continue;
}
pdev->idle_time++;
id++;
}
return 0;
}
void queue_remove_tracks(gboolean notif, int idx, int nb) {
int len;
int i;
g_debug("Removing %d tracks from queue, starting at %d.", nb, idx);
if ((idx < 0) || (nb < 0))
return;
len = g_queue_get_length(&g_queue);
if (idx < len) {
if (idx + nb >= len)
nb = len - idx;
for (i=0; i < nb; i++)
sp_track_release(g_queue_pop_nth(&g_queue, idx));
/* Was the current track removed too? */
if (g_current_track >= idx) {
if (g_current_track < idx+nb) {
queue_stop(FALSE);
g_current_track = -1;
}
else
g_current_track -= nb;
}
}
if (g_shuffle) queue_setup_shuffle();
g_shuffle_first = g_current_track;
if (notif) queue_notify();
}
static struct avrcp_request *pop_request(uint8_t pdu_id, uint8_t event_id,
bool peek)
{
GSList *l;
for (l = devices; l; l = g_slist_next(l)) {
struct avrcp_device *dev = l->data;
GList *reqs = g_queue_peek_head_link(dev->queue);
int i;
for (i = 0; reqs; reqs = g_list_next(reqs), i++) {
struct avrcp_request *req = reqs->data;
if (req->pdu_id != pdu_id || req->event_id != event_id)
continue;
if (!peek)
g_queue_pop_nth(dev->queue, i);
return req;
}
}
return NULL;
}
void
account_list_move_up(guint account_index)
{
if (account_index != 0) {
gpointer acc = g_queue_pop_nth(accountQueue, account_index);
g_queue_push_nth(accountQueue, acc, account_index - 1);
}
}
void
account_list_move_down(guint account_index)
{
if (account_index != accountQueue->length) {
gpointer acc = g_queue_pop_nth(accountQueue, account_index);
g_queue_push_nth(accountQueue, acc, account_index + 1);
}
}
MyShape* my_layer_pop_shape (MyLayer *self, MyShape *shape) {
gint pos;
MyLayerPrivate* priv = MY_LAYER_GET_PRIVATE (self);
pos = g_queue_index (priv->shapes, shape);
if (pos != -1) { // find
return (MyShape *) g_queue_pop_nth (priv->shapes, pos);
}
return NULL;
}
void account_list_set_current(account_t *current)
{
// 2 steps:
// 1 - retrieve the index of the current account in the Queue
// 2 - then set it as first
guint pos = account_list_get_position(current);
if (pos > 0) {
gpointer acc = g_queue_pop_nth(accountQueue, pos);
g_queue_push_nth(accountQueue, acc, 0);
}
}
int random_assignment(Job *jobarray, int njobs, int nmachines,
solution *new_sol, GRand *rand_) {
int i, val = 0;
double n;
partlist *temp = (partlist *) NULL;
Job *j = (Job *) NULL;
GQueue *queue = (GQueue *) NULL;
queue = g_queue_new();
for (i = 0; i < nmachines; ++i) {
g_queue_push_head(queue, new_sol->part + i);
}
for (i = 0; i < njobs; ++i) {
j = jobarray + i;
n = g_rand_double_range(rand_, 0.0, 1.0);
if (n < 0.8) {
temp = (partlist *) g_queue_pop_head(queue);
} else if (n >= 0.8 && n < 0.95) {
temp = (partlist *) g_queue_pop_nth(queue, 1);
} else {
if(nmachines > 2) {
temp = (partlist *)g_queue_pop_nth(queue, 2);
} else {
temp = (partlist *)g_queue_pop_nth(queue, 1);
}
}
val = partlist_insert(temp, new_sol->vlist, j);
CCcheck_val_2(val, "Failed in partlist_insert_order");
g_queue_insert_sorted(queue, temp, compare_func1, NULL);
}
CLEAN:
g_queue_free(queue);
return val;
}
API bool deleteStorePath(Store *store, char *path)
{
bool result = false;
GPtrArray *array = splitStorePath(path);
char **parts = (char **) array->pdata;
char *key = parts[array->len - 1];
parts[array->len - 1] = NULL; // cut off last element
char *parentpath = g_strjoinv("/", parts);
Store *parent = getStorePath(store, "%s", parentpath);
int i;
void *value;
if(parent != NULL) {
switch(parent->type) {
case STORE_ARRAY:
result = g_hash_table_remove(parent->content.array, key); // The hash table frees the removed value automatically
break;
case STORE_LIST:
i = atoi(key);
value = g_queue_pop_nth(parent->content.list, i);
if(value != NULL) {
freeStore(value);
result = true;
} else {
result = false;
}
break;
default: // cannot delete inside a leaf value
result = false;
break;
}
} else {
result = false;
}
// Cleanup
free(parentpath);
free(key);
for(i = 0; i < array->len - 1; i++) {
free(parts[i]);
}
g_ptr_array_free(array, TRUE);
return result;
}
void handle_work_enqueue_event(
awe_server_state * ns,
tw_bf * b,
awe_msg * m,
tw_lp * lp)
{
fprintf(event_log, "%lf;awe_server;%lu;WQ;work=%s\n", now_sec(lp), lp->gid, m->object_id);
char* workid=NULL;
workid = malloc(sizeof(char[MAX_LENGTH_ID]));
strcpy(workid, m->object_id);
assert(workid);
tw_lpid *clientid;
int has_match = 0;
int len = g_queue_get_length(client_req_queue);
if (len > 0) {
int n = -1;
for (int i=0; i<len; i++) {
clientid = g_queue_peek_nth(client_req_queue, i);
if (client_match_work(*clientid, workid)) {
n = i;
break;
}
}
if (n >=0) {
clientid = g_queue_pop_nth(client_req_queue, n);
has_match = 1;
}
}
if (has_match) {
tw_event *e;
awe_msg *msg;
e = codes_event_new(*clientid, ns_tw_lookahead, lp);
msg = tw_event_data(e);
msg->event_type = WORK_CHECKOUT;
strcpy(msg->object_id, workid);
tw_event_send(e);
fprintf(event_log, "%lf;awe_server;%lu;WC;work=%s client=%lu\n", now_sec(lp), lp->gid, workid, *clientid);
free(workid);
free(clientid);
} else {
g_queue_push_tail(work_queue, workid);
}
return;
}
guint garbage_connection_pool_clean_old_entries(network_garbage_connection_pool *gc_pool, gint grace_secs) {
guint count = 0;
guint i = 0;
network_connection_pool_entry *entry = NULL;
GTimeVal now_tv;
guint q_len_before = 0;
guint q_len_after = 0;
g_assert(gc_pool);
g_get_current_time(&now_tv);
g_mutex_lock(&(gc_pool->mutex));
q_len_before = g_queue_get_length(gc_pool->entries);
for (i = 0; i < g_queue_get_length(gc_pool->entries); ) {
entry = g_queue_peek_nth(gc_pool->entries, i);
if (entry == NULL) {
i++;
continue;
}
if (now_tv.tv_sec > (entry->added_ts).tv_sec + grace_secs) {
//remove this entry
entry = g_queue_pop_nth(gc_pool->entries, i);
network_connection_pool_entry_free(entry, TRUE);
entry = NULL;
count++;
} else {
i++;
}
}
q_len_after = g_queue_get_length(gc_pool->entries);
g_mutex_unlock(&(gc_pool->mutex));
#ifdef DEBUG_CONN_POOL
if (q_len_before > 0) {
g_debug("[%s]: gc_pool length before: %d, after: %d, removed: %d",
G_STRLOC, q_len_before, q_len_after, count);
}
#endif
return count;
}
char* get_first_work_by_stage(int stage) {
char *workid = NULL;
int len = g_queue_get_length(work_queue);
int n = -1;
for (int i=0; i<len; i++) {
workid = g_queue_peek_nth(work_queue, i);
gchar **seg = g_strsplit(workid, "_", 3);
int taskid = atoi(seg[1]);
if (taskid == stage) {
n = i;
break;
}
}
if (n >= 0) {
return g_queue_pop_nth(work_queue, n);
}
return NULL;
}
static void
npw_druid_remove_following_page (NPWDruid* druid)
{
gint current;
current = gtk_assistant_get_current_page (GTK_ASSISTANT (druid->window));
for(;;)
{
GtkWidget *widget;
NPWPage* page;
widget = gtk_assistant_get_nth_page (GTK_ASSISTANT (druid->window), current + 1);
if (widget == druid->finish_page) break;
gtk_container_remove (GTK_CONTAINER (druid->window), widget);
page = g_queue_pop_nth (druid->page_list, current - (druid->no_selection ? 0 : 1));
if (page != NULL) npw_page_free (page);
}
}
void navqueue_go_forward()
{
filepos *fnext;
if (nav_queue_pos < 1 ||
nav_queue_pos >= g_queue_get_length(navigation_queue))
return;
/* jump forward */
fnext = g_queue_peek_nth(navigation_queue, nav_queue_pos - 1);
if (goto_file_pos(fnext->file, fnext->pos))
{
nav_queue_pos--;
}
else
{
/** TODO: add option to re open the file */
g_free(g_queue_pop_nth(navigation_queue, nav_queue_pos - 1));
}
adjust_buttons();
}
TEST_F(GQueueTest, popNth)
{
int testData1 = 42;
int testData2 = 1337;
int testData3 = 27;
g_queue_push_tail(queue, &testData1);
g_queue_push_tail(queue, &testData2);
g_queue_push_tail(queue, &testData3);
gpointer data = g_queue_pop_nth(queue, 1);
ASSERT_EQ(&testData2, data) << "popped queue head should have correct value";
ASSERT_TRUE(queue->head != NULL) << "queue head should not be NULL after removing one element";
ASSERT_NE(queue->head, queue->tail) << "queue tail should not be equal to head after removing one element";
ASSERT_EQ(&testData1, queue->head->data) << "queue head data should be set correctly";
ASSERT_EQ(queue->tail, queue->head->next) << "queue head element next should be tail";
ASSERT_TRUE(queue->head->prev == NULL) << "queue head should not have a previous element";
ASSERT_EQ(&testData3, queue->tail->data) << "queue tail data should be set correctly";
ASSERT_EQ(queue->head, queue->tail->prev) << "queue tail element previous should be head";
ASSERT_TRUE(queue->tail->next == NULL) << "queue tail should not have a next element";
ASSERT_EQ(2, queue->length) << "queue should have one element left after popping one";
}
void navqueue_go_back()
{
filepos *fprev;
/* return if theres no place to go back to */
if (g_queue_is_empty(navigation_queue) ||
nav_queue_pos >= g_queue_get_length(navigation_queue) - 1)
return;
/* jump back */
fprev = g_queue_peek_nth(navigation_queue, nav_queue_pos + 1);
if (goto_file_pos(fprev->file, fprev->pos))
{
nav_queue_pos++;
}
else
{
/** TODO: add option to re open the file */
g_free(g_queue_pop_nth(navigation_queue, nav_queue_pos + 1));
}
adjust_buttons();
}
int flom_resource_simple_clean(flom_resource_t *resource,
flom_conn_t *conn)
{
enum Exception { NULL_OBJECT
, SIMPLE_WAITINGS_ERROR
, INTERNAL_ERROR
, NONE } excp;
int ret_cod = FLOM_RC_INTERNAL_ERROR;
FLOM_TRACE(("flom_resource_simple_clean\n"));
TRY {
GSList *p = NULL;
if (NULL == resource)
THROW(NULL_OBJECT);
/* check if the connection keeps a lock */
p = resource->data.simple.holders;
while (NULL != p) {
if (((struct flom_rsrc_conn_lock_s *)p->data)->conn == conn)
break;
else
p = p->next;
} /* while (NULL != p) */
if (NULL != p) {
struct flom_rsrc_conn_lock_s *cl =
(struct flom_rsrc_conn_lock_s *)p->data;
FLOM_TRACE(("flom_resource_simple_clean: the client is holding "
"a lock mode %d, removing it...\n",
cl->info.lock_mode));
FLOM_TRACE(("flom_resource_simple_clean: cl=%p\n", cl));
resource->data.simple.holders = g_slist_remove(
resource->data.simple.holders, cl);
/* free the now useless connection lock record */
flom_rsrc_conn_lock_delete(cl);
/*
FLOM_TRACE(("flom_resource_simple_clean: g_slist_length=%u\n",
g_slist_length(resource->data.simple.holders)));
*/
/* check if some other clients can get a lock now */
if (FLOM_RC_OK != (ret_cod = flom_resource_simple_waitings(
resource)))
THROW(SIMPLE_WAITINGS_ERROR);
} else {
guint i = 0;
/* check if the connection was waiting a lock */
do {
struct flom_rsrc_conn_lock_s *cl =
(struct flom_rsrc_conn_lock_s *)
g_queue_peek_nth(resource->data.simple.waitings, i);
if (NULL == cl)
break;
if (cl->conn == conn) {
/* remove from waitings */
FLOM_TRACE(("flom_resource_simple_clean: the client is "
"waiting for a lock mode %d, removing "
"it...\n", cl->info.lock_mode));
cl = g_queue_pop_nth(resource->data.simple.waitings, i);
if (NULL == cl) {
/* this should be impossibile because peek was ok
some rows above */
THROW(INTERNAL_ERROR);
} else {
/* free the now useless connection lock record */
flom_rsrc_conn_lock_delete(cl);
}
break;
} else
++i;
} while (TRUE);
} /* if (NULL != p) */
THROW(NONE);
} CATCH {
switch (excp) {
case NULL_OBJECT:
ret_cod = FLOM_RC_NULL_OBJECT;
break;
case SIMPLE_WAITINGS_ERROR:
break;
case INTERNAL_ERROR:
ret_cod = FLOM_RC_INTERNAL_ERROR;
break;
case NONE:
ret_cod = FLOM_RC_OK;
break;
default:
ret_cod = FLOM_RC_INTERNAL_ERROR;
} /* switch (excp) */
} /* TRY-CATCH */
FLOM_TRACE(("flom_resource_simple_clean/excp=%d/"
"ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
return ret_cod;
}
static void meh_screen_popup_favorite_toggle(App* app, Screen* screen) {
g_assert(app != NULL);
g_assert(screen != NULL);
PopupData* data = meh_screen_popup_get_data(screen);
ExecutableListData* exec_list_data = meh_exec_list_get_data(data->src_screen);
/* updates the value of the executable */
gboolean new_value = data->executable->favorite == 1 ? FALSE : TRUE;
if (meh_db_set_executable_favorite(app->db, data->executable, new_value)) {
data->executable->favorite = new_value;
}
/* re-position the executable in the executables list if necessary */
if (g_queue_get_length(exec_list_data->executables) > 1) {
int prev_selected = exec_list_data->selected_executable;
unsigned int i = 0;
/* retrieves the one which will move in the list */
Executable* to_move = g_queue_pop_nth(exec_list_data->executables, exec_list_data->selected_executable);
/* find the good position for the moved executable */
for (i = 0; i < g_queue_get_length(exec_list_data->executables); i++) {
gboolean exit = FALSE;
Executable* ex = g_queue_peek_nth(exec_list_data->executables, i);
/* if favorite, ensure to stay in the favorite zone */
if (new_value == TRUE) {
if (ex->favorite == FALSE) {
exit = TRUE;
}
}
gchar* first = g_utf8_strup(ex->display_name, g_utf8_strlen(ex->display_name, -1));
gchar* second = g_utf8_strup(data->executable->display_name, g_utf8_strlen(ex->display_name, -1));
if (g_utf8_collate(first, second) > 0) {
if (new_value == TRUE && ex->favorite == TRUE) {
exit = TRUE;
}
else if (new_value == FALSE && ex->favorite == FALSE) {
exit = TRUE;
}
}
g_free(first);
g_free(second);
if (exit) {
break;
}
}
GList* after = g_queue_peek_nth_link(exec_list_data->executables, i);
/* re-add it to the good position */
g_queue_insert_before(exec_list_data->executables, after, to_move);
/* notify the screen of the new selected executable */
exec_list_data->selected_executable = i;
/* redraw the executables list texts */
meh_exec_list_refresh_executables_widget(app, data->src_screen);
/* move and redraw the selection */
meh_exec_list_after_cursor_move(app, data->src_screen, prev_selected);
}
/* finally close the popup */
meh_screen_popup_close(screen);
}
int flom_resource_simple_waitings(flom_resource_t *resource)
{
enum Exception { INTERNAL_ERROR
, MSG_BUILD_ANSWER_ERROR
, MSG_SERIALIZE_ERROR
, MSG_SEND_ERROR
, MSG_FREE_ERROR
, NONE } excp;
int ret_cod = FLOM_RC_INTERNAL_ERROR;
struct flom_rsrc_conn_lock_s *cl = NULL;
FLOM_TRACE(("flom_resource_simple_waitings\n"));
TRY {
guint i = 0;
struct flom_msg_s msg;
char buffer[FLOM_NETWORK_BUFFER_SIZE];
size_t to_send;
/* check if there is any connection waiting for a lock */
do {
cl = (struct flom_rsrc_conn_lock_s *)
g_queue_peek_nth(resource->data.simple.waitings, i);
if (NULL == cl)
break;
/* try to apply this lock... */
if (flom_resource_simple_can_lock(resource, cl->info.lock_mode)) {
/* remove from waitings */
cl = g_queue_pop_nth(resource->data.simple.waitings, i);
if (NULL == cl)
/* this should be impossibile because peek was ok
some rows above */
THROW(INTERNAL_ERROR);
/* send a message to the client that is waiting the lock */
flom_msg_init(&msg);
if (FLOM_RC_OK != (ret_cod = flom_msg_build_answer(
&msg, FLOM_MSG_VERB_LOCK,
3*FLOM_MSG_STEP_INCR,
FLOM_RC_OK, NULL)))
THROW(MSG_BUILD_ANSWER_ERROR);
if (FLOM_RC_OK != (
ret_cod = flom_msg_serialize(
&msg, buffer, sizeof(buffer), &to_send)))
THROW(MSG_SERIALIZE_ERROR);
if (FLOM_RC_OK != (ret_cod = flom_conn_send(
cl->conn, buffer, to_send)))
THROW(MSG_SEND_ERROR);
flom_conn_set_last_step(cl->conn, msg.header.pvs.step);
if (FLOM_RC_OK != (ret_cod = flom_msg_free(&msg)))
THROW(MSG_FREE_ERROR);
/* insert into holders */
resource->data.simple.holders = g_slist_prepend(
resource->data.simple.holders,
(gpointer)cl);
cl = NULL;
} else
++i;
} while (TRUE);
THROW(NONE);
} CATCH {
switch (excp) {
case INTERNAL_ERROR:
ret_cod = FLOM_RC_INTERNAL_ERROR;
break;
case MSG_BUILD_ANSWER_ERROR:
case MSG_SERIALIZE_ERROR:
case MSG_SEND_ERROR:
case MSG_FREE_ERROR:
break;
case NONE:
ret_cod = FLOM_RC_OK;
break;
default:
ret_cod = FLOM_RC_INTERNAL_ERROR;
} /* switch (excp) */
} /* TRY-CATCH */
if (NULL != cl) {
flom_rsrc_conn_lock_delete(cl);
}
FLOM_TRACE(("flom_resource_simple_waitings/excp=%d/"
"ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
return ret_cod;
}
static gssize
socket_send_message (NiceSocket *sock, const NiceOutputMessage *message)
{
TcpPriv *priv = sock->priv;
gssize ret;
GError *gerr = NULL;
gsize message_len;
/* Don't try to access the socket if it had an error, otherwise we risk a
* crash with SIGPIPE (Broken pipe) */
if (priv->error)
return -1;
message_len = output_message_get_size (message);
/* First try to send the data, don't send it later if it can be sent now
* this way we avoid allocating memory on every send */
if (g_queue_is_empty (&priv->send_queue)) {
ret = g_socket_send_message (sock->fileno, NULL, message->buffers,
message->n_buffers, NULL, 0, G_SOCKET_MSG_NONE, NULL, &gerr);
if (ret < 0) {
if (g_error_matches (gerr, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK) ||
g_error_matches (gerr, G_IO_ERROR, G_IO_ERROR_FAILED)) {
/* Queue the message and send it later. */
add_to_be_sent (sock, message, 0, message_len, FALSE);
ret = message_len;
}
g_error_free (gerr);
} else if ((gsize) ret < message_len) {
/* Partial send. */
add_to_be_sent (sock, message, ret, message_len, TRUE);
ret = message_len;
}
} else {
/* FIXME: This dropping will break http/socks5/etc
* We probably need a way to the upper layer to control reliability
*/
/* If the queue is too long, drop whatever packets we can. */
if (g_queue_get_length (&priv->send_queue) >= MAX_QUEUE_LENGTH) {
guint peek_idx = 0;
struct to_be_sent *tbs = NULL;
while ((tbs = g_queue_peek_nth (&priv->send_queue, peek_idx)) != NULL) {
if (tbs->can_drop) {
tbs = g_queue_pop_nth (&priv->send_queue, peek_idx);
free_to_be_sent (tbs);
break;
} else {
peek_idx++;
}
}
}
/* Queue the message and send it later. */
add_to_be_sent (sock, message, 0, message_len, FALSE);
ret = message_len;
}
return ret;
}
int random_rcl_assignment(Job *jobarray, int njobs, int nmachines,
solution *new_sol, GRand *rand_) {
int i;
double max;
double min;
double lb, ub;
double temp_dbl;
partlist *temp = (partlist *) NULL;
Job *temp_job = (Job *) NULL;
//GList *it = (GList *) NULL;
GQueue *to_do_list = (GQueue *) NULL;
temp = new_sol->part;
to_do_list = g_queue_new();
for (i = 0; i < njobs; ++i) {
g_queue_push_tail(to_do_list, jobarray + i);
}
while (!g_queue_is_empty(to_do_list)) {
temp_job = (Job *)to_do_list->head->data;
max = ((double)temp[0].completiontime + (double)temp_job->processingime);
min = max;
GArray *rcl = g_array_new(FALSE, FALSE, sizeof(pair_job_machine));
/** Compute min and max */
for (i = 1; i < nmachines; ++i) {
//for (it = to_do_list->head; it; it = it->next)
//{
//temp_job = (Job*)it->data;
temp_dbl = (temp[i].completiontime + temp_job->processingime);
if (max < temp_dbl) {
max = temp_dbl;
}
if (min > temp_dbl) {
min = temp_dbl;
}
//}
}
/** Compute RCL */
pair_job_machine temp_job_machine;
lb = min;
ub = min + 0.25 * (max - lb);
for (i = 0; i < nmachines; ++i) {
//for (it = to_do_list->head; it; it = g_list_next(it))
//{
//temp_job = ((Job*)it->data);
double g = ((double)temp[i].completiontime + (double)temp_job->processingime);
if (lb <= g && g <= ub) {
temp_job_machine.job = temp_job->job;
temp_job_machine.machine = i;
g_array_append_val(rcl, temp_job_machine);
}
//}
}
/** Choose uniformaly an assignment of a job to a machine */
int a = g_rand_int_range(rand_, 0, rcl->len);
int job = g_array_index(rcl, pair_job_machine, a).job;
int machine = g_array_index(rcl, pair_job_machine, a).machine;
partlist_insert(temp + machine, new_sol->vlist, jobarray + job);
g_queue_pop_nth(to_do_list, g_queue_index(to_do_list, jobarray + job));
g_array_free(rcl, TRUE);
}
g_queue_free(to_do_list);
return 0;
}
/**
* get a connection from the pool
*
* make sure we have at lease <min-conns> for each user
* if we have more, reuse a connect to reauth it to another user
*
* @param pool connection pool to get the connection from
* @param username (optional) name of the auth connection
* @param default_db (unused) unused name of the default-db
*/
network_socket *network_connection_pool_get(network_connection_pool *pool,
GString *username,
GString *UNUSED_PARAM(default_db), conn_ctl_info *info) {
guint32 cur;
guint len, i;
network_socket *sock = NULL;
network_connection_pool_entry *entry, *found_entry = NULL;
GQueue *conns = network_connection_pool_get_conns(pool, username, NULL);
/**
* if we know this use, return a authed connection
*/
if (conns) {
cur = time(0);
len = g_queue_get_length(conns);
for (i = 0; i < len; i++) {
entry = g_queue_peek_nth(conns, i);
if (entry->key == info->key) {
if (!entry->shared) {
found_entry = entry;
g_queue_pop_nth (conns, i);
break;
}
}
}
if (!found_entry && len > 0) {
entry = g_queue_peek_nth(conns, 0);
found_entry = entry;
g_queue_pop_nth (conns, 0);
g_debug("%s: (get) entry for user '%s' -> %p, cur:%u",
G_STRLOC, username ? username->str : "", entry, cur);
}
if (conns->length == 0) {
/**
* all connections are gone, remove it from the hash
*/
g_hash_table_remove(pool->users, username);
}
}
if (!found_entry) {
g_debug("%s: (get) no entry for user '%s' -> %p", G_STRLOC, username ? username->str : "", conns);
return NULL;
}
sock = found_entry->sock;
g_debug("%s: recv queue length:%d, sock:%p",
G_STRLOC, sock->recv_queue->chunks->length, sock);
network_connection_pool_entry_free(found_entry, FALSE);
/* remove the idle handler from the socket */
event_del(&(sock->event));
g_debug("%s: (get) got socket for user '%s' -> %p", G_STRLOC, username ? username->str : "", sock);
return sock;
}