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