void __GOMP_barrier_10(void)
{
/* struct queue *queue = get_team_queue(omp_get_team_num()); */
struct queue *queue = get_team_queue(0);
struct queue_cell *cell;
int amount = omp_get_num_threads();
int *waiting = (int *) &queue->data;
int nwait;
queue_acquire(queue);
nwait = *waiting + 1;
if (nwait < amount) {
*waiting = nwait;
enqueue(queue, &self);
queue_release(queue);
queue_cell_wait(&self);
} else {
*waiting = 0;
cell = queue->head;
while (cell) {
queue_cell_wake(cell);
cell = cell->next;
}
queue_flush(queue);
queue_release(queue);
}
}
int main(void)
{
queue_t *queue;
int errcode;
size_t counter = 0,integer,integer_;
queue = queue_initialize(sizeof(int),NULL);
if(!queue){
fputs("Error!\n",stderr);
return -1;
}
while(counter != 128){
integer = counter+10;
errcode = queue_enqueue(queue,&integer);
if(errcode){
fputs("Error!\n",stderr);
queue_release(queue);
return -1;
}
counter++;
}
counter = 0;
while(counter != 32){
errcode = queue_dequeue(queue,&integer);
if(errcode){
fputs("Error!\n",stderr);
queue_release(queue);
return -1;
}
counter++;
}
counter = 0;
while(counter != queue_size(queue)){
errcode = queue_refer_from_front(queue,counter,&integer);
if(errcode){
fputs("Error!\n",stderr);
queue_release(queue);
return -1;
}
errcode = queue_refer_from_back(queue,counter,&integer_);
if(errcode){
fputs("Error!\n",stderr);
queue_release(queue);
return -1;
}
fprintf(stdout,"%03d : %03d %03d\n",counter,integer,integer_);
counter++;
}
queue_release(queue);
return 0;
}
void test_normal_queue() {
buffer_queue* queue = queue_init();
printf("head: %p, tail: %p, fixed: %p\n", queue->head, queue->tail, queue->fixed);
printf("-------- enqueue test: \n");
queue_enqueue(queue, 1, "test_enqueue 1", strlen("test_enqueue 1"));
queue_enqueue(queue, 2, "test_enqueue 2", strlen("test_enqueue 2"));
queue_enqueue(queue, 3, "test_enqueue 3", strlen("test_enqueue 3"));
queue_enqueue(queue, 4, "test_enqueue 4", strlen("test_enqueue 4"));
queue_dump(queue);
buffer term;
queue_dequeue(queue, &term);
printf("dequeue: buff=%s, fd=%d, size=%u\n", term.buffer, term.ud, term.szbuf);
FREE(term.buffer);
queue_dequeue(queue, &term);
printf("dequeue: buff=%s, fd=%d, size=%u\n", term.buffer, term.ud, term.szbuf);
FREE(term.buffer);
queue_dequeue(queue, &term);
printf("dequeue: buff=%s, fd=%d, size=%u\n", term.buffer, term.ud, term.szbuf);
FREE(term.buffer);
queue_dequeue(queue, &term);
printf("dequeue: buff=%s, fd=%d, size=%u\n", term.buffer, term.ud, term.szbuf);
FREE(term.buffer);
int ret = queue_dequeue(queue, &term);
assert(ret< 0);
queue_dump(queue);
queue_release(queue);
}
int main()
{
struct queue* my_queue = NULL;
if(queue_init(&my_queue,QUEUE_SIZE) < 0)
{
return 0;
}
enqueue(my_queue,1);
enqueue(my_queue,2);
enqueue(my_queue,3);
printf("dequeue: %d\n",dequeue(my_queue));
printf("dequeue: %d\n",dequeue(my_queue));
printf("dequeue: %d\n",dequeue(my_queue));
/*
** Deliberately, I do the dequeue() more than
** enqueue() one time. :)
*/
printf("dequeue: %d\n",dequeue(my_queue));
queue_release(my_queue);
return 0;
}
struct queue *service_dispatch(struct monitor *monitor, struct queue *q) {
if (!q) {
q = worker_queue_pop();
if (!q) return 0;
}
uint32_t handle = queue_handle(q);
struct service *s = service_grab(handle);
if (!s) {
queue_release(q, queue_message_dtor, (void *)(uintptr_t)handle);
return worker_queue_pop();
}
struct message m;
if (!queue_pop(q, &m)) {
service_release(handle);
return worker_queue_pop();
}
int overload = queue_overload(q);
if (overload)
service_log(handle, "service may overload, message queue length = %d\n", overload);
monitor_trigger(monitor, m.source, handle);
if (s->logfile)
log_output(s->logfile, &m);
s->module.dispatch(s->handle, s->ud, &m);
service_alloc(m.data, 0);
monitor_trigger(monitor, 0, 0);
struct queue *next = worker_queue_pop();
if (next) {
worker_queue_push(q);
q = next;
}
service_release(handle);
return q;
}
uint32_t service_create(struct module *module, const char *param) {
struct service *s = service_alloc(0, sizeof *s);
s->module = *module;
s->session = 0;
s->logfile = 0;
s->handle = service_regist(s);
s->queue = queue_create(s->handle);
service_total_inc();
s = service_grab(s->handle);
s->ud = module->create(s->handle, param);
if (!s->ud) {
service_log(s->handle, "FAILED %s\n", param);
uint32_t handle = s->handle;
while (!(s = (struct service *)index_release(g.index, handle))) {}
queue_try_release(s->queue);
queue_release(s->queue, queue_message_dtor, (void *)(uintptr_t)handle);
service_alloc(s, 0);
service_total_dec();
return 0;
}
service_log(s->handle, "CREATE %s\n", param);
worker_queue_push(s->queue);
if (service_release(s->handle))
return 0;
return s->handle;
}
/**
* gpmi_release_hw - free the hardware
* @pdev: pointer to platform device
*
* In opposite to gpmi_init_hw, release all acquired resources
*/
static void gpmi_release_hw(struct platform_device *pdev)
{
struct lba_data *data = platform_get_drvdata(pdev);
queue_release(data);
clk_put(data->clk);
gpmi_pinmux_free(pdev->dev.bus_id);
}
static int chan_gc(lua_State* L)
{
struct queue_t* q = _lua_arg_queue(L);
TRACE("chan_gc: %s, refs=%d\n", q->name, q->refs);
pthread_mutex_lock(&_queues_lock);
queue_release(q);
pthread_mutex_unlock(&_queues_lock);
return 0;
}
/**
* gpmi_release_hw - free the hardware
* @pdev: pointer to platform device
*
* In opposite to gpmi_init_hw, release all acquired resources
*/
static void gpmi_release_hw(struct platform_device *pdev)
{
struct gpmi_platform_data *gpd =
(struct gpmi_platform_data *)pdev->dev.platform_data;
struct lba_data *data = platform_get_drvdata(pdev);
queue_release(data);
clk_put(data->clk);
gpd->pinmux(0);
}
int main() {
queue *q = queue_create(8, NULL);
assert(q != NULL);
int a = 10;
int b = 20;
enqueue(q, &a);
enqueue(q, &b);
printf("size=%d\n", queue_size(q));
assert(queue_full(q) != true);
printf("%d\n", *(int *)dequeue(q));
printf("%d\n", *(int *)dequeue(q));
assert(queue_empty(q) != false);
queue_release(q);
}
int main(int argc, char const *argv[])
{
queue *queue = queue_create();
if(!queue) {
printf("Allocate memory error!\n");
exit(0);
}
int num;
printf("Please input some positive numbers.Stop input with number 0.\n");
scanf("%d", &num);
while(num > 0) {
queue = enqueue(queue, (void *)num);
scanf("%d", &num);
}
printf("Print the numbers below.\n\n");
int value;
while((value = (int)dequeue(queue)) != NULL) {
printf("%d\n", value);
}
queue_release(queue);
printf("\nEnd printing.\n");
return 0;
}
void destroy_semaphore(int semaphore)
{
if (semaphore >= num_sem) {
printf("ERROR: Semaphore with id %d does not exist\n.", semaphore);
return;
}
sem_t *sem = sem_table[semaphore];
/* Check to see if threads are waiting first. */
if (queue_size(sem->wait_queue) > 0)
{
printf("ERROR: Cannot destroy semaphore %d because there are threads waiting on it.\n", semaphore);
return;
}
else
{
if (sem->count != sem->init)
printf("WARNING: One or more threads have waited on semaphore %d but not yet signalled.\n", semaphore);
queue_release(sem->wait_queue);
free(sem);
sem_table[semaphore] = NULL;
}
}
/* 找到princess返回需要的步数
* 找不到或者出错返回-1
*/
static int find_princess(struct room_info* maze, struct room_info* prince)
{
struct node_info* queue = NULL;
struct node_info* cur_step = NULL;
queue = (struct node_info*)malloc(sizeof(struct node_info));
if (NULL == queue)
{
return -1;
}
init_node_info(queue);
queue->parent = NULL;
queue->level = 0;
queue->room = prince;
cur_step = queue;
while (cur_step != NULL)
{
struct room_info* cur_room = cur_step->room;
if (NULL == cur_room)
{
fprintf(stderr, "IT CAN NOT HAPPEN!\n");
break;
}
if (TYPE_PRINCESS == cur_room->type)
{
struct node_info* tmp = cur_step;
/* we find princess :) */
fprintf(stdout, "\nThe way back to prince... \n");
while (tmp != NULL)
{
fprintf(stdout, "(%d, %d) ", tmp->room->row, tmp->room->col);
tmp = tmp->parent;
}
fprintf(stdout, "\n");
queue_release(queue);
return cur_step->level;
}
else if (TYPE_ROAD == cur_room->type
|| TYPE_PRINCE == cur_room->type)
{
struct room_info* tmp = NULL;
if (1 == cur_room->pass_by)
{
cur_step = cur_step->next;
continue;
}
cur_room->pass_by = 1;
/* 把孩子们丢到队列后面 */
tmp = cur_room->child[D_UP];
queue_push(queue, tmp, cur_step->level, cur_step);
tmp = cur_room->child[D_DOWN];
queue_push(queue, tmp, cur_step->level, cur_step);
tmp = cur_room->child[D_LEFT];
queue_push(queue, tmp, cur_step->level, cur_step);
tmp = cur_room->child[D_RIGHT];
queue_push(queue, tmp, cur_step->level, cur_step);
}
else
{
fprintf(stderr, "Wired!\n");
}
cur_step = cur_step->next;
}
queue_release(queue);
return -1;
}
