static RCCResult ConsumerWorker_run(RCCWorker *this_,RCCBoolean timedout,RCCBoolean *newRunCondition)
{
( void ) timedout;
( void ) newRunCondition;
int ncount, *b;
uint32_t len,n;
// ConsumerWorkerStaticMemory *mem = this_->memories[0];
ConsumerWorkerProperties *props = this_->properties;
int passed = 1;
#ifdef TIME_TP
double usecs;
Timespec cTime;
#endif
char* in_buffer = (char*)this_->ports[ConsumerWorker_Data_In_Port].current.data;
#ifdef TIME_IT
OCPI_TIME_EMIT_C( "Consumer Start" );
#endif
#ifdef TIME_TP
if ( mem->b_count == 0 ) {
get_timestamp( &mem->startTime );
}
#endif
len = this_->ports[ConsumerWorker_Data_In_Port].input.length;
#ifdef TESTOC
printf("OC = %d\n", this_->ports[ConsumerWorker_Data_In_Port].input.u.operation );
if ( this_->ports[ConsumerWorker_Data_In_Port].input.u.operation != props->buffersProcessed ) {
passed = 0;
printf("ERROR!! op code is not correct !!\n");
}
#endif
props->bytesProcessed += len;
if ( len == 0 ) {
#ifndef NDEBUG
printf("Error !! Got a Zero length buffer\n");
#endif
props->droppedBuffers++;
return RCC_ADVANCE;
}
len -= 4;
b = (int*)(in_buffer);
if ( *b != (int)props->buffersProcessed ) {
#ifndef NDEBUG
printf("ERROR!! Dropped a buffer, got buffer %d, expected %d\n",
*b, props->buffersProcessed );
#endif
props->droppedBuffers++;
/* resync */
props->buffersProcessed = *b;
}
ncount = 0;
for (n=4; n<len+4; n++) {
if ( (in_buffer[n] != (char)(n+props->buffersProcessed)%23) && (ncount++ < 100) ) {
#ifndef NDEBUG
printf("\nConsumer(b-> %d): Data integrity error(%d) !!, expected %d, got %d\n",
props->buffersProcessed,n, (char)(n+props->buffersProcessed)%23, in_buffer[n]);
#endif
passed = 0;
}
}
if ( passed ) {
#ifndef NDEBUG
printf("Buffer %d data integrity test passed\n", props->buffersProcessed);
#endif
}
else {
props->passfail = 0;
}
if ( props->droppedBuffers ) {
#ifndef NDEBUG
printf("ERROR!! Dropped %d buffer(s)\n", props->droppedBuffers);
#endif
}
props->buffersProcessed++;
#ifdef TIME_TP
if ( (props->buffersProcessed%50000) == 0 ) {
get_timestamp( &cTime );
usecs = elapsed_usecs ( &mem->startTime, &cTime );
printf ( "xfer n_bytes %lld %16.4f usecs/transfer %16.4f MB/s\n",
(unsigned long long)(mem->b_count * len),
( usecs / ( double ) mem->b_count ),
( ( double ) mem->b_count * ( double )len ) / usecs );
}
#endif
if ( props->transferMode == ConsumerConsume ) {
#ifdef TIME_IT
OCPI_TIME_EMIT_C( "Consumer Start Release" );
#endif
this_->container->release( &this_->ports[ConsumerWorker_Data_In_Port].current );
#ifdef TIME_IT
OCPI_TIME_EMIT_C( "Consumer End Release" );
#endif
}
else {
if ( props->takenBuffers[props->releaseBufferIndex].data ) {
this_->container->take( &this_->ports[ConsumerWorker_Data_In_Port],
&props->takenBuffers[props->releaseBufferIndex], &props->takenBuffers[props->takenBufferIndex] );
props->releaseBufferIndex = (props->releaseBufferIndex + 1)%CONSUMER_TAKE_COUNT;
}
else {
this_->container->take( &this_->ports[ConsumerWorker_Data_In_Port],
NULL, &props->takenBuffers[props->takenBufferIndex] );
}
// Take the buffers for a simulated sliding window algorithm
props->takenBufferIndex = (props->takenBufferIndex + 1)%CONSUMER_TAKE_COUNT;
}
return RCC_OK;
}
/*
* Main entry point of program. Sets up the timers, the child processes
* and reports the various times of each.
*
* @param argc number of arguments passed to this program
* @param *argv[] array of strings passed to this program, used to
* retrieve the fibonacci value to compute
*/
int main(int argc, char *argv[]) {
char *p;
long val;
pid_t child1, child2;
int status;
if (argc!=2) {
fprintf(stderr, "Proper usage is %s val\n"
"where val is the fibonacci "
"value you want to compute.\n",argv[0]);
exit(1);
}
val = strtol(argv[1],&p,0);
if (errno==ERANGE || p==argv[1]) {
fprintf(stderr,"Value to compute, %s, is invalid.\n",argv[1]);
exit(1);
}
/* enable the signal handlers */
if (signal(SIGALRM, real_alarm)==SIG_ERR) {
fprintf(stderr, "Unable to trap SIGALRM.\n");
exit(1);
}
if (signal(SIGVTALRM, virt_alarm)==SIG_ERR) {
fprintf(stderr, "Unable to trap SIGVTALRM.\n");
exit(1);
}
if (signal(SIGPROF, prof_alarm)==SIG_ERR) {
fprintf(stderr, "Unable to trap SIGPROF.\n");
exit(1);
}
/* set up one itimerval to 1 sec, 1 sec. on reset */
seed_t.it_interval.tv_sec = 1;
seed_t.it_interval.tv_usec = 0;
seed_t.it_value.tv_sec = 1;
seed_t.it_value.tv_usec = 0;
/* start the timers for the parent */
if (setitimer(ITIMER_REAL,&seed_t,NULL)!=0) {
fprintf(stderr, "Parent unable to start real timer.\n");
exit(1);
}
if (setitimer(ITIMER_VIRTUAL,&seed_t,NULL)!=0) {
fprintf(stderr, "Parent unable to start virtual timer.\n");
exit(1);
}
if (setitimer(ITIMER_PROF,&seed_t,NULL)!=0) {
fprintf(stderr, "Parent unable to start profile timer.\n");
exit(1);
}
/*
* Forked children inherit the signals but not the
* timers, therefore we only need to set the same
* timers in the child and reuse the same variables
* for tracking the various times. The variables
* are set to 0 in the child as if the parent
* already ticked off a second before being forked,
* although in this program that isn't going to
* happen.
*/
if ((child1=fork())==0) { /* child 1 */
real_secs = virt_secs = prof_secs = 0;
/* start the timers */
if (setitimer(ITIMER_REAL,&seed_t,NULL)!=0) {
fprintf(stderr, "Child 1 unable to start real timer.\n");
exit(1);
}
if (setitimer(ITIMER_VIRTUAL,&seed_t,NULL)!=0) {
fprintf(stderr, "Child 1 unable to start virtual timer.\n");
exit(1);
}
if (setitimer(ITIMER_PROF,&seed_t,NULL)!=0) {
fprintf(stderr, "Child 1 unable to start profile timer.\n");
exit(1);
}
val = fibonacci(val);
/*
* Since we are going for a snapshot of the time we can capture
* the time by turning the timer off. If we use getitimer here
* and the value falls very close to a second boundary we could
* get a misleading value if the timer resets right after
* getitimer is called, before we get a chance to report the
* seconds...
* First, we set up an itimerval to shut off timers.
*/
seed_t.it_interval.tv_sec = 0;
seed_t.it_interval.tv_usec = 0;
seed_t.it_value.tv_sec = 0;
seed_t.it_value.tv_usec = 0;
/* kill the timers, placing current countdown in 3rd param */
if (setitimer(ITIMER_REAL, &seed_t, &real_t)!=0) {
fprintf(stderr, "Child 1 unable to get real time.\n");
exit(0);
}
if (setitimer(ITIMER_VIRTUAL, &seed_t, &virt_t)!=0) {
fprintf(stderr, "Child 1 unable to get virtual time.\n");
exit(0);
}
if (setitimer(ITIMER_PROF, &seed_t, &prof_t)!=0) {
fprintf(stderr, "Child 1 unable to get profile time.\n");
exit(0);
}
printf("child 1 ans: %ld, (real) %ld sec, %ld msec\n",
val, real_secs,
elapsed_usecs(real_t.it_value.tv_sec,
real_t.it_value.tv_usec)/1000);
printf("child 1 ans: %ld, (virt) %ld sec, %ld msec\n",
val, virt_secs,
elapsed_usecs(virt_t.it_value.tv_sec,
virt_t.it_value.tv_usec)/1000);
printf("child 1 ans: %ld, (prof) %ld sec, %ld msec\n",
val, prof_secs,
elapsed_usecs(prof_t.it_value.tv_sec,
prof_t.it_value.tv_usec)/1000);
} else if ((child2=fork())==0) { /* child 2 */
real_secs = virt_secs = prof_secs = 0;
/* start the timers */
if (setitimer(ITIMER_REAL,&seed_t,NULL)!=0) {
fprintf(stderr, "Child 2 unable to start real timer.\n");
exit(1);
}
if (setitimer(ITIMER_VIRTUAL,&seed_t,NULL)!=0) {
fprintf(stderr, "Child 2 unable to start virtual timer.\n");
exit(1);
}
if (setitimer(ITIMER_PROF,&seed_t,NULL)!=0) {
fprintf(stderr, "Child 2 unable to start profile timer.\n");
exit(1);
}
val = fibonacci(val);
/* set up an itimerval to kill the timers */
seed_t.it_interval.tv_sec = 0;
seed_t.it_interval.tv_usec = 0;
seed_t.it_value.tv_sec = 0;
seed_t.it_value.tv_usec = 0;
/* kill the timers */
if (setitimer(ITIMER_REAL, &seed_t, &real_t)!=0) {
fprintf(stderr, "Child 2 unable to get real time.\n");
exit(0);
}
if (setitimer(ITIMER_VIRTUAL, &seed_t, &virt_t)!=0) {
fprintf(stderr, "Child 2 unable to get virtual time.\n");
exit(0);
}
if (setitimer(ITIMER_PROF, &seed_t, &prof_t)!=0) {
fprintf(stderr, "Child 2 unable to get profile time.\n");
exit(0);
}
printf("child 2 ans: %ld, (real) %ld sec, %ld msec\n",
val, real_secs,
elapsed_usecs(real_t.it_value.tv_sec,
real_t.it_value.tv_usec)/1000);
printf("child 2 ans: %ld, (virt) %ld sec, %ld msec\n",
val, virt_secs,
elapsed_usecs(virt_t.it_value.tv_sec,
virt_t.it_value.tv_usec)/1000);
printf("child 2 ans: %ld, (prof) %ld sec, %ld msec\n",
val, prof_secs,
elapsed_usecs(prof_t.it_value.tv_sec,
prof_t.it_value.tv_usec)/1000);
} else {
/* parent */
val = fibonacci(val);
waitpid(child1, &status, 0);
waitpid(child2, &status, 0);
/* set up an itimerval to kill the timers */
seed_t.it_interval.tv_sec = 0;
seed_t.it_interval.tv_usec = 0;
seed_t.it_value.tv_sec = 0;
seed_t.it_value.tv_usec = 0;
/* and kill the timers */
if (setitimer(ITIMER_REAL, &seed_t, &real_t)!=0) {
fprintf(stderr, "Parent unable to get real time.\n");
exit(0);
}
if (setitimer(ITIMER_VIRTUAL, &seed_t, &virt_t)!=0) {
fprintf(stderr, "Parent unable to get virtual time.\n");
exit(0);
}
if (setitimer(ITIMER_PROF, &seed_t, &prof_t)!=0) {
fprintf(stderr, "Parent unable to get profile time.\n");
exit(0);
}
printf("parent ans: %ld, (real) %ld sec, %ld msec\n",
val, real_secs,
elapsed_usecs(real_t.it_value.tv_sec,
real_t.it_value.tv_usec)/1000);
printf("parent ans: %ld, (virt) %ld sec, %ld msec\n",
val, virt_secs,
elapsed_usecs(virt_t.it_value.tv_sec,
virt_t.it_value.tv_usec)/1000);
printf("parent ans: %ld, (prof) %ld sec, %ld msec\n",
val, prof_secs,
elapsed_usecs(prof_t.it_value.tv_sec,
prof_t.it_value.tv_usec)/1000);
}
}
static RCCResult ConsumerWorker_run(RCCWorker *this_,RCCBoolean timedout,RCCBoolean *newRunCondition)
{
( void ) timedout;
( void ) newRunCondition;
uint32_t ncount, *b;
size_t len,n;
ConsumerWorkerStaticMemory *mem = this_->memories[0];
ConsumerWorkerProperties *props = this_->properties;
unsigned passed = 1;
// printf("\n\n\n\n\ IN ConsumerWorker_run\n\n\n\n");
#ifdef TIME_TP
double usecs;
Timespec cTime;
#endif
char* in_buffer = (char*)this_->ports[ConsumerWorker_Data_In_Port].current.data;
/* printf("Cos buffer = %lld\n", in_buffer );
printf("In maxlen = %d\n", this_->ports[ConsumerWorker_Data_In_Port].current.maxLength );
*/
OCPI_TIME_EMIT_C( "Worker Consumer Start" );
#ifdef TIME_TP
if ( mem->b_count == 0 ) {
get_timestamp( &mem->startTime );
}
#endif
len = this_->ports[ConsumerWorker_Data_In_Port].input.length;
/*
printf("Consumer: got a buffer(%d) of data, len = %d first words = %d,%d \n",
mem->b_count, len, (int)in_buffer[0],(int)in_buffer[4] );
*/
/* printf("Con: Actual len = %d, max = %d\n", len, this_->ports[ConsumerWorker_Data_In_Port].maxLength );
*/
if ( len == 0 ) {
printf("Error !! Got a Zero length buffer\n");
return RCC_ADVANCE;
}
len -= 4;
#define CHECK_DATA
#ifdef CHECK_DATA
b = (unsigned*)(in_buffer);
#define RESYNC
#ifdef RESYNC
// sleep( 2 );
if ( *b != mem->b_count ) {
printf("ERROR!! Dropped a buffer, got buffer %d, expected %d\n",
*b, mem->b_count );
dropped_b++;
/* resync */
mem->b_count = *b;
}
#endif
ncount = 0;
for (n=4; n<len+4; n++) {
if ( (in_buffer[n] != (char)(n+mem->b_count)%23) && (ncount++ < 100000) ) {
printf("Consumer(%u, %zu, b-> %d): Data integrity error(%zd) !!, expected %d, got %d\n",
props->startIndex, len, mem->b_count,n, (char)(n+mem->b_count)%23, in_buffer[n]);
passed = 0;
}
}
props->startIndex++;
if ( passed ) {
if ( (mem->b_count%5000) == 0 )
printf("Buffer %d data integrity test passed\n", mem->b_count);
}
#endif
if ( ((report_er++)%10000) == 0 ) {
if ( dropped_b ) {
printf("ERROR!! Dropped %d buffer(s)\n", dropped_b);
}
}
mem->b_count++;
#ifdef TIME_TP
if ( (mem->b_count%50000) == 0 ) {
get_timestamp( &cTime );
usecs = elapsed_usecs ( &mem->startTime, &cTime );
printf ( "xfer n_bytes %lld %16.4f usecs/transfer %16.4f MB/s\n",
(unsigned long long)(mem->b_count * len),
( usecs / ( double ) mem->b_count ),
( ( double ) mem->b_count * ( double )len ) / usecs );
}
#endif
OCPI_TIME_EMIT_C("Consumer Start Release");
// this_->container.release( &this_->ports[ConsumerWorker_Data_In_Port].current );
OCPI_TIME_EMIT_C("Consumer End Release");
return RCC_ADVANCE;
}
static RCCResult UTGConsumerWorker_run(RCCWorker *this_,RCCBoolean timedout,RCCBoolean *newRunCondition)
{
( void ) timedout;
( void ) newRunCondition;
uint32_t ncount, *b;
size_t len,n;
// UTGConsumerWorkerStaticMemory *mem = this_->memories[0];
UTGConsumerWorkerProperties *props = this_->properties;
int passed = 1;
#ifdef TIME_TP
double usecs;
Timespec cTime;
#endif
char* in_buffer = (char*)this_->ports[UTGConsumerWorker_Data_In_Port0].current.data;
OCPI_TIME_EMIT_C( "Consumer Start" );
#ifdef TIME_TP
if ( mem->b_count == 0 ) {
get_timestamp( &mem->startTime );
}
#endif
len = this_->ports[UTGConsumerWorker_Data_In_Port0].input.length;
if ( len == 0 ) {
#ifndef NDEBUG
printf("Error !! Got a Zero length buffer\n");
#endif
props->droppedBuffers++;
return RCC_ADVANCE;
}
len -= 4;
b = (uint32_t*)(in_buffer);
if ( *b != props->buffersProcessed ) {
#ifndef NDEBUG
printf("ERROR!! Dropped a buffer, got buffer %d, expected %d\n",
*b, props->buffersProcessed );
#endif
props->droppedBuffers++;
/* resync */
props->buffersProcessed = *b;
}
ncount = 0;
for (n=4; n<len+4; n++) {
if ( (in_buffer[n] != (char)(n+props->buffersProcessed)%23) && (ncount++ < 100000) ) {
printf("UTGConsumer(b-> %d): Data integrity error(%zu) !!, expected %d, got %d\n",
props->buffersProcessed,n, (char)(n+props->buffersProcessed)%23, in_buffer[n]);
passed = 0;
}
}
if ( passed ) {
#ifndef NDEBUG
printf("Buffer %d data integrity test passed\n", props->buffersProcessed);
#endif
}
else {
props->passfail = 0;
}
if ( props->droppedBuffers ) {
#ifndef NDEBUG
printf("ERROR!! Dropped %d buffer(s)\n", props->droppedBuffers);
#endif
}
props->buffersProcessed++;
#ifdef TIME_TP
if ( (props->buffersProcessed%50000) == 0 ) {
get_timestamp( &cTime );
usecs = elapsed_usecs ( &mem->startTime, &cTime );
printf ( "xfer n_bytes %lld %16.4f usecs/transfer %16.4f MB/s\n",
(unsigned long long)(mem->b_count * len),
( usecs / ( double ) mem->b_count ),
( ( double ) mem->b_count * ( double )len ) / usecs );
}
#endif
OCPI_TIME_EMIT_C( "Consumer Start Release" );
this_->container.advance( &this_->ports[UTGConsumerWorker_Data_In_Port0], 0 );
OCPI_TIME_EMIT_C( "Consumer End Release" );
return RCC_OK;
}
