Niklaus Giger wrote:
Am Donnerstag, 16. März 2006 14:53 schrieb Philippe Gerum:

I'm currently working on extending the VxWorks skin so that it is going to
be callable from user-space directly, without needing the UVM environment.
This will also make its functional extension easier in the future,
especially with respect to bsp-related services.

While I'm at it, I'd also like to polish a few corner cases, so that we
have the closest possible emulation of the original RTOS services.
Unfortunately, the VxWorks documentation is rather terse on some
behavioural aspects, and I have no VxWorks target at hand to test and check
them. Therefore, I definitely need help from people reading this list who
also happen to be VxWorks users, for providing the following missing bits
of information:

- How does taskName() behave when passed a null task id? Is it equivalent
to specifying taskIdSelf(), or does it lead to a NULL error return?

It behaves like taskName(taskIdSelf()). see vx_skin.c.
Output was
-> vx_skin_test_1

myTaskName is 0xf40500 tShell
value = 31 = 0x1f

- How does msgQSend() behave when passed an invalid message priority, i.e.

It doesn't care (see pMsgQue.cpp).
Output was
-> test_init
task1 started
endTime   1834779057842028544
startTime 1832156649595338752
diff      2622408246689792 2622408246689 microSecs per run 26224082466
task1 nrQuestions 100 nrAnswers 100 nrSwitches 100
value = 0 = 0x0

- How does taskInit() behave when passed an invalid set of task options?
Are the invalid flags ignored, or does the routine return an error status?

All invalid bits arg ignored, no error returned. see vx_skin.c.
Output was:
-> vx_skin_test_2

taskInit status is 0

taskOptionGet returns 0 is -1
value = 31 = 0x1f
If you happen to have a VxWorks target at hand regardless of the
architecture, and are willing to help improving the behavioural correctness
of the VxWorks skin, then your input will be most welcome.

Hope this help. Please feel free to ask for more tests.

Great, I will fix the skin using this information. Thanks.

What about a vxWorks test suite? I would like to contribute to it.

You would be most welcome doing so.

 (At least
as soon as I have a working Xenomai environment again.)
 And I would be much
more confident to recommend Xenomai if it had test suites for its various skins. I hope to be able to make some contributions once I get approval to put a few of our internal test routines available under a free license.

The most useful way to help would be to develop the testsuite for validating the recent evolution of the VxWorks skin, which now has a fully native call interface from user-space, i.e. it does not need the UVM layer anymore, albeit the former way will still be available. Let me know whenever you want to help this way, so that we could synchronize, for a better efficiency in fixing the potential issues.

Best regards

Niklaus Giger


 * Copyright (C) 2005 Niklaus Giger <[EMAIL PROTECTED]>.
 * vxWorks is a registered trademark of Wind River Systems, Inc.
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 * Hopefully this program lets you compare the relative performance of
 * taskSwitches and message passing between an original vxWorks image and
 * a xenomai based port.

#ifdef XENOMAI
#include <xeno_config.h>
#include <vxworks/vxworks.h>
#include <xenomai/timer.h>
#include <vxWorks.h>
#include <stdio.h>
#include <msgQLib.h>
#include <taskLib.h>
#include <sysLib.h>
#include <arch/ppc/vxPpcLib.h>
#define xnprintf printf
#define taskExit exit
#define RTIME UINT64
RTIME rt_timer_tsc();

RTIME rt_timer_tsc()
   UINT32 low, high;
   UINT64 res;
   vxTimeBaseGet (&low, &high);
   res = (UINT64) low + ((UINT64) high)<<32;
   return res;

#define TASK_PRI    115
#define STACK_SIZE  8192

MSG_Q_ID question_qid, answer_qid;

int producer_tid,
static int nrQuestions;
static int nrAnswers;
static int nrSwitches;
void reportState(const char *where)
  xnprintf("%s nrQuestions %d nrAnswers %d nrSwitches %d\n",
           where, nrQuestions, nrAnswers, nrSwitches);

#define NR_RUNS 100
void task1 (int a0, int a1, int a2, int a3, int a4,
        int a5, int a6, int a7, int a8, int a9)
    int msg;
    int sz;
    int j;
    RTIME diff, startTime, endTime;
    xnprintf("task1 started\n");
    startTime = rt_timer_tsc();
    for (j=0; j<NR_RUNS; j++)
        // taskDelay(sysClkRateGet()/2);
        // startTime = rt_timer_tsc();
          msg = nrQuestions;
                   (char *)&msg,sizeof(msg),WAIT_FOREVER,MSG_PRI_NORMAL);
          if ( (sz = msgQReceive(answer_qid,
                (char *)&msg,sizeof(msg),WAIT_FOREVER)) == ERROR)
    endTime = rt_timer_tsc();
    diff = endTime - startTime;
    xnprintf("endTime   %16llu\n", endTime);
    xnprintf("startTime %16llu\n", startTime);
xnprintf("diff %16llu %llu microSecs per run %llu\n", diff, diff / 1000, diff / (1000 * NR_RUNS));

void task2 (int a0, int a1, int a2, int a3, int a4,
                    int a5, int a6, int a7, int a8, int a9)
  int msg;
  int sz;
  int j;
  int status;
  // for (j=0;j<5;j++)
  while (1)
      if ( (sz = msgQReceive(question_qid,
            (char*)&msg,sizeof(msg),WAIT_FOREVER)) == ERROR)
      msg = nrAnswers;
      status = msgQSend(answer_qid,
               (char *)&msg,sizeof(msg),WAIT_FOREVER,MSG_PRI_NORMAL | 0xffff);
      if(status != OK)
         printf("\n msgQSend failed with status %d", status);

const int MeasurementInSeconds = 5;
int test_init(void)
        question_qid = msgQCreate(16,sizeof(int),MSG_Q_FIFO);
        answer_qid   = msgQCreate(16,sizeof(int),MSG_Q_FIFO);

        consumer_tid = taskSpawn("tTask1",

        producer_tid = taskSpawn("tTask2",
        return 0;

#ifdef XENOMAI
int root_thread_init (void)

{       test_tid = taskSpawn("tTask1",

        // test_init();
    return 0;

void root_thread_exit (void)



#include <vxWorks.h>
#include <stdio.h>
#include "taskLib.h"

void vx_skin_test_1()
   char *myTaskName = taskName(0);
printf("\nmyTaskName is %p %s\n",myTaskName, myTaskName); }

void vx_skin_test_2()
   char                   *stack_base;
   char                   *task_name=0;
   WIND_TCB               *tcb_base;
   STATUS                  status;
   int                     stack_size = 2048;
   int                     priority = 150;
   int                     options = -1;
   FUNCPTR                 entry_point = (FUNCPTR) vx_skin_test_1;
   tcb_base = (WIND_TCB *) malloc ( sizeof (WIND_TCB) );
   stack_base = malloc (stack_size);
   status = taskInit (tcb_base,                       /* TaskControlBlock */
                      task_name,                      /* Task-Name */
                      priority,                       /* Prioritaet der neuen 
Task */
                      options,                        /* Task-Optionen */
                      stack_base + stack_size,        /* Stack-Start */
                      stack_size,                     /* Stack-Groesse */
                      entry_point,                    /* Task-Funktion */
                      1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
printf("\ntaskInit status is %d\n", status); options = 0xaffeaffe;
   status = taskOptionsGet((int)tcb_base, &options);
printf("\ntaskOptionGet returns %d is %d\n", status, options);



Xenomai-core mailing list

Reply via email to