void pqueue_free(Priority_Queue *Q, int free_keys) { int i = 0; if(free_keys) { for(;i < pqueue_size(Q); i++) { free(((void **)Q->arr[i])[1]); } } for(i = 0; i < pqueue_size(Q); i++) { free(((void **)Q->arr[i])[0]); //all the priorities (int *) free((void **)Q->arr[i]); } free(Q->arr); Q->arr = NULL; Q->size = 0; Q->h_size = 0; }
int get_parcel(PQueue *parcels, Parcel *parcel) { Parcel *data; if (pqueue_size(parcels) == 0) { /* Return that there are no parcels. */ return -1; } else { if (pqueue_extract(parcels, (void **)data) != 0) { /* Return that a parcel could not be retrieved. */ return -1; } else { /* Pass back the highest-priority parcel. */ memcpy(parcel, data, sizeof(Parcel)); free(data); } } return 0; }
static void log_state (GstDtlsConnection * self, const gchar * str) { GstDtlsConnectionPrivate *priv = self->priv; guint states = 0; states |= (! !SSL_is_init_finished (priv->ssl) << 0); states |= (! !SSL_in_init (priv->ssl) << 4); states |= (! !SSL_in_before (priv->ssl) << 8); states |= (! !SSL_in_connect_init (priv->ssl) << 12); states |= (! !SSL_in_accept_init (priv->ssl) << 16); states |= (! !SSL_want_write (priv->ssl) << 20); states |= (! !SSL_want_read (priv->ssl) << 24); #if OPENSSL_VERSION_NUMBER < 0x10100001L GST_LOG_OBJECT (self, "%s: role=%s buf=(%d,%p:%d/%d) %x|%x %s", str, priv->is_client ? "client" : "server", pqueue_size (priv->ssl->d1->sent_messages), priv->bio_buffer, priv->bio_buffer_offset, priv->bio_buffer_len, states, SSL_get_state (priv->ssl), SSL_state_string_long (priv->ssl)); #else GST_LOG_OBJECT (self, "%s: role=%s buf=(%p:%d/%d) %x|%x %s", str, priv->is_client ? "client" : "server", priv->bio_buffer, priv->bio_buffer_offset, priv->bio_buffer_len, states, SSL_get_state (priv->ssl), SSL_state_string_long (priv->ssl)); #endif }
int dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority) { DTLS1_RECORD_DATA *rdata; pitem *item; /* Limit the size of the queue to prevent DOS attacks */ if (pqueue_size(queue->q) >= 100) return 0; rdata = OPENSSL_malloc(sizeof(*rdata)); item = pitem_new(priority, rdata); if (rdata == NULL || item == NULL) { OPENSSL_free(rdata); pitem_free(item); SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); return -1; } rdata->packet = s->rlayer.packet; rdata->packet_length = s->rlayer.packet_length; memcpy(&(rdata->rbuf), &s->rlayer.rbuf, sizeof(SSL3_BUFFER)); memcpy(&(rdata->rrec), &s->rlayer.rrec, sizeof(SSL3_RECORD)); item->data = rdata; #ifndef OPENSSL_NO_SCTP /* Store bio_dgram_sctp_rcvinfo struct */ if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && (SSL_get_state(s) == TLS_ST_SR_FINISHED || SSL_get_state(s) == TLS_ST_CR_FINISHED)) { BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_GET_RCVINFO, sizeof(rdata->recordinfo), &rdata->recordinfo); } #endif s->rlayer.packet = NULL; s->rlayer.packet_length = 0; memset(&s->rlayer.rbuf, 0, sizeof(s->rlayer.rbuf)); memset(&s->rlayer.rrec, 0, sizeof(s->rlayer.rrec)); if (!ssl3_setup_buffers(s)) { SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(rdata); pitem_free(item); return (-1); } /* insert should not fail, since duplicates are dropped */ if (pqueue_insert(queue->q, item) == NULL) { SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(rdata); pitem_free(item); return (-1); } return (1); }
static void print_pqueue(PQueue *pqueue) { int i; /***************************************************************************** * * * Display the priority queue in level order. * * * *****************************************************************************/ fprintf(stdout, "Priority queue size is %d\n", pqueue_size(pqueue)); for (i = 0; i < pqueue_size(pqueue); i++) fprintf(stdout, "Node=%03d\n", *(int *)pqueue->tree[i]); return; }
END_TEST START_TEST(test_pqueue_enqueue) { PriorityQueue *pq = pqueue_new(); ck_assert_msg(pq != NULL, "Priority queue should not be NULL."); pqueue_enqueue(pq, tree_new()); ck_assert_int_eq(pqueue_size(pq), 1); pqueue_enqueue(pq, tree_new()); ck_assert_int_eq(pqueue_size(pq), 2); pqueue_enqueue(pq, tree_new()); ck_assert_int_eq(pqueue_size(pq), 3); pqueue_enqueue(pq, tree_new()); ck_assert_int_eq(pqueue_size(pq), 4); pqueue_free(pq); }
//this returns the priority --> useful, but how to do remove well then? should i //do get priority? and then revert search to give pos in array? int pqueue_search(Priority_Queue *Q, void *key, int comparator(void *data1, void *data2)) { int i = 0; for(;i < pqueue_size(Q); i++) { if(comparator(((void **)Q->arr[i])[1], key) == 0) { return *(int *)((void **)Q->arr[i])[0]; } } return -1; }
static struct proc* pdequeue() { struct proc *p; if(pqueue_size() == 0) return 0; else{ p = pheap_pop(); return p; } }
static int trivial() { pqueue q = pqueue_new(); if (q == NULL) { return 0; } int32_t data = 0xdeadbeef; uint8_t priority[8] = {0}; pitem *item = pitem_new(priority, &data); if (item == NULL || pqueue_insert(q, item) != item || pqueue_size(q) != 1 || pqueue_peek(q) != item || pqueue_pop(q) != item || pqueue_size(q) != 0 || pqueue_pop(q) != NULL) { return 0; } pitem_free(item); pqueue_free(q); return 1; }
void squeue_destroy(squeue_t *q, int flags) { unsigned int i; if (!q || pqueue_size(q) < 1) return; /* * Using two separate loops is a lot faster than * doing 1 cmp+branch for every queued item */ if (flags & SQUEUE_FREE_DATA) { for (i = 0; i < pqueue_size(q); i++) { free(((squeue_event *)q->d[i + 1])->data); free(q->d[i + 1]); } } else { for (i = 0; i < pqueue_size(q); i++) { free(q->d[i + 1]); } } pqueue_free(q); }
int main(int argc, char **argv) { PQueue pqueue; void *data; int intval[30], i; /***************************************************************************** * * * Initialize the priority queue. * * * *****************************************************************************/ pqueue_init(&pqueue, compare_int, NULL); /***************************************************************************** * * * Perform some priority queue operations. * * * *****************************************************************************/ i = 0; intval[i] = 5; fprintf(stdout, "Inserting %03d\n", intval[i]); if (pqueue_insert(&pqueue, &intval[i]) != 0) return 1; print_pqueue(&pqueue); i++; intval[i] = 10; fprintf(stdout, "Inserting %03d\n", intval[i]); if (pqueue_insert(&pqueue, &intval[i]) != 0) return 1; print_pqueue(&pqueue); i++; intval[i] = 20; fprintf(stdout, "Inserting %03d\n", intval[i]); if (pqueue_insert(&pqueue, &intval[i]) != 0) return 1; print_pqueue(&pqueue); i++; intval[i] = 1; fprintf(stdout, "Inserting %03d\n", intval[i]); if (pqueue_insert(&pqueue, &intval[i]) != 0) return 1; print_pqueue(&pqueue); i++; intval[i] = 25; fprintf(stdout, "Inserting %03d\n", intval[i]); if (pqueue_insert(&pqueue, &intval[i]) != 0) return 1; print_pqueue(&pqueue); i++; intval[i] = 22; fprintf(stdout, "Inserting %03d\n", intval[i]); if (pqueue_insert(&pqueue, &intval[i]) != 0) return 1; print_pqueue(&pqueue); i++; intval[i] = 12; fprintf(stdout, "Inserting %03d\n", intval[i]); if (pqueue_insert(&pqueue, &intval[i]) != 0) return 1; print_pqueue(&pqueue); i++; while (pqueue_size(&pqueue) > 0) { fprintf(stdout, "Peeking at the highest priority element..Value=%03d\n", *(int *)pqueue_peek(&pqueue)); if (pqueue_extract(&pqueue, (void **)&data) != 0) return 1; fprintf(stdout, "Extracting %03d\n", *(int *)data); print_pqueue(&pqueue); } /***************************************************************************** * * * Destroy the priority queue. * * * *****************************************************************************/ fprintf(stdout, "Destroying the pqueue\n"); pqueue_destroy(&pqueue); return 0; }
END_TEST START_TEST(test_pqueue_dequeue) { PriorityQueue *pq = pqueue_new(); ck_assert_msg(pq != NULL, "Priority queue should not be NULL."); TreeNode *t = tree_new(); t->type = LEAF; t->freq.v = 10; t->freq.c = 'c'; t->left = NULL; t->right = NULL; pqueue_enqueue(pq, t); ck_assert_int_eq(pqueue_size(pq), 1); t = tree_new(); t->type = LEAF; t->freq.v = 15; t->freq.c = 'x'; t->left = NULL; t->right = NULL; pqueue_enqueue(pq, t); ck_assert_int_eq(pqueue_size(pq), 2); t = tree_new(); t->type = LEAF; t->freq.v = 9; t->freq.c = 'q'; t->left = NULL; t->right = NULL; pqueue_enqueue(pq, t); ck_assert_int_eq(pqueue_size(pq), 3); t = tree_new(); t->type = LEAF; t->freq.v = 999; t->freq.c = 'a'; t->left = NULL; t->right = NULL; pqueue_enqueue(pq, t); ck_assert_int_eq(pqueue_size(pq), 4); t = pqueue_dequeue(pq); ck_assert_int_eq(t->freq.c, 'q'); ck_assert_int_eq(pqueue_size(pq), 3); free(t); t = pqueue_dequeue(pq); ck_assert_int_eq(t->freq.c, 'c'); ck_assert_int_eq(pqueue_size(pq), 2); free(t); t = pqueue_dequeue(pq); ck_assert_int_eq(t->freq.c, 'x'); ck_assert_int_eq(pqueue_size(pq), 1); free(t); t = pqueue_dequeue(pq); ck_assert_int_eq(t->freq.c, 'a'); ck_assert_int_eq(pqueue_size(pq), 0); free(t); pqueue_free(pq); }
void pqueue_walk(Priority_Queue *Q, void (*f)(void *key)) { int i = 0; for(; i < pqueue_size(Q); i++) { f(((void **)Q->arr[i])[1]); } }
static int penqueue(struct proc *p) { if(pqueue_size() == PQUEUE_MAX) return -1; pheap_push(p); return 0; }
static int build_tree(int *freqs, BiTree **tree) { BiTree *init, *merge, *left, *right; PQueue pqueue; HuffNode *data; int size, c; /***************************************************************************** * * * Initialize the priority queue of binary trees. * * * *****************************************************************************/ *tree = NULL; pqueue_init(&pqueue, compare_freq, destroy_tree); for (c = 0; c <= UCHAR_MAX; c++) { if (freqs[c] != 0) { /*********************************************************************** * * * Set up a binary tree for the current symbol and its frequency. * * * ***********************************************************************/ if ((init = (BiTree *)malloc(sizeof(BiTree))) == NULL) { pqueue_destroy(&pqueue); return -1; } bitree_init(init, free); if ((data = (HuffNode *)malloc(sizeof(HuffNode))) == NULL) { pqueue_destroy(&pqueue); return -1; } data->symbol = c; data->freq = freqs[c]; if (bitree_ins_left(init, NULL, data) != 0) { free(data); bitree_destroy(init); free(init); pqueue_destroy(&pqueue); return -1; } /*********************************************************************** * * * Insert the binary tree into the priority queue. * * * ***********************************************************************/ if (pqueue_insert(&pqueue, init) != 0) { bitree_destroy(init); free(init); pqueue_destroy(&pqueue); return -1; } } } /***************************************************************************** * * * Build a Huffman tree by merging trees in the priority queue. * * * *****************************************************************************/ size = pqueue_size(&pqueue); for (c = 1; c <= size - 1; c++) { /************************************************************************** * * * Allocate storage for the next merged tree. * * * **************************************************************************/ if ((merge = (BiTree *)malloc(sizeof(BiTree))) == NULL) { pqueue_destroy(&pqueue); return -1; } /************************************************************************** * * * Extract the two trees whose root nodes have the smallest frequencies. * * * **************************************************************************/ if (pqueue_extract(&pqueue, (void **)&left) != 0) { pqueue_destroy(&pqueue); free(merge); return -1; } if (pqueue_extract(&pqueue, (void **)&right) != 0) { pqueue_destroy(&pqueue); free(merge); return -1; } /************************************************************************** * * * Allocate storage for the data in the root node of the merged tree. * * * **************************************************************************/ if ((data = (HuffNode *)malloc(sizeof(HuffNode))) == NULL) { pqueue_destroy(&pqueue); free(merge); return -1; } memset(data, 0, sizeof(HuffNode)); /************************************************************************** * * * Sum the frequencies in the root nodes of the trees being merged. * * * **************************************************************************/ data->freq = ((HuffNode *)bitree_data(bitree_root(left)))->freq + ((HuffNode *)bitree_data(bitree_root(right)))->freq; /************************************************************************** * * * Merge the two trees. * * * **************************************************************************/ if (bitree_merge(merge, left, right, data) != 0) { pqueue_destroy(&pqueue); free(merge); return -1; } /************************************************************************** * * * Insert the merged tree into the priority queue and free the others. * * * **************************************************************************/ if (pqueue_insert(&pqueue, merge) != 0) { pqueue_destroy(&pqueue); bitree_destroy(merge); free(merge); return -1; } free(left); free(right); } /***************************************************************************** * * * The last tree in the priority queue is the Huffman tree. * * * *****************************************************************************/ if (pqueue_extract(&pqueue, (void **)tree) != 0) { pqueue_destroy(&pqueue); return -1; } else { pqueue_destroy(&pqueue); } return 0; }
unsigned int squeue_size(squeue_t *q) { if (!q) return 0; return pqueue_size(q); }
static int fixed_random() { /* Random order of 10 elements, chosen by * random.choice(list(itertools.permutations(range(10)))) */ int ordering[NUM_ITEMS] = {9, 6, 3, 4, 0, 2, 7, 1, 8, 5}; int i; pqueue q = pqueue_new(); uint8_t priority[8] = {0}; piterator iter; pitem *curr, *item; if (q == NULL) { return 0; } /* Insert the elements */ for (i = 0; i < NUM_ITEMS; i++) { priority[7] = ordering[i]; item = pitem_new(priority, &ordering[i]); if (pqueue_insert(q, item) != item) { return 0; } } /* Insert the elements again. This inserts duplicates and should * fail. */ for (i = 0; i < NUM_ITEMS; i++) { priority[7] = ordering[i]; item = pitem_new(priority, &ordering[i]); if (pqueue_insert(q, item) != NULL) { return 0; } pitem_free(item); } if (pqueue_size(q) != NUM_ITEMS) { return 0; } /* Iterate over the elements. */ iter = pqueue_iterator(q); curr = pqueue_next(&iter); if (curr == NULL) { return 0; } while (1) { pitem *next = pqueue_next(&iter); int *curr_data, *next_data; if (next == NULL) { break; } curr_data = (int*)curr->data; next_data = (int*)next->data; if (*curr_data >= *next_data) { return 0; } curr = next; } pqueue_free(q); return 1; }