static void rt_test_005_005_execute(void) { /* [5.5.1] An higher priority thread is created that performs non-atomical wait and signal operations on a semaphore.*/ test_set_step(1); { threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX()+1, thread3, 0); } /* [5.5.2] The function chSemSignalWait() is invoked by specifying the same semaphore for the wait and signal phases. The counter value must be one on exit.*/ test_set_step(2); { chSemSignalWait(&sem1, &sem1); test_assert(queue_isempty(&sem1.queue), "queue not empty"); test_assert(sem1.cnt == 0, "counter not zero"); } /* [5.5.3] The function chSemSignalWait() is invoked again by specifying the same semaphore for the wait and signal phases. The counter value must be one on exit.*/ test_set_step(3); { chSemSignalWait(&sem1, &sem1); test_assert(queue_isempty(&sem1.queue), "queue not empty"); test_assert(sem1.cnt == 0, "counter not zero"); } }
int main() { Queue myQueue; queue_init(&myQueue); assert(queue_isempty(&myQueue)); queue_enqueue(&myQueue, 9); assert(!queue_isempty(&myQueue)); printf("%d is top\n", queue_first(&myQueue)); queue_enqueue(&myQueue, 1); queue_enqueue(&myQueue, 2); queue_enqueue(&myQueue, 3); queue_enqueue(&myQueue, 4); queue_enqueue(&myQueue, 5); queue_enqueue(&myQueue, 6); queue_enqueue(&myQueue, 7); queue_print(&myQueue); printf("%d dequeued\n", queue_dequeue(&myQueue)); printf("%d dequeued\n", queue_dequeue(&myQueue)); printf("%d dequeued\n", queue_dequeue(&myQueue)); printf("%d dequeued\n", queue_dequeue(&myQueue)); queue_print(&myQueue); queue_destroy(&myQueue); queue_print(&myQueue); }
static void test_005_005_execute(void) { bool b; tprio_t prio; /* [5.5.1] Getting current thread priority for later checks.*/ test_set_step(1); { prio = chThdGetPriorityX(); } /* [5.5.2] Locking the mutex first time, it must be possible because it is not owned.*/ test_set_step(2); { b = chMtxTryLock(&m1); test_assert(b, "already locked"); } /* [5.5.3] Locking the mutex second time, it must fail because it is already owned.*/ test_set_step(3); { b = chMtxTryLock(&m1); test_assert(!b, "not locked"); } /* [5.5.4] Unlocking the mutex then it must not be owned anymore and the queue must be empty.*/ test_set_step(4); { chMtxUnlock(&m1); test_assert(m1.owner == NULL, "still owned"); test_assert(queue_isempty(&m1.queue), "queue not empty"); } /* [5.5.5] Testing that priority has not changed after operations.*/ test_set_step(5); { test_assert(chThdGetPriorityX() == prio, "wrong priority level"); } /* [5.5.6] Testing chMtxUnlockAll() behavior.*/ test_set_step(6); { b = chMtxTryLock(&m1); test_assert(b, "already locked"); b = chMtxTryLock(&m1); test_assert(!b, "not locked"); chMtxUnlockAll(); test_assert(m1.owner == NULL, "still owned"); test_assert(queue_isempty(&m1.queue), "queue not empty"); } /* [5.5.7] Testing that priority has not changed after operations.*/ test_set_step(7); { test_assert(chThdGetPriorityX() == prio, "wrong priority level"); } }
/** * @brief Performs atomic signal and wait operations on two semaphores. * * @param[in] sps pointer to a @p semaphore_t structure to be signaled * @param[in] spw pointer to a @p semaphore_t structure to wait on * @return A message specifying how the invoking thread has been * released from the semaphore. * @retval MSG_OK if the thread has not stopped on the semaphore or the * semaphore has been signaled. * @retval MSG_RESET if the semaphore has been reset using @p chSemReset(). * * @api */ msg_t chSemSignalWait(semaphore_t *sps, semaphore_t *spw) { msg_t msg; chDbgCheck((sps != NULL) && (spw != NULL)); chDbgAssert(((sps->s_cnt >= (cnt_t)0) && queue_isempty(&sps->s_queue)) || ((sps->s_cnt < (cnt_t)0) && queue_notempty(&sps->s_queue)), "inconsistent semaphore"); chDbgAssert(((spw->s_cnt >= (cnt_t)0) && queue_isempty(&spw->s_queue)) || ((spw->s_cnt < (cnt_t)0) && queue_notempty(&spw->s_queue)), "inconsistent semaphore"); chSysLock(); if (++sps->s_cnt <= (cnt_t)0) { chSchReadyI(queue_fifo_remove(&sps->s_queue))->p_u.rdymsg = MSG_OK; } if (--spw->s_cnt < (cnt_t)0) { thread_t *ctp = currp; sem_insert(ctp, &spw->s_queue); ctp->p_u.wtsemp = spw; chSchGoSleepS(CH_STATE_WTSEM); msg = ctp->p_u.rdymsg; } else { chSchRescheduleS(); msg = MSG_OK; } chSysUnlock(); return msg; }
static void mtx5_execute(void) { #if !CH_CFG_USE_MUTEXES_RECURSIVE bool b; tprio_t prio = chThdGetPriorityX(); b = chMtxTryLock(&m1); test_assert(1, b, "already locked"); b = chMtxTryLock(&m1); test_assert(2, !b, "not locked"); chSysLock(); chMtxUnlockS(&m1); chSysUnlock(); test_assert(3, queue_isempty(&m1.m_queue), "queue not empty"); test_assert(4, m1.m_owner == NULL, "still owned"); test_assert(5, chThdGetPriorityX() == prio, "wrong priority level"); #endif /* !CH_CFG_USE_MUTEXES_RECURSIVE */ chMtxLock(&m1); chMtxUnlockAll(); test_assert(6, queue_isempty(&m1.m_queue), "queue not empty"); test_assert(7, m1.m_owner == NULL, "still owned"); }
/* * Move entire contents of one queue to the other * * Parameters: * src Pointer to source queue * dst Pointer to destination queue */ void queue_move(QUEUE *dst, QUEUE *src) { if (queue_isempty(src)) return; if (queue_isempty(dst)) dst->head = src->head; else dst->tail->next = src->head; dst->tail = src->tail; src->head = NULL; return; }
static void wakeup_writer(struct mgmt *mgmt) { if (!queue_isempty(mgmt->pending_list)) { /* only queued reply commands trigger wakeup */ if (queue_isempty(mgmt->reply_queue)) return; } if (mgmt->writer_active) return; io_set_write_handler(mgmt->io, can_write_data, mgmt, write_watch_destroy); }
int queue_remove(queue *q) { if(queue_isempty(q)) { fprintf(stderr,"Error: dequeue: Queue is empty\n"); exit(1); } node *p=q->head; q->head=q->head->next; q->size--; if(queue_isempty(q)) q->tail=NULL; int x=p->data; free(p); return x; }
static int _thread_cond_signal(cond_t *cond, int broadcast) { /* consistency checks */ if (cond == NULL) return_errno(FALSE, EINVAL); if (!(cond->cn_state & THREAD_COND_INITIALIZED)) return_errno(FALSE, EDEADLK); // do something only if there is at least one waiters (POSIX semantics) if (cond->cn_waiters > 0) { // signal the condition do { thread_t *t = dequeue(&cond->wait_queue); assert (t != NULL); thread_resume(t); // t could also be a timed out thread, but it doesn't matter cond->cn_waiters--; } while (broadcast && !queue_isempty(&cond->wait_queue)); // and give other threads a chance to grab the CPU CAP_SET_SYSCALL(); thread_yield(); CAP_CLEAR_SYSCALL(); } /* return to caller */ return TRUE; }
int main (int argc, char **argv) { execname = basename(argv[0]); queue *the_queue = queue_new(); if (argc < 2) { putinqueue(the_queue, stdin, "-"); } else { for (int argi = 1; argi < argc; ++argi) { if (strcmp(argv[argi], "-") == 0) { putinqueue(the_queue, stdin, "-"); } else { putfileinqueue(the_queue, argv[argi]); } } } while (!queue_isempty(the_queue)) { queue_item_t temp = queue_remove(the_queue); printf("%s\n", temp); free(temp); } queue_free(the_queue); return exit_status; }
int main (int argc, char **argv) { execname = basename(argv[0]); queue *the_queue = queue_new(); if (argc < 2) { putinqueue(the_queue, stdin, "-"); } else { for (int argi = 1; argi < argc; ++argi) { if (strcmp(argv[argi], "-") == 0) { putinqueue(the_queue, stdin, "-"); } else { putfileinqueue(the_queue, argv[argi]); } } } while (!queue_isempty(the_queue)) { char* tmp = queue_remove(the_queue); //assign a temp char pointer to point at the item printf("%s\n", tmp); //print the item free(tmp); //free the pointer } queue_free(the_queue); //free the queue return exit_status; }
void queue_destroy (queue_t *queue) { void *tmp; if (queue != NULL) { //Tell our queue manager that we're done. stop_managing_queue(queue); CHECK_AND_LOCK_MUTEX(queue->mutex); while (!queue_isempty (queue)) { if ((tmp = queue_pop(queue)) == NULL) { break; } else { free(tmp); } } /* Free the dummy node too */ free(queue->front); CHECK_AND_UNLOCK_MUTEX(queue->mutex); SDL_DestroyMutex(queue->mutex); #ifdef NEW_TEXTURES SDL_DestroyCond(queue->condition); #endif /* NEW_TEXTURES */ free (queue); } }
bool gatt_db_isempty(struct gatt_db *db) { if (!db) return true; return queue_isempty(db->services); }
void *queue_pop (queue_t *queue) { node_t *oldnode; void *item; if (queue == NULL || queue_isempty(queue)) { return NULL; } else { CHECK_AND_LOCK_MUTEX(queue->mutex); oldnode = queue->front->next; item = oldnode->data; /* Check if removing the last node from the queue */ if (queue->front->next->next == NULL) { queue->rear = queue->front; } else { queue->front->next = queue->front->next->next; } free(oldnode); queue->nodes--; CHECK_AND_UNLOCK_MUTEX(queue->mutex); return item; } }
object* dequeue(queue *q) { int sz; queue_node *p; object *obj = NULL; if (q == NULL) { return NULL; } if (!queue_isempty(q)) { p = q->head; q->head = q->head->next; if (q->head == NULL) { q->rear = NULL; } obj = p->elem; sz = q->cache_size; if (sz < QUEUE_CACHE_SIZE) { /* cache this node */ q->cache[sz++] = p; q->cache_size = sz; } else { sc_free(p); } } return obj; }
const Article* queue_peek(const Queue *queue) { if (!queue_isempty(queue)) { const Article *const_ptr = node_get_const_ptr(queue->bottom); return const_ptr; } return 0; }
static void export_service(struct gatt_db_attribute *attr, void *user_data) { struct btd_gatt_client *client = user_data; struct service *service; if (gatt_db_service_get_claimed(attr)) return; service = service_create(attr, client); if (!service) return; if (!create_characteristics(attr, service)) { error("Exporting characteristics failed"); unregister_service(service); return; } queue_push_tail(client->services, service); /* * Asynchronously update the "Characteristics" property of the service. * If there are any pending reads to obtain the value of the "Extended * Properties" descriptor then wait until they are complete. */ if (!service->chrcs_ready && queue_isempty(service->pending_ext_props)) service->idle_id = g_idle_add(set_chrcs_ready, service); }
static char *test_queue_empty() { queue_t queue; queue_init(&queue); mu_assert("Error: queue not empty", queue_isempty(&queue)); queue_destroy(&queue); return 0; }
static void* mevent_start_base_entry(void *arg) { int rv; struct timespec ts; struct queue_entry *q; struct event_entry *e = (struct event_entry*)arg; int *mypos = _tls_get_mypos(); *mypos = e->cur_thread; mtc_dbg("I'm %s %dnd thread", e->name, *mypos); for (;;) { /* Condition waits are specified with absolute timeouts, see * pthread_cond_timedwait()'s SUSv3 specification for more * information. We need to calculate it each time. * We sleep for 1 sec. There's no real need for it to be too * fast (it's only used so that stop detection doesn't take * long), but we don't want it to be too slow either. */ mutil_utc_time(&ts); ts.tv_sec += 1; rv = 0; queue_lock(e->op_queue[*mypos]); while (queue_isempty(e->op_queue[*mypos]) && rv == 0) { rv = queue_timedwait(e->op_queue[*mypos], &ts); } if (rv != 0 && rv != ETIMEDOUT) { errlog("Error in queue_timedwait()"); /* When the timedwait fails the lock is released, so * we need to properly annotate this case. */ __release(e->op_queue[*mypos]->lock); continue; } q = queue_get(e->op_queue[*mypos]); queue_unlock(e->op_queue[*mypos]); if (q == NULL) { if (e->loop_should_stop) { break; } else { continue; } } mtc_dbg("%s %d process", e->name, *mypos); e->process_driver(e, q, *mypos); /* Free the entry that was allocated when tipc queued the * operation. This also frees it's components. */ queue_entry_free(q); } return NULL; }
static inline void job_send_status(jobpool *jp,uint32_t jobid,uint8_t status) { zassert(pthread_mutex_lock(&(jp->pipelock))); if (queue_isempty(jp->statusqueue)) { // first status eassert(write(jp->wpipe,&status,1)==1); // write anything to wake up select } queue_put(jp->statusqueue,jobid,status,NULL,1); zassert(pthread_mutex_unlock(&(jp->pipelock))); return; }
int queue_front(queue_t *thiz, void *data) { if (queue_isempty(thiz)) return -1; memcpy(data, thiz->front->prev->data, thiz->size); return 0; }
bool queue_deq (struct queue *q, unsigned char *ret) { if (queue_isempty( q )) return 0; *ret = q->buff[q->s]; q->s++; q->ocupied--; if (q->s >= q->sz) q->s = 0; return 1; }
int queue_dequeue(queue_t *queue, void **data) { if (queue_isempty(queue)) { return 0; } *data = queue->buffer[queue->tail]; queue->tail = (queue->tail + 1) % queue->size; return 1; }
static void rt_test_005_003_execute(void) { unsigned i; systime_t target_time; msg_t msg; /* [5.3.1] Testing special case TIME_IMMEDIATE.*/ test_set_step(1); { msg = chSemWaitTimeout(&sem1, TIME_IMMEDIATE); test_assert(msg == MSG_TIMEOUT, "wrong wake-up message"); test_assert(queue_isempty(&sem1.queue), "queue not empty"); test_assert(sem1.cnt == 0, "counter not zero"); } /* [5.3.2] Testing non-timeout condition.*/ test_set_step(2); { threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1, thread2, 0); msg = chSemWaitTimeout(&sem1, TIME_MS2I(500)); test_wait_threads(); test_assert(msg == MSG_OK, "wrong wake-up message"); test_assert(queue_isempty(&sem1.queue), "queue not empty"); test_assert(sem1.cnt == 0, "counter not zero"); } /* [5.3.3] Testing timeout condition.*/ test_set_step(3); { target_time = chTimeAddX(test_wait_tick(), TIME_MS2I(5 * 50)); for (i = 0; i < 5; i++) { test_emit_token('A' + i); msg = chSemWaitTimeout(&sem1, TIME_MS2I(50)); test_assert(msg == MSG_TIMEOUT, "wrong wake-up message"); test_assert(queue_isempty(&sem1.queue), "queue not empty"); test_assert(sem1.cnt == 0, "counter not zero"); } test_assert_sequence("ABCDE", "invalid sequence"); test_assert_time_window(target_time, chTimeAddX(target_time, ALLOWED_DELAY), "out of time window"); } }
/* * Remove and return first (oldest) entry from the specified queue * * Parameters: * q Pointer to queue structure * * Return Value: * Node at head of queue - NULL if queue is empty */ QNODE* queue_remove(QUEUE *q) { QNODE *oldest; if (queue_isempty(q)) return NULL; oldest = q->head; q->head = oldest->next; return oldest; }
void queue_add(queue *q,int x) { node *p=(node*)malloc(sizeof(node)); p->data=x; p->next=NULL; if(queue_isempty(q)) q->head=p; else q->tail->next=p; q->tail=p; q->size++; return; }
static void wakeup_writer(struct bt_att *att) { if (att->writer_active) return; /* Set the write handler only if there is anything that can be sent * at all. */ if (queue_isempty(att->write_queue)) { if ((att->pending_req || queue_isempty(att->req_queue)) && (att->pending_ind || queue_isempty(att->ind_queue))) return; } if (!io_set_write_handler(att->io, can_write_data, att, write_watch_destroy)) return; att->writer_active = true; }
Article* queue_pop(Queue *queue) { if (!queue_isempty(queue)) { Article *ptr = node_get_ptr(queue->top); Node *old_top = queue->top; queue->top = node_get_next(queue->top); node_remove(old_top); // Don't delete article in the node queue->size--; return ptr; } return 0; }
QT* queue_pop(queue* getpop) { if (getpop == NULL || *getpop == NULL || queue_isempty(*getpop)) NULL; QT* output = (*getpop)->key; queue hold = *getpop; *getpop = (*getpop)->link; free(hold); return output; }
int queue_setfront(queue* setfro, QT* value) { if (setfro==NULL || *setfro==NULL || value==NULL || queue_isempty(*setfro)) return EXIT_FAILURE; if ((*setfro)->key == value) return EXIT_FAILURE; free((*setfro)->key); (*setfro)->key = value; return EXIT_SUCCESS; }