/* * Given a process id, iterate through all open files of that process * looking for a match to the target file, and then determine how it * is being used by that process. This is quite different in QNX to * UNIX, as chroot and chdir do not hold open a reference to the file. * The iteration process attempts to dup each file descriptor into * this process, so it can then be queried; attempt to skip things which * aren't files (heuristic guess) and use a timeout as self-defence. */ int howused(pid_t pid, match_t *match) { struct _server_info sinfo; struct _fdinfo finfo; struct stat st; io_dup_t msg; uint64_t to; int fd, coid, usage; usage = 0; for (fd = 0; (fd = ConnectServerInfo(pid, fd, &sinfo)) != -1; ++fd) { if ((pid != sinfo.pid || !(fd & _NTO_SIDE_CHANNEL)) && (coid = ConnectAttach(sinfo.nd, sinfo.pid, sinfo.chid, 0, _NTO_COF_CLOEXEC)) != -1) { msg.i.type = _IO_DUP; msg.i.combine_len = sizeof(msg.i); msg.i.info.nd = netmgr_remote_nd(sinfo.nd, ND_LOCAL_NODE); msg.i.info.pid = pid; msg.i.info.chid = sinfo.chid; msg.i.info.scoid = sinfo.scoid; msg.i.info.coid = fd; TimerTimeout(CLOCK_MONOTONIC, _NTO_TIMEOUT_SEND | _NTO_TIMEOUT_REPLY, NULL, (to = 1000000000LL, &to), NULL); if (MsgSend(coid, &msg.i, sizeof(msg.i), NULL, 0) == -1) { ConnectDetach(coid); } else { if (fstat(coid, &st) != -1 && ismatch(match, st.st_dev, st.st_ino)) { if (iofdinfo(coid, 0, &finfo, NULL, 0) == -1 || sinfo.pid != PATHMGR_PID || finfo.mode != 0) usage |= USED_OPEN; } close(coid); } } } return(usage); }
int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout) { int rc; if(timeout) { // Passing a NULL for event is the same as notify = SIGEV_UNBLOCK uint64_t t = timespec2nsec(timeout); //POSIX 3.3.8.4 error checking if(!TIMESPEC_VALID(timeout)) { errno = EINVAL; return -1; } // Passing a NULL for event is the same as notify = SIGEV_UNBLOCK if(TimerTimeout(CLOCK_MONOTONIC, _NTO_TIMEOUT_SIGWAITINFO, 0, &t, 0) == -1) { return -1; } } // POSIX P1003.1-1996 Section 3.3.8.2 line 1995 says we have to do this if (((rc = SignalWaitinfo(set, info)) == -1) && (errno == ETIMEDOUT)) { errno = EAGAIN; } return rc; }
int clsThread::WaitForEvent(uint64_t nsec) { uint64_t nWait = nsec; TimerTimeout(CLOCK_REALTIME, _NTO_TIMEOUT_CONDVAR | _NTO_TIMEOUT_MUTEX, NULL, &nWait, NULL); int nReturn = pthread_cond_wait(&m_condThread, &m_mtxThread); return nReturn; }
int mq_timedsend_woption(mqd_t mq, const char *buff, size_t nbytes, unsigned msgprio, const struct timespec *timeout, clockid_t clock_choice) { uint64_t t = timespec2nsec(timeout); if(!TIMESPEC_VALID(timeout)) { errno = EINVAL; return -1; } if(TimerTimeout(clock_choice, TIMER_ABSTIME | _NTO_TIMEOUT_SEND | _NTO_TIMEOUT_REPLY, 0, &t, 0) == -1) { return -1; } return (_writex(mq, buff, nbytes, _IO_XTYPE_MQUEUE | (msgprio << 16), 0, 0) == -1) ? -1 : 0; }
int timer_timeout(clockid_t id, int flags, const struct sigevent *notify, const struct timespec *ntime, struct timespec *otime) { int ret; uint64_t o, n; if(ntime) { n = timespec2nsec(ntime); } ret = TimerTimeout(id, flags, notify, ntime ? &n : 0, otime ? &o : 0); if(otime) { nsec2timespec(otime, o); } return ret; }
int omap3530_wait(omap3530_spi_t *dev, int len) { struct _pulse pulse; int rx_idx = dev->sdma_rx_chid; while (1) { if (len) { uint64_t to = dev->dtime * 1000 * 50; /* 50 times for time out */ to *= len ; TimerTimeout(CLOCK_REALTIME, _NTO_TIMEOUT_RECEIVE, NULL, &to, NULL); } if (MsgReceivePulse(dev->chid, &pulse, sizeof(pulse), NULL) == -1){ fprintf(stderr, "omap3530_wait: errono %s(%d), status %x\n", strerror(errno), errno, in32(dev->vbase+ OMAP3530_MCSPI_IRQ_STATUS_OFFSET)); return -1; } switch (pulse.code) { case OMAP3530_SPI_EVENT: return 0; case OMAP3530_SDMA_EVENT: { /* Unmask the Interrupt */ InterruptUnmask(dev->irq_sdma+rx_idx, dev->iid_sdma); if ((dev->dma4->channel[rx_idx].csr & DMA4_CSR_FRAME)){ /* clear interrupt status line 0 for transmit channel */ dev->dma4->channel[rx_idx].csr |= DMA4_CSR_FRAME; return 0; }else { continue; } } } } return 0; }
int main( int argc, char *argv[] ) { int arg; int use_tracker = FALSE; int use_isense = FALSE; int use_udp = FALSE; int orientation_only = FALSE; IsenseDataPacket iSenseData; UDPDataPacket udpData; int data_available = NO; for ( arg = 1; arg < argc; arg++ ) { if ( !strcmp( argv[arg], "-full" ) ) { width = 640; height = 480; border = false; fullscreen = true; stereo = false; } else if ( !strcmp( argv[arg], "-hmd" ) ) { width = 1280; height = 480; border = false; fullscreen = true; stereo = true; // HMDScreen( HMD_STEREO ); } else if ( !strcmp( argv[arg], "-svga" ) ) { width = 2048; height = 768; border = false; fullscreen = true; stereo = true; HMDScreen( HMD_STEREO ); } else if ( !strcmp( argv[arg], "-nVisL" ) ) { fprintf( stderr, "LowRes nVis\n" ); width = 2048; height = 768; border = false; fullscreen = true; stereo = true; // HMDScreen( HMD_STEREO ); } else if ( !strcmp( argv[arg], "-nVis" ) ) { width = 2560; height = 1024; border = false; fullscreen = true; stereo = true; // HMDScreen( HMD_STEREO ); } else if ( !strcmp( argv[arg], "-noborder" ) ) border = FALSE; else if ( !strcmp( argv[arg], "-tracker" ) ) use_tracker = TRUE; else if ( !strcmp( argv[arg], "-isense" ) ) use_isense = TRUE; else if ( !strcmp( argv[arg], "-udp" ) ) use_udp = TRUE; else if ( !strcmp( argv[arg], "-ori" ) ) orientation_only = TRUE; else if ( !strcmp( argv[arg], "-sensor" ) ) { arg++; if ( arg < argc ) sscanf( argv[arg], "%d", &viewpoint_sensor ); fprintf( stderr, "Using sensor %d.\n", viewpoint_sensor ); } else closure_record = argv[arg]; } fprintf( stderr, "Closure record: %s\n", closure_record ); /* Start up optical tracker. */ if ( use_tracker ) { SetupTracker(); SensorSetHysteresis( 1, 2.0, 0.5 ); // mm and degrees /* * The simulated tracker goes through 7 phases. * The first is stationary. * The next three are translation movements along X,Y and Z, respectively. * The last three are rotations around Z, Y and X, respectively. * The following sets the amplitude of each phase. * This call will have no effect on real tracker movements. */ SimulateSetMovement( viewpoint_sensor, sim_translation, sim_rotation ); /* Shift the nominal viewpoint up, then tilt the view back down to look at the target. */ viewpoint_position[Y] = nominal_head_height; SimulateSetLocation( viewpoint_sensor, viewpoint_position ); viewpoint_orientation[Y][Y] = viewpoint_orientation[Z][Z] = cos( radians( nominal_head_tilt ) ); viewpoint_orientation[Y][Z] = sin( radians( nominal_head_tilt ) ) ; viewpoint_orientation[Z][Y] = - viewpoint_orientation[Y][Z]; SimulateSetOrientation( viewpoint_sensor, viewpoint_orientation ); SimulateSetLocation( object_sensor, object_position ); SimulateSetMovement( object_sensor, sim_translation, sim_rotation ); } if ( use_isense || use_udp ) { if ( UDPTrackerInitClient( &trkr, NULL, DEFAULT_PORT ) ) { MessageBox( NULL, "Error opening socket.", "Isense UDP", MB_OK ); use_isense = NO; } } /* * Define a viewing projection with: * 45° vertical field-of-view - horizontal fov will be determined by window aspect ratio. * 60 mm inter-pupilary distance - the units don't matter to OpenGL, but all the dimensions * that I give for the model room here are in mm. * 100.0 to 10000.0 depth clipping planes - making this smaller would improve the depth resolution. */ viewpoint = new Viewpoint( 6.0, 45.0, 10.0, 10000.0); int x = 100, y = 100; /* * Create window. */ window = new OpenGLWindow(); window->Border = border; // Remove borders for an HMD display. window->FullScreen = fullscreen; if ( window->Create( NULL, argv[0], 0, 0, width, height ) ) { /* * Create sets the new window to be the active window. * Setup the lights and materials for that window. */ glDefaultLighting(); glDefaultMaterial(); // wall_texture->Define(); } window->Activate(); window->SetKeyboardCallback( keyboard_callback ); // Shade model glEnable(GL_TEXTURE_2D); // Enable Texture Mapping ( NEW ) glEnable(GL_LIGHTING); glShadeModel(GL_SMOOTH); // Enable Smooth Shading glClearDepth(1.0f); // Depth Buffer Setup glEnable(GL_DEPTH_TEST); // Enables Depth Testing glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations create_objects(); TimerSet( &frame_timer, 10.0 ); frame_counter = 0; for ( double angle = 0.0; true; angle += 5.0 ) { if ( TimerTimeout( &frame_timer )) { fprintf( stderr, "Frame rate: %f\n", (double) frame_counter / TimerElapsedTime( &frame_timer ) ); if ( use_isense ) { UDPTrackerGetIsenseData( &trkr, &iSenseData ); printf("Isense Quarternion %7.3f %7.3f %7.3f %7.3f %.3f\n", iSenseData.Station[0].orientation[0], iSenseData.Station[0].orientation[1], iSenseData.Station[0].orientation[2], iSenseData.Station[0].orientation[3], iSenseData.Station[0].timestamp ); } TimerStart( &frame_timer ); frame_counter = 0; } if ( use_tracker ) { data_available = !GetSensorPositionOrientation( viewpoint_sensor, YES, viewpoint_position, viewpoint_orientation ); if ( data_available ) { if ( !orientation_only ) viewpoint->SetPosition( viewpoint_position ); viewpoint->SetOrientation( viewpoint_orientation ); } } else if ( use_isense ) { data_available = !( UDPTrackerGetIsenseData( &trkr, &iSenseData )); if ( data_available ) { isense_to_matrix( iSenseData.Station[0].orientation, viewpoint_orientation ); isense_to_vector( iSenseData.Station[0].position, viewpoint_position ); scale_vector( 10.0, viewpoint_position, viewpoint_position ); if ( !orientation_only ) viewpoint->SetPosition( viewpoint_position ); viewpoint->SetOrientation( viewpoint_orientation ); } } else if ( use_udp ) { data_available = !( UDPTrackerGetData( &trkr, &udpData )); if ( data_available ) { quaternion_to_matrix( udpData.Station[0].orientation, viewpoint_orientation ); copy_vector( udpData.Station[0].position, viewpoint_position ); scale_vector( 10.0, viewpoint_position, viewpoint_position ); if ( !orientation_only ) viewpoint->SetPosition( viewpoint_position ); viewpoint->SetOrientation( viewpoint_orientation ); } } else { data_available = data_available; } if ( use_tracker ) { data_available = !GetSensorPositionOrientation( object_sensor, YES, object_position, object_orientation ); object->SetPosition( object_position ); object->SetOrientation( object_orientation ); } else if ( use_isense && data_available ) { isense_to_matrix( iSenseData.Station[1].orientation, object_orientation ); isense_to_vector( iSenseData.Station[1].position, object_position ); scale_vector( 10.0, object_position, object_position ); object->SetOrientation( object_orientation ); if ( !orientation_only ) object->SetPosition( object_position ); } else { object->SetOrientation( angle, j_vector ); object->SetPosition( object_position ); } window->Clear(); if ( stereo ) { viewpoint->Apply( window, LEFT_EYE ); render(); viewpoint->Apply( window, RIGHT_EYE ); render(); } else { viewpoint->Apply( window, CYCLOPS ); render(); } window->Swap(); if ( ! window->RunOnce() ) break; frame_counter++; } window->Destroy(); if ( use_tracker ) KillTracker(); RevertScreen(); return( 0 ); }
void io (const char *what) { static int first_time = 1; long clock_timeout = 0, timer_timeout = 0, real_timeout = 0; static struct timeval my_now, my_timer, *time_ptr = &my_timer; int hold_over, rc; fd_set rd, wd; get_time(&my_now); now = my_now.tv_sec; /* CHECK FOR CPU SAVER MODE */ if (!cpu_saver && get_int_var(CPU_SAVER_AFTER_VAR)) if (now - idle_time > get_int_var(CPU_SAVER_AFTER_VAR) * 60) cpu_saver_on(0, NULL); rd = readables; wd = writables; FD_ZERO(&wd); FD_ZERO(&rd); set_screens(&rd, &wd); set_server_bits(&rd, &wd); set_process_bits(&rd); set_socket_read(&rd, &wd); icmp_sockets(&rd, &wd); #if defined(WANT_THREAD) #ifdef WANT_NSLOOKUP set_dns_output_fd(&rd); #endif #ifdef WANT_PTEST set_ptest_output_fd(&rd); #endif #ifdef WANT_MP3PLAYER set_mp3_output_fd(&rd); #endif # if defined(GTK) if (tgtk_okay()) tgtk_set_output_fd(&rd); # endif #endif clock_timeout = (timeout_select - (my_now.tv_sec % timeout_select)) * 1000; if (cpu_saver && get_int_var(CPU_SAVER_EVERY_VAR)) clock_timeout += (get_int_var(CPU_SAVER_EVERY_VAR) - 1) * 60000; timer_timeout = TimerTimeout(); if ((hold_over = unhold_windows())) real_timeout = 0; else if (timer_timeout <= clock_timeout) real_timeout = timer_timeout; else real_timeout = clock_timeout; if (real_timeout == -1) time_ptr = NULL; else { time_ptr->tv_sec = real_timeout / 1000; time_ptr->tv_usec = ((real_timeout % 1000) * 1000); } /* GO AHEAD AND WAIT FOR SOME DATA TO COME IN */ switch ((rc = new_select(&rd, &wd, time_ptr))) { case 0: break; case -1: { /* if we just got a sigint */ first_time = 0; if (cntl_c_hit) edit_char('\003'); else if (errno && errno != EINTR) { int ii = 0; fd_set rd1, wd1; char ii_buff_r[500]; char ii_buff_w[500]; int ii_r[FD_SETSIZE]; int ii_w[FD_SETSIZE]; yell("Select failed with [%d:%s]", errno, strerror(errno)); /* Reseed fd_sets so we can dig further */ yell("Packing fd_sets... Dump of fd's set in fd_set"); ii_buff_r[0] = '\0'; ii_buff_w[0] = '\0'; for (ii = 0; ii < FD_SETSIZE; ii++) { ii_r[ii] = 0; ii_w[ii] = 0; } FD_ZERO(&wd1); FD_ZERO(&rd1); set_screens(&rd1, &wd1); set_server_bits(&rd1, &wd1); set_process_bits(&rd1); set_socket_read(&rd1, &wd1); icmp_sockets(&rd1, &wd1); #if defined(WANT_THREAD) #ifdef WANT_NSLOOKUP set_dns_output_fd(&rd1); #endif #ifdef WANT_PTEST set_ptest_output_fd(&rd1); #endif #ifdef WANT_MP3PLAYER set_mp3_output_fd(&rd1); #endif # if defined(GTK) if (tgtk_okay()) tgtk_set_output_fd(&rd1); # endif #endif for (ii = 0; ii <= global_max_fd; ii++) { fd_set rblah, wblah; memcpy(&rblah, &rd1, sizeof(fd_set)); FD_SET(ii, &rblah); if (memcmp(&rblah, &rd1, sizeof(fd_set)) == 0) { char blahblah[20]; sprintf(blahblah, "%d ", ii); strcat(ii_buff_r, blahblah); ii_r[ii] = 1; } memcpy(&wblah, &wd1, sizeof(fd_set)); FD_SET(ii, &wblah); if (memcmp(&wblah, &wd1, sizeof(fd_set)) == 0) { char blahblah[20]; yell("blah"); sprintf(blahblah, "%d ", ii); strcat(ii_buff_w, blahblah); ii_w[ii] = 1; } } yell("Read fd's in set: %s", (ii_buff_r[0] == '\0') ? "<NONE>" : ii_buff_r); for (ii = 0; ii <= global_max_fd; ii++) { if (ii_r[ii] == 1) { struct stat st; if (fstat(ii, &st) == -1) { yell("READ FD %d is causing the select failure!", ii); } else { if (S_ISSOCK(st.st_mode)) yell("READ FD %d is a socket!", ii); else if (S_ISREG(st.st_mode)) yell("READ FD %d is a regular file!", ii); else if (S_ISFIFO(st.st_mode)) yell("READ FD %d is a FIFO!", ii); else ; } } } yell("Write fd's in set: %s", (ii_buff_w[0] == '\0') ? "<NONE>" : ii_buff_w); for (ii = 0; ii <= global_max_fd; ii++) { if (ii_w[ii] == 1) { struct stat st; if (fstat(ii, &st) == -1) { yell("WRITE FD %d is causing the select failure!", ii); } else { if (S_ISSOCK(st.st_mode)) yell("WRITE FD %d is a socket!", ii); else if (S_ISREG(st.st_mode)) yell("WRITE FD %d is a regular file!", ii); else if (S_ISFIFO(st.st_mode)) yell("WRITE FD %d is a FIFO!", ii); else ; } } } sleep(10); } else { #if 0 yell("errno 0 rc = -1, maybe it'll go away"); sleep(10); #endif } break; } /* we got something on one of the descriptors */ default: { cntl_c_hit = 0; now = time(NULL); make_window_current(NULL); do_screens(&rd); check_icmpresult(&rd, &wd); #if defined(WANT_THREAD) #ifdef WANT_NSLOOKUP dns_check(&rd); #endif #ifdef WANT_PTEST ptest_check(&rd); #endif #ifdef WANT_MP3PLAYER mp3_check(&rd); #endif # if defined(GTK) if (tgtk_okay()) tgtk_check(&rd); # endif #endif do_server(&rd, &wd); do_processes(&rd); scan_sockets(&rd, &wd); clean_sockets(); break; } } now = time(NULL); ExecuteTimers(); get_child_exit(-1); if (update_refresh) { update_refresh = 0; refresh_screen(0, NULL); } if (!hold_over) cursor_to_input(); if (update_clock(RESET_TIME)) { if (get_int_var(CLOCK_VAR)) { update_all_status(current_window, NULL, 0); cursor_to_input(); } clean_queue(get_int_var(TRANSFER_TIMEOUT_VAR)); /* timeout if send time is greater than 5 minutes */ } /* (set in term.c) -- we should redraw the screen here */ if (need_redraw) refresh_screen(0, NULL); #ifdef WANT_THREAD if (scan_done) scan_is_done(); #endif alloca(0); return; }
int _waitfor( __const char *path, int delay_ms, int poll_ms, int (*checkfunc)(__const char *, void *), void *handle ) { int notify_id = -1; struct sigevent event; int chid = -1, coid = -1; struct _pulse pulse; int ret_val = -1; uint64_t polltimeout = 100 * (uint64_t)1000000; uint64_t timeout_nsec; timeout_nsec = _syspage_time(CLOCK_MONOTONIC); timeout_nsec += delay_ms * (uint64_t)1000000; /* Check to make sure we don't wait for something already there... */ ret_val = checkfunc( path, handle ); if ( ret_val >= 0 || ret_val == WAITFOR_CHECK_ABORT ) { return ret_val; } if ( poll_ms > 0 ) { polltimeout = poll_ms * (uint64_t)1000000; } /* * We make the channel fixed since we want to remain at the current * thread's priority */ chid = ChannelCreate(_NTO_CHF_FIXED_PRIORITY); if ( chid == -1 ) { goto fail1; } coid = ConnectAttach( ND_LOCAL_NODE, 0, chid, _NTO_SIDE_CHANNEL, 0 ); if ( coid == -1 ) { goto fail2; } SIGEV_PULSE_INIT( &event, coid, SIGEV_PULSE_PRIO_INHERIT, PULSE_CODE_PATHSPACE, 0 ); notify_id = procmgr_event_notify_add( PROCMGR_EVENT_PATHSPACE, &event ); if ( notify_id == -1 ) { goto fail3; } while(_syspage_time(CLOCK_MONOTONIC) < timeout_nsec) { /* we need to poll in case we are checking for a subdirectory/file, * since we won't get a pathmgr event for those. */ SIGEV_UNBLOCK_INIT(&event); if ( TimerTimeout( CLOCK_MONOTONIC, _NTO_TIMEOUT_RECEIVE, &event, &polltimeout, NULL) == -1 ) { ret_val = -1; break; } if ( MsgReceivePulse( chid, &pulse, sizeof(pulse), NULL ) != -1 || errno == ETIMEDOUT ) { ret_val = checkfunc( path, handle ); if ( ret_val >= 0 || ret_val == WAITFOR_CHECK_ABORT ) { break; } } else { break; } } (void)procmgr_event_notify_delete( notify_id ); fail3: (void)ConnectDetach(coid); fail2: (void)ChannelDestroy(chid); fail1: return ret_val; }
/**************************************************************************** * * Subroutine state_thread * * Purpose: This is a thread that is used to trigger the various thread * states * * Parameters: None * * Returns: Nothing * * *****************************************************************************/ void * state_thread(void * arg) { int rc,x,coid; sigset_t myset; uint64_t timeout; struct sigevent myevent; pthread_t mythread; char buf[100]; while(1) { /* Syncronize with the main thread. */ pthread_barrier_wait(&global_barrier); switch (cur_state) { case STATE_DEAD: /* Start the logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); /* Trigger the dead state by calling pthread_exit */ pthread_exit(NULL); /* Should never get here */ abort(); case STATE_READY: exit_now=0; for (x=0;x<_syspage_ptr->num_cpu;x++) pthread_create(NULL, NULL, ready_thread, NULL); /* Let the new threads get started */ sleep(1); case STATE_RUNNING: /* Start the logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); /* Trigger the running state by just doing some work. * this should also trigger a ready state before * we are running */ x=0; while(x<10) x++; exit_now=1; while(x<1000) x++; exit_now=1; /* and unblock the parent */ pthread_barrier_wait(&global_barrier); break; case STATE_STOPPED: /* Start the logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(100); kill (child_pid, SIGSTOP); delay(10); kill (child_pid, SIGCONT); delay(100); pthread_barrier_wait(&global_barrier); break; case STATE_SEND: case STATE_REPLY: coid=ConnectAttach(0, getpid(), chid, _NTO_SIDE_CHANNEL, 0); /* Start the logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); /* Trigger the SEND/REPLY blocked states */ MsgSend(coid, buf, 10, buf,10); pthread_barrier_wait(&global_barrier); break; case STATE_RECEIVE: /* Start the logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); /* Trigger a receive state */ rc=MsgReceive(chid, buf, sizeof(buf), NULL); MsgReply(rc, EOK, "ok", 3); pthread_barrier_wait(&global_barrier); break; case STATE_WAITTHREAD: /* Start the logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); /* Trigger a waitthread state */ pthread_create(NULL, NULL, nothing_thread, NULL); pthread_barrier_wait(&global_barrier); break; case STATE_SIGSUSPEND: memset(&myevent, 0, sizeof(myevent)); myevent.sigev_notify = SIGEV_UNBLOCK; timeout = 1*1000000000L; sigemptyset(&myset); sigaddset(&myset, SIGHUP); sigaddset(&myset, SIGBUS); sigaddset(&myset, SIGSEGV); sigaddset(&myset, SIGXCPU); sigaddset(&myset, SIGRTMIN); sigaddset(&myset, SIGRTMAX); /* Start logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); TimerTimeout( CLOCK_REALTIME, _NTO_TIMEOUT_SIGSUSPEND,&myevent, &timeout, NULL ); SignalSuspend(&myset); pthread_barrier_wait(&global_barrier); break; case STATE_SIGWAITINFO: memset(&myevent, 0, sizeof(myevent)); myevent.sigev_notify = SIGEV_UNBLOCK; timeout = 1*1000000000L; sigemptyset(&myset); sigaddset(&myset, SIGHUP); sigaddset(&myset, SIGBUS); sigaddset(&myset, SIGSEGV); sigaddset(&myset, SIGXCPU); sigaddset(&myset, SIGRTMIN); sigaddset(&myset, SIGRTMAX); /* Start logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); TimerTimeout( CLOCK_REALTIME, _NTO_TIMEOUT_SIGWAITINFO,&myevent, &timeout, NULL ); SignalWaitinfo(&myset,NULL); pthread_barrier_wait(&global_barrier); break; case STATE_NANOSLEEP: /* Start logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); sleep(1); sleep(1); pthread_barrier_wait(&global_barrier); break; case STATE_MUTEX: /* Start logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); sleep(1); pthread_mutex_lock(&mymutex); pthread_mutex_unlock(&mymutex); pthread_barrier_wait(&global_barrier); break; case STATE_CONDVAR: /* Start logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); sleep(1); pthread_mutex_lock(&mymutex); pthread_cond_wait(&mycondvar, &mymutex); pthread_mutex_unlock(&mymutex); pthread_barrier_wait(&global_barrier); break; case STATE_JOIN: pthread_create(&mythread, NULL, nothing_thread, NULL); /* Start logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); delay(10); pthread_join(mythread, NULL); pthread_barrier_wait(&global_barrier); break; case STATE_SEM: /* Start logging */ rc=TraceEvent(_NTO_TRACE_STARTNOSTATE); assert(rc!=-1); sleep(1); sem_wait(&mysem); pthread_barrier_wait(&global_barrier); break; } } }
int main(int argc, char **argv) { if(argc != 2) { printf("Set client id\n"); return EXIT_SUCCESS; } uint32_t cid = atoi(argv[1]);//!! struct timespec timeout, stime, etime; frame_t frame, rframe; char buf[BUFFER_SIZE], cmd[BUFFER_SIZE], param[BUFFER_SIZE]; int itr = -1, n, k; FILE *pfile = 0; uint32_t itr_max = ITR; double_t *pfcn, *psig, init; uint64_t timeoutsend = 200000000; //***************************************************************************** timeout.tv_nsec = 0; timeout.tv_sec = 1; strcpy(buf, CFGFILENAME); strcat(buf, argv[1]); pfile = fopen(buf, "r"); if(NULL != pfile) { while(0 == feof(pfile)) { fscanf(pfile, "%s %s", cmd, param); if(0 == strcmp(cmd, "itr_max")) { itr_max = atoi(param); } else if(0 == strcmp(cmd, "timeoutsend")) { timeoutsend = atol(param); } else if(0 == strcmp(cmd, "timeout_sec")) { timeout.tv_sec = atol(param); } else if(0 == strcmp(cmd, "timeout_nsec")) { timeout.tv_nsec = atol(param); } } fclose(pfile); } else { perror(MSG_ERR_CFGFILE); } strcpy(buf, OUTFILENAME); strcat(buf, argv[1]); pfile = fopen(buf, "w"); fprintf(pfile, "itr_max %i\ntimeoutsend %llu\ntimeout %lu %lu\n", itr_max, timeoutsend, timeout.tv_sec, timeout.tv_nsec); pfcn = malloc(sizeof(double_t)*(SIZE*2)); psig = malloc(sizeof(double_t)*((SIZE-1)*2)); srand(time(NULL)); for(size_t i = 0; i<SIZE; i++) { pfcn[i] = i*STEP; pfcn[i+SIZE] = sin(pfcn[i])+2; } for(size_t i = 0; i<SIZE-1; i++) { psig[i] = SHIFT + (rand()%SIZE)*STEP; psig[i+SIZE-1] = sin(psig[i])+2; } frame.cid = cid; frame.fid = 0; frame.size = 2; //***************************************************************************** int srv_coid = name_open(SRV_NAME, NAME_FLAG_ATTACH_GLOBAL); __ERROR_EXIT(srv_coid, -1, SRV_NAME); frame.ptask = malloc(sizeof(task_t)*2); frame.ptask[0].cmd = SPLINE_INIT; frame.ptask[0].n = SIZE*2*sizeof(double_t); frame.ptask[0].px = (void*)pfcn; frame.timeout = timeout; frame.ptask[1].cmd = SPLINE_GETVAL; frame.ptask[1].n = 2*sizeof(double_t); frame.ptask[1].px = (void*)psig; frame_repinit(&frame, &rframe); __ERROR_CHECK(TimerTimeout(CLOCK_REALTIME, _NTO_TIMEOUT_SEND | _NTO_TIMEOUT_REPLY, NULL, &timeoutsend, NULL), -1, "TimerTimeout"); // send init data about spline __ERROR_CHECK(frame_send(srv_coid, &frame, &rframe), -1, "sendv"); frame_destroy(&rframe); free(frame.ptask); frame.ptask = malloc(sizeof(task_t)); frame.ptask[0].cmd = SPLINE_GETVAL; frame.ptask[0].n = sizeof(double_t); frame.size = 1; frame_repinit(&frame, &rframe); k=0; for(uint32_t i=0; i<itr_max; ++i) { frame.fid = i; n = rand()%(SIZE-1); frame.ptask[0].px = (void*)&psig[n]; trace_msg_start(); // send tasks to server and wait for results __ERROR_CONT(frame_send(srv_coid, &frame, &rframe), -1, "sendv"); trace_msg_stop(); clock_gettime(CLOCK_MONOTONIC, &etime); fprintf(pfile, "%f %f %u %u\n", psig[n], *(double_t*)rframe.ptask->px, etime.tv_sec-stime.tv_sec, etime.tv_nsec-stime.tv_nsec); printf("I receive data\n"); } frame.ptask[0].cmd = SPLINE_DESTROY; frame.ptask[0].n = 0; frame.ptask[0].px = 0; frame.fid++; // say server to destroy our spline __ERROR_CHECK(frame_send(srv_coid, &frame, &rframe), -1, "sendv"); fclose(pfile); frame_destroy(&rframe); free(pfcn); free(psig); __ERROR_CHECK(name_close(srv_coid), -1, "name_close"); return EXIT_SUCCESS; }