Mity CPU Platforms » MityDSP-L138 (ARM9 Based Platforms)

I am having some trouble with a data acquisition system.

Using MDK_2012-08-10

There are two tasks (among others) that perform the data acquisition. The data is streaming in from the mcBSP and is loaded into a common buffer by the DSP.
Rough outline of code:

gSig_record is setup to generate a periodic signal every 10 msec.

void * taskOne(void *pArg)
{
    while(!quit)
    {
    sigwait(&gSig_record, &sig);            // recording timer event

        clock_gettime(1, &start);
        times[idxMark] = start.tv_nsec - last;          // measure interval of gSig_record event
        last = start.tv_nsec;

       // ....code omitted.... 
       // Collect 32Kbytes of data into global buffer

    // send message to taskTwo
    if (gfdThis > 0)
        mq_send(gfdThis, (char *) msg, msgLen, PRIORITY_NORMAL);

        clock_gettime(1, &end);
        samples[idxMark] = n;
        runTime[idxMark++] = end.tv_nsec - start.tv_nsec;   // measure run time of this task
        idxMark &= 31;

    } // endwhile: !quit

    return NULL;
} // end: taskOne()

void taskTwo()
{
    while(!quit)
    {
        // wait for instruction from taskOne
        ret = mq_receive(gfdThis, (char *)msg, sizeof(msg), NULL);

        clock_gettime(1, &start);
        timesRec[idxRec] = start.tv_nsec - last;          // measure the interval between messages
        last = start.tv_nsec;

        // write to SATA
        fwrite(globalBuffer, 1, 32 * 1024, file); 

        // measure how long that took
        clock_gettime(1, &end);
        runTimeRec[idxRec++] = end.tv_nsec - start.tv_nsec;
        idxRec &= 31;

    }

}

taskOne has a priority of 99.
taskTwo has a priority of 98.
taskOne causes taskTwo to run. So, they run sequentially.

taskOne runs in around 1 msec
taskTwo runs in around 5 msec

This works fine for a while, then occasionally (on the order of every 10ish seconds), taskOne gets held off. I calculate the interval at which taskOne runs, and it's 10 msec. But occasionally I see an interval of >30 msec.

With the priority of these tasks being so high, I am guessing it's the kernel that's holding it off. Could this be due to the buffering in fwrite? Should I call fflush() after each fwrite()? or use write() instead?

Which is more efficient for ongoing real time writes to the SATA, write() or fwrite()? I am writing block data 32Kbytes at a time. Does fwrite() involve an extra copy of data? Can the kernal accessing the SATA hold off my real time periodic tasks?

Is there a way to find out what the kernel was doing just before this long interval occurred?

Any insights would be helpful.
Thanks,
Mary