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;
}
