Beispiel #1
0
/*
 * Create a key
 * this means getting a key from the the pool
 */
int lthread_key_create(unsigned int *key, tls_destructor_func destructor)
{
	if (key == NULL)
		return POSIX_ERRNO(EINVAL);

	struct lthread_key *new_key;

	if (rte_ring_mc_dequeue((struct rte_ring *)key_pool, (void **)&new_key)
	    == 0) {
		new_key->destructor = destructor;
		*key = (new_key - key_table);

		return 0;
	}
	return POSIX_ERRNO(EAGAIN);
}
Beispiel #2
0
int app_func(void *arg)
{
    struct rte_ring *ring1, *ring2;
    static struct message *msg1, *msg2;
    static struct message *msg3, *msg4;
    static struct message out_msg1, out_msg2;
    unsigned long long int t1 = 0, t2 = 0;
    int i = 0;
    out_msg1.message_id = 2;
    out_msg1.payload1 = 0;
    out_msg2.message_id = 2;
    out_msg2.payload1 = 0;

#ifndef __baremetal__
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(1, &cpuset);
pthread_t current_thread = pthread_self();
pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset);
#endif

    if (*(int*)arg == 0) {
        ring1 = app1; ring2 = app2; // Only this branch is used for now, for 3 threads
    } else {
        ring1 = app3; ring2 = app3;
    }

    // Simple round robin message parser/scheduler
    for (i = 0; i < N; i++)
    {
        int received1 = 0, received2 = 0;
        int received3 = 0, received4 = 0;
        // Scan the command queue, barrier
        while (!(received1 && received2 && received3 && received4))
        {
/*#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("app spin %d %d %d %d\n", received1, received2, received3, received4);
#endif*/
          if(!received1)
          {
            if(!rte_ring_mc_dequeue(ring1, (void **)&msg1))
	    {
#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("packet from io ring 1 %d %d\n", msg1->message_id, msg1->payload1);
#endif
                received1 = -1;
            }
          }
          if(!received2)
          {
            if(!rte_ring_mc_dequeue(ring2, (void **)&msg2))
            {
                received2 = -1;
#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("packet from io ring 2 %d %d\n", msg2->message_id, msg2->payload1);
#endif
            }
	  }
          if(!received3)
          {
            if(!rte_ring_mc_dequeue(ring1, (void **)&msg3))
            {
                received3 = -1;
#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("packet from io ring 12 %d %d\n", msg3->message_id, msg3->payload1);
#endif
            }
	  }
          if(!received4)
          {
            if(!rte_ring_mc_dequeue(ring2, (void **)&msg4))
            {
                received4 = -1;
#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("packet from io ring 22 %d %d\n", msg4->message_id, msg4->payload1);
#endif
            }
          }
        }
    	        if (t1 == 0) t1 = getticks();
		else
		{
#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("next iteration %d\n", (unsigned int)(getticks() - t1));
#endif
		}
        // Send stuff back, use mp function in case
        out_msg1.payload1++;
        int sent = rte_ring_mp_enqueue(out1, &out_msg1);
        out_msg2.payload1++;
        sent     = rte_ring_mp_enqueue(out2, &out_msg2);
    }
    t2 = getticks();
#ifndef __baremetal__
    printf
#else
    kprintf
#endif
    ("%d\n", ((unsigned int)(t2 - t1))/N);

#ifndef __baremetal__
    return 0;
#else
    return ((unsigned int)(t2 - t1))/N;
#endif
}
Beispiel #3
0
// 2 pinned comms threads, processing 2out and 4in buffers.
int io_func(void *arg)
{
    struct rte_ring *ring1, *ring2;
    static struct message *out_msg1, *out_msg2;
    static struct message msg1, msg2;
#ifndef __baremetal__
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
pthread_t current_thread = pthread_self();
#endif
    msg1.payload1 = 0;
    msg2.payload1 = 0;

    if (*(int*)arg == 0) {
        msg1.message_id = 1;
        ring1 = out1;
#ifndef __baremetal__
CPU_SET(2, &cpuset);
pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset);
#endif
    } else {
        msg2.message_id = 3;
        ring1 = out2;
#ifndef __baremetal__
CPU_SET(3, &cpuset);
pthread_setaffinity_np(current_thread, sizeof(cpu_set_t), &cpuset);
#endif
    }

    // Simple round robin message sender/receiver
    while (1)
    {
        int received1 = 0, received2 = 0;
        unsigned long long t1 = getticks();
        // Try sending
        msg1.payload1++;
        int sent = rte_ring_mp_enqueue(app1, &msg1);

        if (-1 == sent)
        {// FIXME to handle the error
        }
        msg2.payload1++;
        sent = rte_ring_mp_enqueue(app2, &msg2);

        // receive output, barrier
        while (!received1)
        {
/*#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("io spin %d %d \n", received1, received2);
#endif*/
          if(!received1)
          {
            if(!rte_ring_mc_dequeue(ring1, (void **)&out_msg1))
            {
#ifdef DEBUG
#ifdef __baremetal__
kprintf
#else
printf
#endif
("packet from app ring 1 %d %d\n", out_msg1->message_id, out_msg1->payload1);
#endif
		if (out_msg1->payload1 == N)
			return 0;
                received1 = -1;
            }
          }
        }
    }

    return 0;
}