int main(void)
{
struct queue queue;
int i;
init_queue(&queue);
for (i = 0; i < MAX_QUEUE_SIZE; i++) {
enqueue(&queue, i);
}
print_queue(&queue);
if (1 != is_queue_full(&queue))
enqueue(&queue, 10);
print_queue(&queue);
fprintf(stdout, "front :%d, rear :%d\n",
queue.front, queue.rear);
int data;
fprintf(stdout, "dequeue\n");
dequeue(&queue, &data);
fprintf(stdout, "data :%d\n", data);
enqueue(&queue, 11);
fprintf(stdout, "front :%d, rear :%d\n",
queue.front, queue.rear);
print_queue(&queue);
destroy_queue(&queue);
return 0;
}
void enqueue(queue **q_ref,int payload){
//Insert element
if(is_queue_full(q_ref)== SUCCESS) {
(*q_ref)->piles[(*q_ref)->head] = payload;
(*q_ref)->head += 1;
printf("enqueued element = %d\n",payload);
}
}
void do_keyboard()
{
u8 scan_code = io_inb(0x60); /* 读取扫描码 */
if (!is_queue_full(&kb_queue)) /* 若队列未满则入队，否则放弃该扫描码 */
{
en_queue(&kb_queue, scan_code);
}
io_outb(0x20, 0x20);
}
static inline int enqueue(struct queue *queue, int data)
{
CHECK_QUEUE_POINTER(queue);
if (1 == is_queue_full(queue)) {
fprintf(stderr, "queue is full\n");
return -1;
}
queue->data[queue->rear] = data;
queue->rear = (queue->rear + 1) % MAX_QUEUE_SIZE;
queue->flag = 1;
return 0;
}
int
enqueue(Any_Type a, struct Queue *q) {
if (is_queue_full(q))
return 0;
q->num_elements++;
if (++q->last_element == q->wheel_size)
q->last_element = 0;
q->wheel[q->last_element] = a;
return 1;
}
void *iTASK_1(void *t){
for(;;){
if( SYS_STATUS == OS_QUEUE_FAIL){ pthread_exit(NULL); }
pthread_mutex_lock(&count_mutex);
if( is_queue_full(&qptr) == QUEUE_OK ||
is_queue_exist(&qptr,TASK[1].id) == QUEUE_OK ){
printf("%s,%s","@iTask_1->",encode(OS_QUEUE_FULL | OS_QUEUE_EXIST));
} else {
if( push_queue_head(&qptr,TASK[1].id,TASK[1].time_out,TASK[1].priority,TASK[1].work_time) != QUEUE_OK ){
printf("%s,%s","@iTASK_1->",encode(OS_QUEUE_FAIL));
SYS_STATUS = OS_QUEUE_FAIL;
pthread_exit(NULL);
}
}
pthread_mutex_unlock(&count_mutex);
sleep(TASK[1].sleep);
}
}
static inline int print_queue(struct queue *queue)
{
CHECK_QUEUE_POINTER(queue);
int i, start;
if (1 == is_queue_empty(queue)) {
return 0;
} else {
if (1 == is_queue_full(queue)) {
fprintf(stdout, "queue[%d]:%d\n",
queue->front, queue->data[queue->front]);
start = (queue->front + 1) % MAX_QUEUE_SIZE;
} else {
start = queue->front;
}
for (i = start; i != queue->rear; i = (i + 1) % MAX_QUEUE_SIZE) {
fprintf(stdout, "queue[%d]:%d\n",
i, queue->data[i]);
}
}
}
static int
main_loop(SESSION *sess)
{
fd_set rfds, wfds, exfds;
int i, stdin_closed;
sess->inbuf = queue_new(INLET_QUEUE_SIZE);
sess->outbuf = queue_new(OUTLET_QUEUE_SIZE);
if (sess->inbuf == NULL || sess->outbuf == NULL)
error(1, "Can't allocate the mainstream queues.\n");
for (i = 0; i < sess->num_workers; i++) {
sess->workers[i].inbuf = queue_new(INQUEUE_SIZE);
sess->workers[i].outbuf = queue_new(OUTQUEUE_SIZE);
if (sess->workers[i].inbuf == NULL || sess->workers[i].outbuf == NULL)
error(1, "Failed to allocate buffer queues.\n");
}
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&exfds);
stdin_closed = 0;
for (;;) {
int maxfd=-1, nevents;
struct timeval tv, *timeout;
if (stdin_closed || is_queue_full(sess->inbuf))
FD_CLR(STDIN_FILENO, &rfds);
else {
FD_SET(STDIN_FILENO, &rfds);
maxfd = FD_MAX(maxfd, STDIN_FILENO);
}
if (!is_queue_empty(sess->outbuf)) {
FD_SET(STDOUT_FILENO, &wfds);
maxfd = FD_MAX(maxfd, STDOUT_FILENO);
}
else
FD_CLR(STDOUT_FILENO, &wfds);
for (i = 0; i < sess->num_workers; i++) {
WORKER *w=&sess->workers[i];
if (!IS_STDOUT_ALIVE(w) || is_queue_full(w->inbuf))
FD_CLR(w->stdout_fd, &rfds);
else {
FD_SET(w->stdout_fd, &rfds);
maxfd = FD_MAX(maxfd, w->stdout_fd);
}
if (IS_STDIN_ALIVE(w) && !is_queue_empty(w->outbuf)) {
FD_SET(w->stdin_fd, &wfds);
maxfd = FD_MAX(maxfd, w->stdin_fd);
}
else
FD_CLR(w->stdin_fd, &wfds);
}
if (maxfd < 0 && sess->running_workers <= 0)
break;
tv.tv_sec = 0;
tv.tv_usec = 500000;
timeout = &tv;
if ((nevents = select(maxfd + 1, &rfds, &wfds, &exfds, timeout)) == -1) {
if (errno == EINTR)
continue;
perror("echidna");
error(1, "Error on select()\n");
}
if (nevents == 0) { /* select timed out. */
if (!is_queue_full(sess->outbuf)) {
/* Traverse all workers and try processing for blocked output queues. */
for (i = 0; i < sess->num_workers; i++) {
WORKER *w=&sess->workers[i];
if (w->status == STATUS_RUNNING && !is_queue_empty(w->inbuf))
w->input_handler(sess, w);
}
}
continue;
}
if (FD_ISSET(STDIN_FILENO, &rfds)) {
char *bufstart;
qsize_t bufsize;
ssize_t rsize;
bufsize = queue_num_continuous_vacant(sess->inbuf, &bufstart);
if ((rsize = read(STDIN_FILENO, bufstart, bufsize)) < 0)
error(1, "Error on reading from stdin.\n");
if (rsize == 0)
stdin_closed = 1;
else
queue_queued(sess->inbuf, rsize);
sess->input_handler(sess);
}
if (FD_ISSET(STDOUT_FILENO, &wfds)) {
char *bufstart;
qsize_t bufsize;
ssize_t wsize;
bufsize = queue_num_continuous_filled(sess->outbuf, &bufstart);
if ((wsize = write(STDOUT_FILENO, bufstart, bufsize)) < 0) {
if (errno != EAGAIN)
error(1, "Error on writing to stdout.\n");
}
queue_consumed(sess->outbuf, wsize);
for (i = 0; i < sess->num_workers; i++) {
WORKER *w=&sess->workers[i];
if (!is_queue_empty(w->inbuf))
w->input_handler(sess, w);
}
}
for (i = 0; i < sess->num_workers; i++) {
WORKER *w=&sess->workers[i];
if (FD_ISSET(w->stdout_fd, &rfds)) {
char *bufstart;
qsize_t bufsize;
ssize_t rsize;
bufsize = queue_num_continuous_vacant(w->inbuf, &bufstart);
if ((rsize = read(w->stdout_fd, bufstart, bufsize)) < 0)
error(1, "Error on reading from worker %d.\n", i);
if (rsize == 0)
w->status = STATUS_TERMINATED;
else
queue_queued(w->inbuf, rsize);
w->input_handler(sess, w);
}
if (FD_ISSET(w->stdin_fd, &wfds)) {
char *bufstart;
qsize_t bufsize;
ssize_t wsize;
bufsize = queue_num_continuous_filled(w->outbuf, &bufstart);
if ((wsize = write(w->stdin_fd, bufstart, bufsize)) < 0) {
if (errno != EAGAIN)
error(1, "Error on writing to worker %d.\n", i);
}
queue_consumed(w->outbuf, wsize);
sess->input_handler(sess);
}
else if (stdin_closed && w->status == STATUS_RUNNING &&
is_queue_empty(w->outbuf)) {
w->status = STATUS_FLUSHING;
if (close(w->stdin_fd) == -1)
perror("close");
}
}
}
for (i = 0; i < sess->num_workers; i++) {
queue_destroy(sess->workers[i].inbuf);
queue_destroy(sess->workers[i].outbuf);
}
queue_destroy(sess->inbuf);
queue_destroy(sess->outbuf);
return 0;
}
