/*===========================================================================* * do_settime * *===========================================================================*/ int do_settime(struct proc * caller, message * m_ptr) { clock_t newclock, ticks; time_t timediff; if (m_ptr->T_CLOCK_ID != CLOCK_REALTIME) /* only realtime can change */ return EINVAL; if (m_ptr->T_SETTIME_NOW == 0) { /* user just wants to adjtime() */ /* convert delta value from seconds and nseconds to ticks */ ticks = (m_ptr->T_TIME_SEC * system_hz) + (m_ptr->T_TIME_NSEC/(1000000000/system_hz)); set_adjtime_delta(ticks); return(OK); } /* else user wants to set the time */ /* prevent a negative value for realtime */ if (m_ptr->T_TIME_SEC <= boottime) { /* boottime was likely wrong, try to correct it. */ boottime = m_ptr->T_TIME_SEC; set_realtime(1); return(OK); } /* calculate the new value of realtime in ticks */ timediff = m_ptr->T_TIME_SEC - boottime; newclock = (timediff*system_hz) + (m_ptr->T_TIME_NSEC/(1000000000/system_hz)); set_realtime(newclock); return(OK); }
void TimerTestFixture::testTimerUnderAttack(){ shared_ptr<Timer> t(new Timer()); set_realtime(94); for(int i = 0; i < 1000; i++){ MWTime delay = 10000; shared_ptr <Clock> clock = Clock::instance(); MWTime then = clock->getCurrentTimeUS(); t->startUS(delay); while(!t->hasExpired()) clock->sleepUS(50); MWTime now = clock->getCurrentTimeUS(); //cerr << "Timer fell at expiration-relative time of: " // << (now - then) - delay << endl; CPPUNIT_ASSERT( (now - then) > delay ); CPPUNIT_ASSERT( abs( (now - then) - delay ) < 1000 ); } }
void TimerTestFixture::testTimerWithTimebase(){ set_realtime(94); shared_ptr<TimeBase> tb(new TimeBase()); shared_ptr<Timer> t(new Timer()); MWTime time_amount = 1000; shared_ptr<Variable> time_to_wait(new ConstantVariable(time_amount)); StartTimer a(t,tb, time_to_wait); shared_ptr <Clock> clock = Clock::instance(); MWTime then = clock->getCurrentTimeUS(); tb->setNow(); for(int i = 1; i < 5000; i++){ a.execute(); while(!t->hasExpired()) clock->sleepUS(10); MWTime now = clock->getCurrentTimeUS(); //cerr << "Now: " << now << endl; MWTime error = (now - then) - (MWTime)(*time_to_wait); //cerr << "Error: " << (long long) error << endl; CPPUNIT_ASSERT( abs(error) < 2000 ); CPPUNIT_ASSERT( error > 0 ); time_to_wait->setValue(i * time_amount); //cerr << "Waiting: " << (long long)(*time_to_wait) << endl; } }
static void set_mark_thread_prio(void){ #if NO_SNAPSHOT set_snapshot_thread_prio(0); #else set_realtime(SCHED_RR,sched_get_priority_min(SCHED_RR)); #endif }
static void set_snapshot_thread_prio(int num){ #if NO_SNAPSNOT bound_thread_to_cpu(NONSNAPSHOT_SNAPSHOT_CPU); #else if(num==0) bound_thread_to_cpu(SNAPSHOT_CPU1); else bound_thread_to_cpu(SNAPSHOT_CPU2); #endif set_realtime(SCHED_FIFO,audio_priority); //set_realtime(SCHED_FIFO,99); }
int main(int argc, char *argv[]){ if(argc<3){ error("Usage: \n\t./ethtest client hostname port \n\t./ethtest server port\n\t./ethtest mvm_server port\n"); _Exit(1); } set_realtime(0, -20); char *NBUF=getenv("NBUF"); if(NBUF){ nbuf=strtol(NBUF, NULL, 10); dbg("nbuf=%d\n", nbuf); } char *ip=0; if(argc>3){ ip=argv[3]; } if(!strcmp(argv[1], "server")){ int port=strtol(argv[2], NULL, 10); listen_port(port, ip, server, 0, NULL, 1); }else if(!strcmp(argv[1],"mvm_server")){ int port=strtol(argv[2], NULL, 10); listen_port(port, ip, mvm_server, 0, NULL, 1); }else{ if(argc<4){ error("Usage: ./ethtest client hostname port [nrep] [nmin] [nmax] [nstep]"); } const char *host=argv[2]; int port=strtol(argv[3], NULL, 10); int nstep=100; int nmin=409584; int nmax=409584; int nrep=1000; if(argc>4){ nrep=strtol(argv[4], NULL, 10); } if(argc>5){ nmin=strtol(argv[5], NULL, 10); } if(argc>6){ nmax=strtol(argv[6], NULL, 10); } if(argc>7){ nstep=strtol(argv[7], NULL, 10); } client(host, port, nmin, nmax, nstep, nrep); } }
/*===========================================================================* * do_settime * *===========================================================================*/ int do_settime(struct proc * caller, message * m_ptr) { clock_t newclock; int32_t ticks; time_t timediff, timediff_ticks; if (m_ptr->m_lsys_krn_sys_settime.clock_id != CLOCK_REALTIME) /* only realtime can change */ return EINVAL; if (m_ptr->m_lsys_krn_sys_settime.now == 0) { /* user just wants to adjtime() */ /* convert delta value from seconds and nseconds to ticks */ ticks = (m_ptr->m_lsys_krn_sys_settime.sec * system_hz) + (m_ptr->m_lsys_krn_sys_settime.nsec/(1000000000/system_hz)); set_adjtime_delta(ticks); return(OK); } /* else user wants to set the time */ timediff = m_ptr->m_lsys_krn_sys_settime.sec - boottime; timediff_ticks = timediff * system_hz; /* prevent a negative value for realtime */ if (m_ptr->m_lsys_krn_sys_settime.sec <= boottime || timediff_ticks < LONG_MIN/2 || timediff_ticks > LONG_MAX/2) { /* boottime was likely wrong, try to correct it. */ boottime = m_ptr->m_lsys_krn_sys_settime.sec; set_realtime(1); return(OK); } /* calculate the new value of realtime in ticks */ newclock = timediff_ticks + (m_ptr->m_lsys_krn_sys_settime.nsec/(1000000000/system_hz)); set_realtime(newclock); return(OK); }
void TimerTestFixture::testTimerOverrideMultipleTimesFast(){ shared_ptr<Timer> t(new Timer()); set_realtime(94); for(int i = 0; i < NUM_TIMER_RESETS; i++){ //if(i%10 == 0) { // fprintf(stderr, "%d timer resets (fast)\n", i); fflush(stderr); //} t->startMS(10); shared_ptr <Clock> clock = Clock::instance(); clock->sleepMS(1); CPPUNIT_ASSERT( t->hasExpired() == false ); clock->sleepMS(6); // 3 ms left to go CPPUNIT_ASSERT( t->hasExpired() == false ); // Bump that up to 10 t->startMS(10); clock->sleepMS(7); // Should be 3 ms left. CPPUNIT_ASSERT( t->hasExpired() == false ); clock->sleepMS(4); // Should be done CPPUNIT_ASSERT( t->hasExpired() == true ); t->startMS(10); t->startMS(20); CPPUNIT_ASSERT( t->hasExpired() == false ); clock->sleepMS(15); CPPUNIT_ASSERT( t->hasExpired() == false ); clock->sleepMS(6); CPPUNIT_ASSERT( t->hasExpired() == true ); } }
static void busy_loop_thread(void){ int cpu = atomic_add_get_oldval(&bl_cpu_num,1); bound_thread_to_cpu(cpu_nums[cpu]); set_realtime(SCHED_FIFO,audio_priority - 2); while(true){ semaphore_wait(bl_semaphore[cpu]); //fprintf(stderr,"starting to busy-loop %d\n",cpu); while(bl_please_stop[cpu]==0){ double start = get_ms(); while( (get_ms() - start) < 0.01); //sched_yield(); } //fprintf(stderr,"stopping busy-loop %d\n",cpu); } }
// SangSpilling foregår ved å sette registerene A (X, Y) før en kaller opp interpreteren int main(int argc, char **argv) { if((fd_mem = open("/dev/mem", O_RDWR | O_SYNC)) == -1) { printf("Could not get /dev/mem\n"); return -1; } sid_kernel_timer = fopen("/dev/sid_timer", "r"); if (sid_kernel_timer == NULL) { printf("Could not get /dev/sid_timer\n"); return -1; } set_realtime(); printWelcome(); initGPIO(); initPWM(); // sjekk opp argv[1] if (argv[1]) { menu_init(argv[1]); } else { printf("Required parameter - top level directory not specified"); exit(1); } if (argc > 2) { int z = strtol(argv[2], NULL, 10); printf("LCD reinit %d\n", z); lcd_reinit(z, z); } else { lcd_init(); } while(1) { menu_run(); if (inputSidFile != NULL) { int32_t next = c64_play(); next = next * ((float) sh.hz / 1000000.0f); platform_usleep(next); } else { usleep(1000); } } }
int main(int argc, char *argv[]){ enum{ P_EXE, P_FRAC, P_NSTEP, P_TOT, }; if(argc!=P_TOT){ info2("Usage: \n\tenv MVM_CLIENT=hostname MVM_PORT=port MVM_SASTEP=sastep ./mvm_cpu fraction nstep\n"); _Exit(0); } int fraction=strtol(argv[P_FRAC], NULL, 10); int nstep=strtol(argv[P_NSTEP], NULL, 10); int nstep0=nstep>1?20:0;//warm up dmat *d_saind=dread("NFIRAOS_saind"); const int nsa=(d_saind->nx-1)/fraction; int *saind=mymalloc((1+nsa),int); for(int i=0; i<nsa+1; i++){ saind[i]=(int)d_saind->p[i]; } dfree(d_saind); const int totpix=saind[nsa]; const int nact=6981;//active subapertures. int ng=nsa*2; float FSMdelta=-0.2; smat *dm=snew(nact,1); smat *mvm=snew(nact, ng); smat *mtch=snew(totpix*2,1); smat *grad=snew(ng,1); smat *im0=snew(totpix,3); short *pix=mymalloc(totpix,short); short *pixbias=mymalloc(totpix,short); { rand_t rseed; seed_rand(&rseed, 1); srandu(mvm, 1e-7, &rseed); srandu(mtch, 1, &rseed); for(int i=0; i<totpix; i++){ pix[i]=(short)(randu(&rseed)*25565); pixbias[i]=(short)(randu(&rseed)*1000); } } smat *mvmt=strans(mvm); int sastep=200;//how many subapertures each time int nrep=1; if(getenv("MVM_NREP")){ nrep=strtol(getenv("MVM_NREP"), NULL, 10); } if(getenv("MVM_SECT")){ sastep=nsa/strtol(getenv("MVM_SECT"), NULL, 10); } if(getenv("MVM_TRANS")){ use_trans=strtol(getenv("MVM_TRANS"), NULL, 10); } if(getenv("MVM_SASTEP")){ sastep=strtol(getenv("MVM_SASTEP"), NULL, 10); } info2("use_trans=%d, nrep=%d, sastep=%d\n", use_trans, nrep, sastep); int sock=-1; char* MVM_CLIENT=getenv("MVM_CLIENT"); if(MVM_CLIENT){ short port=(short)strtol(getenv("MVM_PORT"), NULL, 10); sock=connect_port(MVM_CLIENT, port, 0 ,1); if(sock!=-1) { info2("Connected\n"); int cmd[7]; cmd[0]=nact; cmd[1]=nsa; cmd[2]=sastep; cmd[3]=totpix; cmd[4]=nstep; cmd[5]=nstep0; cmd[6]=2; if(stwriteintarr(sock, cmd, 7) || stwriteintarr(sock, saind, nsa+1) || stwrite(sock, pix, sizeof(short)*totpix)){ close(sock); sock=-1; warning("Failed: %s\n", strerror(errno)); } } } int ready=0; if(sock!=-1 && stwriteint(sock, ready)){ warning("error send ready signal: %s\n", strerror(errno)); close(sock); sock=-1; } smat *timing=snew(nstep, 1); TIC; float timtot=0, timmax=0, timmin=INFINITY; set_realtime(-1, -20); for(int jstep=-nstep0; jstep<nstep; jstep++){ int istep=jstep<0?0:jstep; tic; double theta=M_PI*0.5*istep+FSMdelta; float cd=cos(theta); float sd=cos(theta); szero(dm); for(int isa=0; isa<nsa; isa+=sastep){ int npixleft; int nsaleft; if(nsa<isa+sastep){//terminate npixleft=totpix-saind[isa]; nsaleft=nsa-isa; }else{ npixleft=saind[isa+sastep]-saind[isa]; nsaleft=sastep; } short *pcur=pix+saind[isa]; if(sock!=-1){ if(stread(sock, pcur, sizeof(short)*npixleft)){ warning("failed: %s\n", strerror(errno)); close(sock); sock=-1; _Exit(1); } if(isa==0) tic; } //Matched filter mtch_do(mtch->p, pix, pixbias, grad->p+isa*2, im0->p, im0->p+totpix, im0->p+totpix*2, saind+isa, nsaleft, cd, sd); //MVM for(int irep=0; irep<nrep; irep++){ if(use_trans){ mvmt_do(mvmt->p+isa*2, grad->p+isa*2,dm->p, nact, nsaleft*2, ng); }else{ mvm_do(mvm->p+isa*2*nact, grad->p+isa*2, dm->p, nact, nsaleft*2); } } }//for isa if(sock!=-1){ if(stwrite(sock, dm->p, sizeof(float)*nact)){ warning("error write dmres: %s\n", strerror(errno)); close(sock); sock=-1; _Exit(1); } if(streadint(sock, &ready)){//acknowledgement. warning("error read ack failed: %s\n", strerror(errno)); close(sock), sock=-1; _Exit(1); } timing->p[istep]=ready*1.e-6; }else{ timing->p[istep]=toc3;//do not tic. } if(jstep==istep){ timtot+=timing->p[istep]; if(timmax<timing->p[istep]){ timmax=timing->p[istep]; } if(timmin>timing->p[istep]){ timmin=timing->p[istep]; } } }//for istep float timmean=timtot/nstep; info2("Timing is mean %.3f, max %.3f min %.3f. BW is %.1f of 51.2GB/s\n", timmean*1e3, timmax*1e3, timmin*1e3, nrep*(nact*ng+nact+ng)*sizeof(float)/timmean/(1024*1024*1024)); writebin(timing, "cpu_timing_%s", HOST); if(nstep==1){ writearr("cpu_pix", 1, sizeof(short), M_INT16, NULL, pix, totpix, 1); writearr("cpu_pixbias", 1, sizeof(short), M_INT16, NULL, pixbias, totpix, 1); writebin(dm, "cpu_dm"); writebin(grad, "cpu_grad"); writebin(mvm, "cpu_mvm"); writebin(mtch, "cpu_mtch"); } }
/* Change priority for thread 'threadhandle', or for the calling thread if 'threadhandle' == NULL. * threadhandle == 0x1 means "Main Psychtoolbox thread" and may incur special treatment. * 'basePriority' can be 0 for normal scheduling, 1 for higher priority and 2 for highest priority. * 'tweakPriority' modulates more fine-grained within the category given by 'basepriority'. It * can be anywhere between 0 and some big value where bigger means more priority. * * Returns zero on success, non-zero on failure to set new priority. */ int PsychSetThreadPriority(psych_thread* threadhandle, int basePriority, int tweakPriority) { int rc = 0; pthread_t thread; int kernError; task_t threadID; thread_policy_t threadPolicy; mach_msg_type_number_t policyCount, policyCountFilled; boolean_t isDefault; if ((NULL != threadhandle) && ((psych_thread*) 0x1 != threadhandle)) { // Retrieve thread handle of thread to change: thread = *threadhandle; } else { // Retrieve handle of calling thread: thread = pthread_self(); } // Map Posix thread handle to Mach thread handle: threadID = pthread_mach_thread_np(thread); // Get timebase: double ticksPerSec = PsychGetKernelTimebaseFrequencyHz(); double baseQuantum = 0.010; // tweakPriority <= 0 -> 10% cpu. Can go up to 90% at level >=8 in 10% increments. if (tweakPriority < 0) tweakPriority = 0; if (tweakPriority > 8) tweakPriority = 8; switch(basePriority) { case 0: // Normal priority: Drop to standard scheduling. threadPolicy = (thread_policy_t) malloc(sizeof(thread_standard_policy_data_t)); policyCount = THREAD_STANDARD_POLICY_COUNT; policyCountFilled = policyCount; isDefault = TRUE; kernError = thread_policy_get(threadID, THREAD_STANDARD_POLICY, threadPolicy, &policyCountFilled, &isDefault); if (kernError == 0) kernError = thread_policy_set(threadID, THREAD_STANDARD_POLICY, threadPolicy, policyCountFilled); free(threadPolicy); rc = (int) kernError; break; case 1: // High priority: Up to 90% cpu utilization, but preemptible for urgent tasks, with an allowable total time to completion of baseQuantum. // This basically says: "I am more important than bog-standard threads, and i want to have x msecs of 10 msecs very 10 msecs, but i don't care // about startup delay (reaction times) or interruptions, as long as i don't lose more than 10 msecs. Good for high priority compute tasks // with lots of wiggle room wrt. when stuff happens, e.g., some data producer thread or i/o thread which needs to deliver/handle a certain // amount of data processing/shuffling/io within a certain time quantum, because it is feeding some other realtime thread or hw process, // due to things like intermediate fifo buffering, itself can tolerate a certain lag. // This may become useful in the future for i/o functions in IOPort/PsychHID, movie playback/recording helper threads etc... rc = set_realtime(threadID, baseQuantum * ticksPerSec, (((double) tweakPriority + 1) / 10) * baseQuantum * ticksPerSec, baseQuantum * ticksPerSec, TRUE); break; case 2: // Realtime priority: Up to (tweakPriority + 1) msecs out of 10 msecs of *uninterrupted* computation (non-preemptible after start). // However, after the thread becomes runnable, its actual start of uninterrupted execution can be delayed by up to 1 msec, e.g., if more // important (basePriority 10) threads are executing, or a high priority or lower priority thread needs some computation time. // This is our most common use-case: Most of our realtime threads are completely triggered (= reactive to) by external hardware input events. // They wait on the arrival of some external event, e.g., a user key press or mouse click, some trigger signal from some I/O device like // response box, serial port or parallel port, DAQ board etc., or for some timer going off at a certain time. Most often they have to respond // to some trigger event by either executing some action, or by simply timestamping the event, like a button press of a subject, or some TTL // trigger from some equipment. Executing the actual action, or timestamping, or storing the received data in some queue, is usually fast, // the computation finishes quickly. As timestamping or external hardware control can be involved, we don't want to get preempted once running, // to avoid impairing precision of timestamps or clock-sync algorithms or hw control actions. However for typical neuro-science experiments, // we can tolerate a random time delay (or imprecision in acquired timestamps) of 1 msec. // Typical consumers of this setup: IOPort, PsychHID, Movie playback or video capture high-level control. rc = set_realtime(threadID, baseQuantum * ticksPerSec, (((double) tweakPriority + 1) / 10) * baseQuantum * ticksPerSec, (((double) tweakPriority + 1 + 1) / 10) * baseQuantum * ticksPerSec, FALSE); break; case 10: // Critical priority: Up to (tweakPriority + 1) msecs out of 10 msecs of *uninterrupted* computation (non-preemptible after start), // must run as soon as possible and then complete without distraction. This is good for timestamping operations that must not be interrupted // in the wrong moment, because that would impair timestamps significantly, and for time-based triggering of execution of operations with // the highest possible timing precision. // Out main client of this is currently the OpenGL flipperThread used by Screen for async flip scheduling and timestamping, and for // frame-sequential stereo fallback. For those apps, uninterrupted low latency is crucial. flipperThread uses tweakPriority == 2, so could // run for up to 3 msecs uninterrupted, something it usually won't do (closer to << 1 msec is expected), but can do in a worst case scenario, // where various workarounds for broken GPU drivers are active and screen resolution/refresh rate settings are especially suboptimal. // The other client is video refresh rate calibration during Screen('GetFlipInterval') active calibration or during Screen('Openwindow') // default calibration. // // Future clients may be found in the IOPort async-task framework for highly timing sensitive i/o operations. rc = set_realtime(threadID, baseQuantum * ticksPerSec, (((double) tweakPriority + 1) / 10) * baseQuantum * ticksPerSec, 0, FALSE); break; default: printf("PTB-CRITICAL: In call to PsychSetThreadPriority(): Invalid/Unknown basePriority %i provided!\n", basePriority); rc = 2; } // Try to apply new priority and scheduling method: if (rc != 0) { printf("PTB-WARNING: In call to PsychSetThreadPriority(): Failed to set new basePriority %i, tweakPriority %i, effective %i [%s] for thread %p provided!\n", basePriority, tweakPriority, tweakPriority, (basePriority > 0) ? "REALTIME" : "NORMAL", (void*) threadhandle); printf("PTB-WARNING: This can lead to timing glitches and odd performance behaviour.\n"); } // rc is either zero for success, or 2 for invalid arg, or some other non-zero failure code: return(rc); }
static void set_free_thread_prio(void){ set_realtime(SCHED_FIFO, audio_priority >= 2 ? GC_MAX(sched_get_priority_min(SCHED_FIFO),audio_priority-1) : audio_priority); }
void StandardStateSystem::run() { #ifdef __APPLE__ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; #endif weak_ptr<State> next_state; int bus_speed, mib [2] = { CTL_HW, HW_BUS_FREQ }; size_t len; len = sizeof (bus_speed); sysctl (mib, 2, &bus_speed, &len, NULL, 0); int didit = set_realtime(STATE_SYSTEM_PRIORITY); if(didit){ //fprintf(stderr,"Scheduler went realtime. Rock on.\n"); //fflush(stderr); } else { fprintf(stderr,"Scheduler didn't go realtime. Bummer.\n"); fflush(stderr); } // Make a copy of the experiment to ensure that it isn't destroyed before we're done with it shared_ptr<Experiment> current_experiment = GlobalCurrentExperiment; if (!current_experiment) { merror(M_STATE_SYSTEM_MESSAGE_DOMAIN, "Cannot start state system without a valid experiment defined"); return;
int main(int argc, const char **argv) { pthread_mutexattr_t ma; pthread_mutex_t *mutex; int fd, ret, i; pid_t pid; void *addr; int num_children; int priority = PRIO_NORMAL; if (argc < 3 || argc > 4) { fprintf(stderr, "Usage: %s <file> <n> [0|1|2]\n", argv[0]); fprintf(stderr, " %s <file> debug\n", argv[0]); exit(1); } if (argc == 4) { priority = atoi(argv[3]); } if (priority == PRIO_REALTIME) { set_realtime(); } else if (priority == PRIO_NICE_20) { high_priority(); } fd = open(argv[1], O_CREAT|O_RDWR, 0600); if (fd == -1) { fprintf(stderr, "open failed\n"); exit(1); } ret = lseek(fd, 0, SEEK_SET); if (ret != 0) { fprintf(stderr, "lseek failed\n"); exit(1); } ret = ftruncate(fd, sizeof(pthread_mutex_t)); if (ret != 0) { fprintf(stderr, "ftruncate failed\n"); exit(1); } addr = mmap(NULL, sizeof(pthread_mutex_t), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FILE, fd, 0); if (addr == NULL) { fprintf(stderr, "mmap failed\n"); exit(1); } mutex = (pthread_mutex_t *)addr; if (strcmp(argv[2], "debug") == 0) { ret = pthread_mutex_trylock(mutex); if (ret == EOWNERDEAD) { ret = pthread_mutex_consistent(mutex); if (ret == 0) { pthread_mutex_unlock(mutex); } } else if (ret == EBUSY) { printf("pid=%u\n", mutex->__data.__owner); } else if (ret == 0) { pthread_mutex_unlock(mutex); } exit(0); } ret = pthread_mutexattr_init(&ma); if (ret != 0) { fprintf(stderr, "pthread_mutexattr_init failed\n"); exit(1); } ret = pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK); if (ret != 0) { fprintf(stderr, "pthread_mutexattr_settype failed\n"); exit(1); } ret = pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED); if (ret != 0) { fprintf(stderr, "pthread_mutexattr_setpshared failed\n"); exit(1); } ret = pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST); if (ret != 0) { fprintf(stderr, "pthread_mutexattr_setrobust failed\n"); exit(1); } ret = pthread_mutex_init(mutex, &ma); if (ret != 0) { fprintf(stderr, "pthread_mutex_init failed\n"); exit(1); } ret = pthread_mutex_lock(mutex); if (ret != 0) { fprintf(stderr, "pthread_mutex_lock failed\n"); exit(1); } setpgid(0, 0); fprintf(stderr, "Creating children\n"); num_children = atoi(argv[2]); for (i=0; i<num_children; i++) { pid = fork(); if (pid < 0) { fprintf(stderr, "fork() failed\n"); exit(1); } if (pid == 0) { close(fd); run_child(argv[1]); exit(1); } } fprintf(stderr, "Waiting for children\n"); ret = pthread_mutex_unlock(mutex); if (ret != 0) { fprintf(stderr, "pthread_mutex_unlock failed\n"); exit(1); } for (i=0; i<num_children; i++) { int status; pid = waitpid(-1, &status, 0); if (pid <= 0) { fprintf(stderr, "waitpid() failed\n"); } } close(fd); unlink(argv[1]); exit(0); }
static void set_priority(priority_t *priority){ set_realtime(priority->policy,priority->priority); }
int main(int ac, char **av) { int realtime = 0; int parallel = 1; int warmup = 0; int repetitions = -1; int c; char buf[512]; timer_e what = USLEEP; state_t state; char *scheduler = ""; char *mechanism = "usleep"; char *usage = "[-r] [-u <method>] [-P <parallelism>] [-W <warmup>] [-N <repetitions>] usecs\nmethod=usleep|nanosleep|select|pselect|itimer\n"; realtime = 0; while ((c = getopt(ac, av, "ru:W:N:")) != EOF) { switch (c) { case 'r': realtime = 1; break; case 'u': if (strcmp(optarg, "usleep") == 0) { what = USLEEP; mechanism = "usleep"; } else if (strcmp(optarg, "nanosleep") == 0) { what = NANOSLEEP; mechanism = "nanosleep"; } else if (strcmp(optarg, "select") == 0) { what = SELECT; mechanism = "select"; #ifdef _POSIX_SELECT } else if (strcmp(optarg, "pselect") == 0) { what = PSELECT; mechanism = "pselect"; #endif /* _POSIX_SELECT */ } else if (strcmp(optarg, "itimer") == 0) { what = ITIMER; mechanism = "itimer"; } else { lmbench_usage(ac, av, usage); } break; case 'P': parallel = atoi(optarg); if (parallel <= 0) lmbench_usage(ac, av, usage); break; case 'W': warmup = atoi(optarg); break; case 'N': repetitions = atoi(optarg); break; default: lmbench_usage(ac, av, usage); break; } } if (optind != ac - 1) { lmbench_usage(ac, av, usage); } state.usecs = bytes(av[optind]); if (realtime && set_realtime()) scheduler = "realtime "; switch (what) { case USLEEP: benchmp(NULL, bench_usleep, NULL, 0, parallel, warmup, repetitions, &state); break; case NANOSLEEP: benchmp(NULL, bench_nanosleep, NULL, 0, parallel, warmup, repetitions, &state); break; case SELECT: benchmp(NULL, bench_select, NULL, 0, parallel, warmup, repetitions, &state); break; #ifdef _POSIX_SELECT case PSELECT: benchmp(NULL, bench_pselect, NULL, 0, parallel, warmup, repetitions, &state); break; #endif /* _POSIX_SELECT */ case ITIMER: benchmp(initialize, bench_itimer, NULL, 0, parallel, warmup, repetitions, &state); break; default: lmbench_usage(ac, av, usage); break; } sprintf(buf, "%s%s %lu microseconds", scheduler, mechanism, state.usecs); micro(buf, get_n()); return (0); }
int disk_scan(disk_t *disk, enum scan_mode mode, unsigned data_size) { disk->run = 1; void *data = allocate_buffer(data_size); uint32_t *scan_order = NULL; int result = 0; struct scan_state state = {.latency = NULL, .progress_bytes = 0, .progress_full = 1000}; struct timespec ts_start; struct timespec ts_end; time_t scan_time; disk->conclusion = CONCLUSION_SCAN_PROBLEM; if (data_size % disk->sector_size != 0) { data_size -= data_size % disk->sector_size; if (data_size == 0) data_size = disk->sector_size; ERROR("Cannot scan data not in multiples of the sector size, adjusted scan size to %u", data_size); } set_realtime(true); clock_gettime(CLOCK_MONOTONIC, &ts_start); INFO("Scanning disk %s in %u byte steps", disk->path, data_size); scan_time = time(NULL); INFO("Scan started at: %s", ctime(&scan_time)); VVVERBOSE("Using buffer of size %d", data_size); if (data == NULL) { ERROR("Failed to allocate data buffer, errno=%d: %s", errno, strerror(errno)); result = 1; goto Exit; } uint64_t offset; const uint64_t disk_size_bytes = disk->num_bytes; const uint64_t latency_stride = calc_latency_stride(disk); VVERBOSE("latency stride is %"PRIu64, latency_stride); state.latency_bucket = 0; state.latency_stride = latency_stride; state.latency_count = 0; state.latency = malloc(sizeof(uint32_t) * latency_stride); state.data = data; scan_order = calc_scan_order(disk, mode, latency_stride, data_size); if (!scan_order) { result = 1; ERROR("Failed to generate scan order"); goto Exit; } verbose_extra_newline = 1; for (offset = 0; disk->run && offset < disk_size_bytes; offset += latency_stride * disk->sector_size) { VERBOSE("Scanning stride starting at %"PRIu64" done %"PRIu64"%%", offset, offset*100/disk_size_bytes); progress_calc(disk, &state, 0); latency_bucket_prepare(disk, &state, offset); if (!disk_scan_latency_stride(disk, &state, offset, data_size, scan_order)) break; latency_bucket_finish(disk, &state, offset + latency_stride * disk->sector_size); if (disk->is_ata) disk_ata_monitor(disk); else disk_scsi_monitor(disk); } verbose_extra_newline = 0; if (!disk->run) { INFO("Disk scan interrupted"); disk->conclusion = CONCLUSION_ABORTED; } else { disk->conclusion = conclusion_calc(disk); } report_scan_done(disk); Exit: clock_gettime(CLOCK_MONOTONIC, &ts_end); set_realtime(false); free(scan_order); free_buffer(data, data_size); free(state.latency); disk->run = 0; scan_time = time(NULL); INFO("Scan ended at: %s", ctime(&scan_time)); INFO("Scan took %d second", (int)(ts_end.tv_sec - ts_start.tv_sec)); return result; }
void *zenScheduledExecutionThread(void *arglist){ // Hand-off the task description shared_ptr<ZenScheduleTask> *task_ptr = (shared_ptr<ZenScheduleTask> *)arglist; shared_ptr<ZenScheduleTask> task = *task_ptr; delete task_ptr; // moved until end for speediness //task->heartbeat(); if(VERBOSE_SCHEDULER) mprintf("Scheduled thread spawned %p", task.get()); // Unpack the task description boost::function<void *()> functor = task->getFunctor(); int ntimes = task->getNTimes(); MWTime initial_delay_us = task->getInitialDelayUS(); MWTime repeat_interval_us = task->getRepeatIntervalUS(); if(VERBOSE_SCHEDULER) mprintf(" ****** repeat_interval_us = %lu %p", (unsigned long)repeat_interval_us, task.get()); MWTime start_time_us = task->getStartTimeUS(); MissedExecutionBehavior behavior = task->getMissedExecutionBehavior(); int priority = task->getPriority(); MWTime warning_slop_us = task->getWarningSlopUS(); int fail_slop_us = task->getFailureSlopUS(); MWTime computation_time_us = task->getComputationTimeUS(); MWTime next_us; long ndone = 0; // Go realtime, if requested if(VERBOSE_SCHEDULER) mprintf("Computation time = %lld", computation_time_us); if(computation_time_us > 0LL){ //#if (defined(__ppc__) && defined(__APPLE__)) //mprintf("%d", get_bus_speed); #ifndef LOW_PRIORITY_MODE set_realtime(((double)get_bus_speed() * (double)repeat_interval_us) / 1000000.0, ((double)get_bus_speed() * (double)computation_time_us) / 1000000.0, ((double)get_bus_speed() * (double)repeat_interval_us) / 1000000.0); #endif //#endif } else { #if REALTIME_SCHEDULER #ifndef LOW_PRIORITY_MODE int didit = set_realtime(priority); if(didit){ //fprintf(stderr, "Scheduler went realtime. Rock on.\n"); //fflush(stderr); } else { fprintf(stderr,"Scheduler didn't go realtime. Bummer.\n"); fflush(stderr); } #endif #endif } MWTime now_us = task->getScheduler()->getClock()->getCurrentTimeUS(); //cerr << "Startup latency: " << now_us - start_time_us << endl; MWTime time_to_first_shot = (start_time_us + initial_delay_us) - now_us; // Sleep if there is an initial delay if(time_to_first_shot > 0){ task->getScheduler()->getClock()->sleepUS(time_to_first_shot); } // Compute the next scheduled execution time next_us = start_time_us + initial_delay_us + repeat_interval_us; if(VERBOSE_SCHEDULER) mprintf("Scheduled thread entering main loop (%ld done, %d total) %p", ndone, ntimes, task.get()); while(task->isActive() && (ntimes == M_REPEAT_INDEFINITELY || ndone < ntimes)){ //task->heartbeat(); // ********************* // Execute the payload // ********************* if(VERBOSE_SCHEDULER){ mprintf("Scheduled function called " "(main loop, %ld done / %d total) %p", ndone, ntimes, task.get()); } now_us = task->getScheduler()->getClock()->getCurrentTimeUS(); functor(); if(VERBOSE_SCHEDULER){ mprintf("Scheduled function returned " "(main loop) %p", task.get()); } if(fail_slop_us > (MWTime)0 && now_us - next_us > fail_slop_us){ if(!SILENCE_SCHEDULE_WARNINGS){ merror(M_SCHEDULER_MESSAGE_DOMAIN, "Scheduled task (%s) not on time (off by %lld; task = %p; priority= %d)", task->getDescription().c_str(), now_us - next_us, task.get(), task->getPriority()); } } else if(warning_slop_us > (MWTime)0 && now_us - next_us > warning_slop_us){ if (!SILENCE_SCHEDULE_WARNINGS) { mwarning(M_SCHEDULER_MESSAGE_DOMAIN, "Scheduled task (%s) not on time (off by %lld; task = %p; priority=%d)", task->getDescription().c_str(), now_us - next_us, task.get(), task->getPriority()); } } // one closer to being done... ndone++; // communicate back with the task object task->setNDone(ndone); if(ntimes != M_REPEAT_INDEFINITELY && ndone >= ntimes){ if(VERBOSE_SCHEDULER) mprintf("Scheduled task has completed %ld executions, quitting %p", ndone, task.get()); break; } if(!task->isActive()){ if(VERBOSE_SCHEDULER) mprintf("Scheduled execution deactivated (2) %p", task.get()); break; } // this is when the next one should happen next_us = start_time_us + initial_delay_us + (ndone)*repeat_interval_us; now_us = task->getScheduler()->getClock()->getCurrentTimeUS(); // are we going too slow? // if (warned) mprintf("DROP decision values: now: %d next: %d now-next: %d ms repeat interval %d ms", // (long)(now_us/1000), (long)(next_us/1000), (long)((now_us - next_us)/1000), (long)(repeat_interval_us/1000)); // JJD change Jan 30, 2007. // if when the NEXT one should happen is already more than the repeat_interval behind, then we are already too late! // This is partly how we can get into the state with a bunch of warnings, but no correction by dropping. // If warnings are less than this, then it IS proper behavior to keep spitting out the warnings -- it is up to the person scheduling // things to set the warning level appropriately (i.e. greater than the repeat interval plus some slop to deal with delays inside this routine). //if((now_us - next_us) > (repeat_interval_us + warning_slop_us)) { // DDC old test if((now_us - next_us) > (repeat_interval_us)) { // JJD new test Jan 30, 2007 //if (now_us > next_us) { // DDC Feb 12, 3007 if(VERBOSE_SCHEDULER){ mprintf("Thread not keeping up (off by %ld usec: now = %lu, next = %lu repeat = %lu; priority = %d) %p", (long)(now_us - next_us), (unsigned long)now_us, (unsigned long)next_us, (unsigned long)repeat_interval_us, priority, task.get()); } switch(behavior){ case M_MISSED_EXECUTION_DROP: if(repeat_interval_us){ if(VERBOSE_SCHEDULER) mprintf("Dropping (ndone was: %ld) %p", ndone, task.get()); ndone += 0 + (int)((now_us - next_us) / repeat_interval_us); //mprintf("((now_us - next_us) / repeat_interval_us) = %lld", ((now_us - next_us) / repeat_interval_us)); // move on if(warning_slop_us > (MWTime)0){ if (!SILENCE_SCHEDULE_WARNINGS){ mwarning(M_SCHEDULER_MESSAGE_DOMAIN, "Scheduled task (%s) falling behind, dropping %d " "scheduled executions " "(priority = %d, interval = %lld, task = %p)", task->getDescription().c_str(), 1 + (int)((now_us - next_us) / repeat_interval_us), priority, repeat_interval_us, task.get()); //lastWarnTimeUS = now_us; if(task.get() == NULL){ merror(M_SCHEDULER_MESSAGE_DOMAIN, "NULL task: something is very wrong"); } } } } break; case M_MISSED_EXECUTION_CATCH_UP: // go go go.... continue; case M_MISSED_EXECUTION_FAIL: merror(M_SCHEDULER_MESSAGE_DOMAIN, "Scheduled execution failed to keep up"); // TODO: put on the brakes break; } } next_us = start_time_us + initial_delay_us + ((MWTime)(ndone))*repeat_interval_us; if((next_us - now_us) > 0){ if(VERBOSE_SCHEDULER) mprintf("Scheduled thread sleeping... (2: %lld) %p", (next_us - now_us), task.get()); task->getScheduler()->getClock()->sleepUS(next_us - now_us); } } task->getScheduler()->removeTask(task->getNodeID()); if(VERBOSE_SCHEDULER) mprintf("Scheduled thread ending... %p", task.get()); return 0; }