Queue *queue_new (void) { Queue *newQueue = mem_new(Queue,1); queue_head(newQueue) = NULL; queue_tail(newQueue) = NULL; return newQueue; }
queue_node_t* window_get( window_t* window, uint32_t index) { debug_print("window_get()\n"); //printf("index: %d\n", index); if (!window || index >= window->size) { return 0; } if (!index) { return window->buffer->head; } //printf("check\n"); queue_node_t* node = queue_head(window->buffer); uint32_t node_count = 0; while (node_count++ < (index-1)) { node = node->next; } //while (node && node->next && node_count < (index+1)) { // printf("%d\n", node_count); // // node = node->next; // node_count++; //} //printf("%d\n", node_count); return node; }
static inline enum comp_state get_wqe(struct rxe_qp *qp, struct rxe_pkt_info *pkt, struct rxe_send_wqe **wqe_p) { struct rxe_send_wqe *wqe; /* we come here whether or not we found a response packet to see if * there are any posted WQEs */ wqe = queue_head(qp->sq.queue); *wqe_p = wqe; /* no WQE or requester has not started it yet */ if (!wqe || wqe->state == wqe_state_posted) return pkt ? COMPST_DONE : COMPST_EXIT; /* WQE does not require an ack */ if (wqe->state == wqe_state_done) return COMPST_COMP_WQE; /* WQE caused an error */ if (wqe->state == wqe_state_error) return COMPST_ERROR; /* we have a WQE, if we also have an ack check its PSN */ return pkt ? COMPST_CHECK_PSN : COMPST_EXIT; }
void window_slide( window_t* window) { debug_print("window_slide()\n"); queue_node_t* node; packet_t* packet; window_lock(window); while (window->buffer->size > 0) { node = queue_head(window->buffer); packet = node->data; if (!packet->needs_ack && packet->transmission_time) { node = queue_dequeue(window->buffer, false); packet_free(node->data); free(node); if (window->size) { window->size--; } } else { break; } } window_unlock(window); window_out_commit(window); success_print("window_slide() succeed\n"); }
/* Process any events whose time has come. */ void event_process(void) { struct event *the_event; long new_time; while ((long) pulse >= queue_key(event_q)) { if (!(the_event = (struct event *) queue_head(event_q))) { log("SYSERR: Attempt to get a NULL event"); return; } /* ** Set the_event->q_el to NULL so that any functions called beneath ** event_process can tell if they're being called beneath the actual ** event function. */ the_event->q_el = NULL; /* call event func, reenqueue event if retval > 0 */ if ((new_time = (the_event->func)(the_event->event_obj)) > 0) the_event->q_el = queue_enq(event_q, the_event, new_time + pulse); else { free(the_event); } } }
void test_OneElementQueue(void) { queue* q = create_queue(); TEST_ASSERT_NOT_NULL(q); element e = {"string", 3}; element* e_ptr = debug_get_node(sizeof(element)); enqueue(q, e_ptr); *e_ptr = e; TEST_ASSERT_FALSE(empty(q)); TEST_ASSERT_NOT_NULL(queue_head(q)); TEST_ASSERT_EQUAL(1, get_no_of_elements(q)); element* e_ptr_returned = dequeue(q); TEST_ASSERT_NOT_NULL(e_ptr_returned); TEST_ASSERT_EQUAL_STRING(e_ptr_returned->str, "string"); TEST_ASSERT_EQUAL_PTR(e_ptr_returned, e_ptr); TEST_ASSERT_EQUAL(0, get_no_of_elements(q)); TEST_ASSERT_TRUE(empty(q)); TEST_ASSERT_NULL(dequeue(q)); destroy_queue(q); }
/* ping 帧永远插到最前面*/ void Http2Base::PushFrame(Http2_header *header){ uint32_t id = HTTP2_ID(header->id); LOGD(DHTTP2, "push a frame [%d]:%d, size:%d, flags: %d\n", id, header->type, get24(header->length), header->flags); std::list<write_block>::insert_iterator i; if((http2_flag & HTTP2_FLAG_INITED) == 0){ i = queue_end(); goto ret; } switch(header->type){ case PING_TYPE: for(i = queue_head(); i!= queue_end() ; i++){ if(i->offset){ continue; } const Http2_header* check = (const Http2_header*)i->buff; if(check->type != PING_TYPE){ break; } } break; case HEADERS_TYPE:{ auto j = queue_end(); do{ i = j--; if(j == queue_head() || j->offset){ break; } const Http2_header* check = (const Http2_header*)j->buff; if(check->type != DATA_TYPE) break; uint32_t jid = HTTP2_ID(check->id); if(jid == 0 || jid == id) break; }while(true); break; } default: i = queue_end(); break; } ret: size_t length = sizeof(Http2_header) + get24(header->length); assert(i == queue_end() || i == queue_head() || i->offset == 0); queue_insert(i, write_block{header, length, 0}); }
int pipe_discard(packet_pipe_t * pipe, xrtp_hrtime_t deadline){ pipe_load_t * load; int npacket = 0; load = (pipe_load_t*)queue_head(pipe->packets); while( load && TIME_NEWER(deadline, load->max_usec) ){ queue_serve(pipe->packets); if(pipe->type == XRTP_RTP){ xrtp_rtp_packet_t * rtp = (xrtp_rtp_packet_t*)(load->packet); pipe_rtp_outgoing(pipe, rtp); rtp_packet_done(rtp); } if(pipe->type == XRTP_RTCP){ xrtp_rtcp_compound_t * rtcp = (xrtp_rtcp_compound_t*)(load->packet); pipe_rtcp_outgoing(pipe, rtcp); rtcp_compound_done(rtcp); } xfree(load); npacket++; load = (pipe_load_t*)queue_head(pipe->packets); } if(load){ pipe->next_us = load->max_usec; }else{ pipe->next_us = HRTIME_INFINITY; } if(pipe->pipe_discard_cb) pipe->pipe_discard_cb(pipe->pipe_discard_callee, pipe->next_us, npacket); return npacket; }
static enum resp_states check_resource(struct rxe_qp *qp, struct rxe_pkt_info *pkt) { struct rxe_srq *srq = qp->srq; if (qp->resp.state == QP_STATE_ERROR) { if (qp->resp.wqe) { qp->resp.status = IB_WC_WR_FLUSH_ERR; return RESPST_COMPLETE; } else if (!srq) { qp->resp.wqe = queue_head(qp->rq.queue); if (qp->resp.wqe) { qp->resp.status = IB_WC_WR_FLUSH_ERR; return RESPST_COMPLETE; } else { return RESPST_EXIT; } } else { return RESPST_EXIT; } } if (pkt->mask & RXE_READ_OR_ATOMIC) { /* it is the requesters job to not send * too many read/atomic ops, we just * recycle the responder resource queue */ if (likely(qp->attr.max_dest_rd_atomic > 0)) return RESPST_CHK_LENGTH; else return RESPST_ERR_TOO_MANY_RDMA_ATM_REQ; } if (pkt->mask & RXE_RWR_MASK) { if (srq) return get_srq_wqe(qp); qp->resp.wqe = queue_head(qp->rq.queue); return (qp->resp.wqe) ? RESPST_CHK_LENGTH : RESPST_ERR_RNR; } return RESPST_CHK_LENGTH; }
/* frees all events in the queue */ void event_free_all(void) { struct event *the_event; while ((the_event = (struct event *) queue_head(event_q))) { if (the_event->event_obj) free(the_event->event_obj); free(the_event); } queue_free(event_q); }
void test_EmptyQueue(void) { queue* q = create_queue(); TEST_ASSERT_NOT_NULL(q); TEST_ASSERT_TRUE(empty(q)); TEST_ASSERT_NULL(queue_head(q)); TEST_ASSERT_NULL(dequeue(q)); TEST_ASSERT_EQUAL(0, get_no_of_elements(q)); destroy_queue(q); }
static void req_retry(struct rxe_qp *qp) { struct rxe_send_wqe *wqe; unsigned int wqe_index; unsigned int mask; int npsn; int first = 1; wqe = queue_head(qp->sq.queue); npsn = (qp->comp.psn - wqe->first_psn) & BTH_PSN_MASK; qp->req.wqe_index = consumer_index(qp->sq.queue); qp->req.psn = qp->comp.psn; qp->req.opcode = -1; for (wqe_index = consumer_index(qp->sq.queue); wqe_index != producer_index(qp->sq.queue); wqe_index = next_index(qp->sq.queue, wqe_index)) { wqe = addr_from_index(qp->sq.queue, wqe_index); mask = wr_opcode_mask(wqe->wr.opcode, qp); if (wqe->state == wqe_state_posted) break; if (wqe->state == wqe_state_done) continue; wqe->iova = (mask & WR_ATOMIC_MASK) ? wqe->wr.wr.atomic.remote_addr : (mask & WR_READ_OR_WRITE_MASK) ? wqe->wr.wr.rdma.remote_addr : 0; if (!first || (mask & WR_READ_MASK) == 0) { wqe->dma.resid = wqe->dma.length; wqe->dma.cur_sge = 0; wqe->dma.sge_offset = 0; } if (first) { first = 0; if (mask & WR_WRITE_OR_SEND_MASK) retry_first_write_send(qp, wqe, mask, npsn); if (mask & WR_READ_MASK) wqe->iova += npsn * qp->mtu; } wqe->state = wqe_state_posted; } }
/* * find the middle queue element if the queue has odd number of elements * or the first element of the queue's second part otherwise */ queue_t * queue_middle(queue_t *queue) { queue_t *middle, *next; middle = queue_head(queue); if (middle == queue_tail(queue)) { return middle; } next = queue_head(queue); for ( ;; ) { middle = queue_next(middle); next = queue_next(next); if (next == queue_tail(queue)) { return middle; } next = queue_next(next); if (next == queue_tail(queue)) { return middle; } } /* no reached */ }
int main(int argc, char const *argv[]) { void * queue; queue = queue_create(); teacher_t t[50]; for (int i = 0 ; i < 50; i++) { t[i].age = i; queue_insert(queue, &t[i]); } teacher_t * p; int k = queue_length(queue); for (int i = 0; i < k-1; i++) { p = (teacher_t *)queue_delete(queue); fprintf(stdout, "%d ", p->age); } fprintf(stdout, "\n"); p = (teacher_t *)queue_head(queue); fprintf(stdout, "%d ", p->age); fprintf(stdout, "\n"); queue_delete(queue); for (int i = 0 ; i < 50; i++) { t[i].age = i + 100; queue_insert(queue, &t[i]); } if (!queue_empty(queue)) fprintf(stdout, "queue is not empty\n"); k = queue_length(queue); for (int i = 0; i < k; i++) { p = (teacher_t *)queue_delete(queue); fprintf(stdout, "%d ", p->age); } fprintf(stdout, "\n"); if (queue_empty(queue)) fprintf(stdout, "queue not empty\n"); queue_destroy(queue); return 0; }
void test_CustomOrderQueue(void) { queue* q = debug_create_priority_queue(compare_elements); element *e1_ptr, *e2_ptr, *e3_ptr, *e4_ptr, *e5_ptr, *e6_ptr; e1_ptr = (element*)debug_get_node(sizeof(element)); e2_ptr = (element*)debug_get_node(sizeof(element)); e3_ptr = (element*)debug_get_node(sizeof(element)); e4_ptr = (element*)debug_get_node(sizeof(element)); e5_ptr = (element*)debug_get_node(sizeof(element)); e6_ptr = (element*)debug_get_node(sizeof(element)); e1_ptr->number = 1; e2_ptr->number = 1; e3_ptr->number = 10; e4_ptr->number = 10; e5_ptr->number = 100; e6_ptr->number = 100; enqueue(q, e3_ptr); enqueue(q, e5_ptr); enqueue(q, e2_ptr); enqueue(q, e1_ptr); enqueue(q, e4_ptr); enqueue(q, e6_ptr); TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 100); TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 100); TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 100); TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 100); TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 10); TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 10); TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 10); TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 10); TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 1); TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 1); TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 1); TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 1); TEST_ASSERT_TRUE(empty(q)); destroy_queue(q); free_node(e1_ptr); free_node(e2_ptr); free_node(e3_ptr); free_node(e4_ptr); free_node(e5_ptr); free_node(e6_ptr); }
static void* consumer_run(void* ptr) { Queue* queue = (Queue*)ptr; int i = 0; int ret_data; for(i = 0; i < 1000; i++) { usleep(200); if (queue_head(queue, (void**)&ret_data) != RET_OK) { continue; } printf("\t pop: %d\n", ret_data); assert(queue_pop(queue) == RET_OK); } return NULL; }
int channel_select_remove(channel *chan){ uvc_ctx *ctx=uvc_self(); //queue_t *node; queue_t *q = queue_head(&chan->readq); for (; q != queue_sentinel(&chan->readq); q = queue_next(&chan->readq)) { if(q->ext == ctx){ queue_remove(q); } } for (; q != queue_sentinel(&chan->writq); q = queue_next(&chan->writq)) { if(q->ext == ctx){ queue_remove(q); } } return 0; }
void window_out_commit( window_t* window) { debug_print("window_out_commit()\n"); window_lock(window); if (!window->buffer->size) { window->size = 0; window->head = 0; window->tail = 0; } else { window->size = MIN(window->max_size, window->buffer->size); window->head = queue_head(window->buffer); window->tail = window_get(window, window->size-1); //printf("head: %p, tail: %p\n", window->head, window->tail); if (!window->tail || !window->head) { return; } queue_node_t* node = window->head; packet_t* packet = (packet_t*) node->data; while(node != window->tail) { packet = (packet_t*) node->data; if (!packet->transmission_time) { channel_send_packet(packet); } node = node->next; } if (node == window->tail) { if (!packet->transmission_time) { channel_send_packet(packet); } } } window_unlock(window); success_print("window_out_commit() succeed\n"); }
static void rxe_drain_resp_pkts(struct rxe_qp *qp, bool notify) { struct sk_buff *skb; struct rxe_send_wqe *wqe; while ((skb = skb_dequeue(&qp->resp_pkts))) { rxe_drop_ref(qp); kfree_skb(skb); } while ((wqe = queue_head(qp->sq.queue))) { if (notify) { wqe->status = IB_WC_WR_FLUSH_ERR; do_complete(qp, wqe); } else { advance_consumer(qp->sq.queue); } } }
bool window_out_ack( window_t* window, packet_t* ack_packet) { debug_print("window_ack_set()\n"); if (!window || !ack_packet || !window->size || !window->buffer->size) { return false; } queue_node_t* node = window->head; uint8_t node_count = 1; packet_t* packet; while(node && node_count <= window->size) { packet = (packet_t*) node->data; if (packet->needs_ack && packet_ack_valid(packet, ack_packet)) { packet->needs_ack = false; utimer_set(packet->timer_retrans, 0); if (queue_head(window->buffer)== node) { window_slide(window); } goto succeed; } node_count++; node = node->next; } error_print("window_ack_set() failed\n"); return false; succeed: success_print("window_ack_set() succeed\n"); return true; }
static int rxe_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *wc) { int i; struct rxe_cq *cq = to_rcq(ibcq); struct rxe_cqe *cqe; unsigned long flags; spin_lock_irqsave(&cq->cq_lock, flags); for (i = 0; i < num_entries; i++) { cqe = queue_head(cq->queue); if (!cqe) break; memcpy(wc++, &cqe->ibwc, sizeof(*wc)); advance_consumer(cq->queue); } spin_unlock_irqrestore(&cq->cq_lock, flags); return i; }
static enum resp_states get_srq_wqe(struct rxe_qp *qp) { struct rxe_srq *srq = qp->srq; struct rxe_queue *q = srq->rq.queue; struct rxe_recv_wqe *wqe; struct ib_event ev; if (srq->error) return RESPST_ERR_RNR; spin_lock_bh(&srq->rq.consumer_lock); wqe = queue_head(q); if (!wqe) { spin_unlock_bh(&srq->rq.consumer_lock); return RESPST_ERR_RNR; } /* note kernel and user space recv wqes have same size */ memcpy(&qp->resp.srq_wqe, wqe, sizeof(qp->resp.srq_wqe)); qp->resp.wqe = &qp->resp.srq_wqe.wqe; advance_consumer(q); if (srq->limit && srq->ibsrq.event_handler && (queue_count(q) < srq->limit)) { srq->limit = 0; goto event; } spin_unlock_bh(&srq->rq.consumer_lock); return RESPST_CHK_LENGTH; event: spin_unlock_bh(&srq->rq.consumer_lock); ev.device = qp->ibqp.device; ev.element.srq = qp->ibqp.srq; ev.event = IB_EVENT_SRQ_LIMIT_REACHED; srq->ibsrq.event_handler(&ev, srq->ibsrq.srq_context); return RESPST_CHK_LENGTH; }
/* the stable insertion sort */ void queue_sort(queue_t *queue, int (*cmp)(const queue_t *, const queue_t *)) { queue_t *q, *prev, *next; q = queue_head(queue); if (q == queue_tail(queue)) { return; } for (q = queue_next(q); q != queue_sentinel(queue); q = next) { prev = queue_prev(q); next = queue_next(q); queue_remove(q); do { if (cmp(prev, q) <= 0) { break; } prev = queue_prev(prev); } while (prev != queue_sentinel(queue)); queue_insert_head(prev, q); } }
extern void dispatcher(Queue* in, Queue* out, pthread_mutex_t *mutex){ pthread_mutex_lock(mutex); if (!is_empty(in)){ uint8_t packet_length = queue_head(in); if (in->count >= packet_length){ uint8_t count = dequeue(in); t_command command = dequeue(in); printf ("%s receive packet with command %i\n", KNRM, command); switch (command){ case INIT: init(in); acknowledge(out); break; case SET_DIAM_WHEELS: set_diam_wheels(in); acknowledge(out); break; case SET_WHEELS_SPACING: set_wheels_spacing(in); acknowledge(out); break; case SET_PID_TRSL: set_pid_trsl(in); acknowledge(out); break; case SET_PID_ROT: set_pid_rot(in); acknowledge(out); break; case SET_TRSL_ACC: set_trsl_acc(in); acknowledge(out); break; case SET_TRSL_DEC: set_trsl_dec(in); acknowledge(out); break; case SET_TRSL_MAXSPEED: set_trsl_max(in); acknowledge(out); break; case SET_ROT_ACC: set_rot_acc(in); acknowledge(out); break; case SET_ROT_DEC: set_rot_dec(in); acknowledge(out); break; case SET_ROT_MAXSPEED: set_rot_max(in); acknowledge(out); break; case SET_DELTA_MAX_ROT: set_delta_max_rot(in); acknowledge(out); break; case SET_DELTA_MAX_TRSL: set_delta_max_trsl(in); acknowledge(out); break; case SET_PWM: set_pwm(in); acknowledge(out); break; case SET_X: set_x(in); acknowledge(out); break; case SET_Y: set_y(in); acknowledge(out); break; case SET_THETA: set_theta(in); acknowledge(out); break; case TELEMETRY: set_telemetry(in); acknowledge(out); break; case SET_DEBUG: set_debug(in); acknowledge(out); break; case GOTO_XY: goto_xy(in); acknowledge(out); break; case GOTO_THETA: goto_theta(in); acknowledge(out); break; case FREE: execute_free(in); acknowledge(out); break; case STOP_ASAP: stop_asap(in); acknowledge(out); break; case MOVE_TRSL: move_trsl(in); acknowledge(out); break; case MOVE_ROT: move_rot(in); acknowledge(out); break; case RECALAGE: execute_recalage(in); acknowledge(out); break; case CURVE: curve(in); acknowledge(out); break; case GET_POSITION: getPosition(out); break; case GET_PID_TRSL: getPIDtrsl(out); break; case GET_PID_ROT: getPIDRot(out); break; case GET_SPEEDS: getSpeed(out); break; case GET_WHEELS: getWheels(out); break; case GET_DELTA_MAX: getDeltaMax(out); break; case GET_VECTOR_TRSL: getVectorTrsl (out); break; case GET_VECTOR_ROT: getVectorRot (out); break; default: printf ("/!\\ command error: %i\n", command); send_error(out, COULD_NOT_READ); break; } } } pthread_mutex_unlock(mutex); }
void window_in_commit( window_t* window) { debug_print("window_in_commit()\n"); window_lock(window); if (!window->buffer->size) { window->size = 0; window->head = 0; window->tail = 0; } else { if (!window->head) { window->head = queue_head(window->buffer); } packet_t* packet; while (window->head->next) { packet = window->head->data; //printf("%08X == %08X, %08X == %08X\n", //packet->header->sequence, packet->socket->channel->acknowledge, //packet->header->acknowledge, packet->socket->channel->sequence +1); if (packet->header->sequence == packet->socket->channel->acknowledge && packet->header->acknowledge == packet->socket->channel->sequence /*+ (packet->socket->options->state == STATE_ESTABLISHED? 1:0)*/) { packet->socket->channel->acknowledge += packet->data_buffer_size; //packet->socket->channel->acknowledge = // packet->header->sequence + packet->data_buffer_size; //packet->socket->channel->sequence = packet->header->acknowledge; channel_send_ack(packet->socket, packet); window->head = window->head->next; } else { goto cleanup; } } if (window->head) { packet = window->head->data; //printf("%08X == %08X, %08X == %08X\n", //packet->header->sequence, packet->socket->channel->acknowledge, //packet->header->acknowledge, packet->socket->channel->sequence +1); if (packet->header->sequence == packet->socket->channel->acknowledge && packet->header->acknowledge == packet->socket->channel->sequence /*+ (packet->socket->options->state == STATE_ESTABLISHED? 1:0)*/) { packet->socket->channel->acknowledge += packet->data_buffer_size; //packet->socket->channel->sequence = packet->header->acknowledge; channel_send_ack(packet->socket, packet); sem_post(&window->available); window->head = window->head->next; } else { } } } /* queue_node_t* node = window->head; packet_t* packet; uint32_t current_size = 0; while (node && current_size++ < window->size) { window->tail = node; packet = node->data; if (!packet->ack || !packet->ack->transmission_time && window_sequenced(window, node->prev, node)) { printf("seq:%08X == %08X, ack:%08X == %08X\n", packet->socket->channel->sequence, packet->header->sequence, packet->socket->channel->acknowledge, packet->header->acknowledge); channel_send_ack(packet->socket, packet); } node = node->next; } } window_unlock(window); success_print("window_in_commit() succeed\n"); //socket->channel->acknowledge = // packet->header->sequence + packet->data_buffer_size; //socket->channel->sequence = packet->header->acknowledge; //if (channel_send_ack(socket, packet) < 0) // goto failed; * */ cleanup: window_unlock(window); success_print("window_in_commit() succeed\n"); }
static struct rxe_send_wqe *req_next_wqe(struct rxe_qp *qp) { struct rxe_send_wqe *wqe = queue_head(qp->sq.queue); unsigned long flags; if (unlikely(qp->req.state == QP_STATE_DRAIN)) { /* check to see if we are drained; * state_lock used by requester and completer */ spin_lock_irqsave(&qp->state_lock, flags); do { if (qp->req.state != QP_STATE_DRAIN) { /* comp just finished */ spin_unlock_irqrestore(&qp->state_lock, flags); break; } if (wqe && ((qp->req.wqe_index != consumer_index(qp->sq.queue)) || (wqe->state != wqe_state_posted))) { /* comp not done yet */ spin_unlock_irqrestore(&qp->state_lock, flags); break; } qp->req.state = QP_STATE_DRAINED; spin_unlock_irqrestore(&qp->state_lock, flags); if (qp->ibqp.event_handler) { struct ib_event ev; ev.device = qp->ibqp.device; ev.element.qp = &qp->ibqp; ev.event = IB_EVENT_SQ_DRAINED; qp->ibqp.event_handler(&ev, qp->ibqp.qp_context); } } while (0); } if (qp->req.wqe_index == producer_index(qp->sq.queue)) return NULL; wqe = addr_from_index(qp->sq.queue, qp->req.wqe_index); if (unlikely((qp->req.state == QP_STATE_DRAIN || qp->req.state == QP_STATE_DRAINED) && (wqe->state != wqe_state_processing))) return NULL; if (unlikely((wqe->wr.send_flags & IB_SEND_FENCE) && (qp->req.wqe_index != consumer_index(qp->sq.queue)))) { qp->req.wait_fence = 1; return NULL; } wqe->mask = wr_opcode_mask(wqe->wr.opcode, qp); return wqe; }
int pipe_complete(packet_pipe_t * pipe, xrtp_hrtime_t deadline, int budget, xrtp_hrtime_t * r_nextts, int * r_nts){ pipe_load_t * load; int npacket = 0, nbytes = 0; pipe_step_t * step = NULL; rtime_t us_prev; *r_nts = 0; load = (pipe_load_t*)queue_head(pipe->packets); us_prev = load->max_usec; while( load && !TIME_NEWER(deadline, load->max_usec) && pipe->curr_bytes_budget >= load->packet_bytes){ queue_serve(pipe->packets); if(pipe->type == XRTP_RTP){ xrtp_rtp_packet_t * rtp = (xrtp_rtp_packet_t*)(load->packet); pipe_rtp_outgoing(pipe, rtp); rtp_packet_done(rtp); } if(pipe->type == XRTP_RTCP){ xrtp_rtcp_compound_t * rtcp = (xrtp_rtcp_compound_t*)(load->packet); pipe_rtcp_outgoing(pipe, rtcp); rtcp_compound_done(rtcp); } xfree(load); step->load = NULL; npacket++; nbytes += load->packet_bytes; pipe->curr_bytes_budget -= load->packet_bytes; load = (pipe_load_t*)queue_head(pipe->packets); if(load->max_usec != us_prev) *r_nts++; } if(load){ *r_nextts = pipe->next_us = load->max_usec; }else{ *r_nextts = pipe->next_us = HRTIME_INFINITY; } if(pipe->pipe_complete_cb) pipe->pipe_complete_cb(pipe->pipe_complete_callee, pipe->next_us, npacket, nbytes); return XRTP_OK; }