예제 #1
0
파일: freq-step.c 프로젝트: mdamt/linux
static double get_sample(struct sample *sample)
{
	double delay, mindelay = 0.0;
	struct timespec ts1, ts2, ts3;
	int i;

	for (i = 0; i < SAMPLE_READINGS; i++) {
		clock_gettime(CLOCK_MONOTONIC_RAW, &ts1);
		clock_gettime(CLOCK_MONOTONIC, &ts2);
		clock_gettime(CLOCK_MONOTONIC_RAW, &ts3);

		ts1.tv_sec -= mono_raw_base;
		ts2.tv_sec -= mono_base;
		ts3.tv_sec -= mono_raw_base;

		delay = diff_timespec(&ts3, &ts1);
		if (delay <= 1e-9) {
			i--;
			continue;
		}

		if (!i || delay < mindelay) {
			sample->offset = diff_timespec(&ts2, &ts1);
			sample->offset -= delay / 2.0;
			sample->time = ts1.tv_sec + ts1.tv_nsec / 1e9;
			mindelay = delay;
		}
	}

	return mindelay;
}
예제 #2
0
파일: raw_skew.c 프로젝트: 020gzh/linux
int main(int argv, char **argc)
{
	struct timespec mon, raw, start, end;
	long long delta1, delta2, interval, eppm, ppm;
	struct timex tx1, tx2;

	setbuf(stdout, NULL);

	if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
		printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
		return -1;
	}

	tx1.modes = 0;
	adjtimex(&tx1);
	get_monotonic_and_raw(&mon, &raw);
	start = mon;
	delta1 = diff_timespec(mon, raw);

	if (tx1.offset)
		printf("WARNING: ADJ_OFFSET in progress, this will cause inaccurate results\n");

	printf("Estimating clock drift: ");
	sleep(120);

	get_monotonic_and_raw(&mon, &raw);
	end = mon;
	tx2.modes = 0;
	adjtimex(&tx2);
	delta2 = diff_timespec(mon, raw);

	interval = diff_timespec(start, end);

	/* calculate measured ppm between MONOTONIC and MONOTONIC_RAW */
	eppm = ((delta2-delta1)*NSEC_PER_SEC)/interval;
	eppm = -eppm;
	printf("%lld.%i(est)", eppm/1000, abs((int)(eppm%1000)));

	/* Avg the two actual freq samples adjtimex gave us */
	ppm = (tx1.freq + tx2.freq) * 1000 / 2;
	ppm = (long long)tx1.freq * 1000;
	ppm = shift_right(ppm, 16);
	printf(" %lld.%i(act)", ppm/1000, abs((int)(ppm%1000)));

	if (llabs(eppm - ppm) > 1000) {
		printf("	[FAILED]\n");
		return ksft_exit_fail();
	}
	printf("	[OK]\n");
	return  ksft_exit_pass();
}
예제 #3
0
int main()
{
	int	ret;
#ifdef _POSIX_CPUTIME
	struct timespec     ts1, ts2, ts_diff;
	clockid_t	clock_cpu;
	if ((ret = clock_getcpuclockid(0, &clock_cpu)) != 0) { 
		return EXIT_FAILURE;
	}
	clock_gettime(clock_cpu, &ts1);
#endif
	int i;
	double x, step, sum = 0.0;
	step = 1.0/(double) num_steps;
	for (i=0; i<num_steps; i++) {
		x = (i+0.5) * step;
		sum += 4.0/(1.0 + x*x);
	}
	printf("pi = %.8f (sum = %.8f)\n", step*sum, sum);
	sleep(1);
#ifdef _POSIX_CPUTIME
	clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts2);
	ts_diff = diff_timespec(ts1, ts2);
	printf("elapsed cpu time = %ld.%09ld\n", ts_diff.tv_sec, ts_diff.tv_nsec);
#endif
	return EXIT_SUCCESS;
}
예제 #4
0
파일: profile.cpp 프로젝트: artemg/toolzlib
void FastProfiler::stop() {
    clock_gettime(CLOCK_MONOTONIC_RAW, &t2);
    double res = diff_timespec(&t1, &t2);
    data_[cur_index].time += res;
    data_[cur_index].counter +=1;
    started = false;
}
void char_ready_handler(int signo, siginfo_t* siginfo, void *dummy) {
    char answer;
	Tmeas *temp = (Tmeas*)(((struct aiocb*)siginfo->si_value.sival_ptr)->aio_buf);
    
	int ptemp = ((struct aiocb*)siginfo->si_value.sival_ptr) - &aiocb[0];
	int intemp = (int)(((struct aiocb*)siginfo->si_value.sival_ptr)->aio_fildes);
	if (aio_error(((struct aiocb*)siginfo->si_value.sival_ptr)) != 0) 
		printf("ERROR\n");
	
	if( signo == SIGIO ) {
       /* printf("i/o complete signal is received. Char was %d \n",
                 *((struct Tmeas*)(((struct aiocb*)siginfo->si_value.sival_ptr)->aio_buf)))->value;
        //start a new read*/
		

			

		clock_gettime(CLOCK_REALTIME, &current_time);
		lag = diff_timespec(&current_time, &temp->moment );

		 printf("# Measurement value of %d sensor is %d, it took %d\n",
                  ptemp+1, temp->value, lag.tv_nsec);

		increment_timespec(&total_lag, &lag);
			
				 
		if (aio_return(((struct aiocb*)siginfo->si_value.sival_ptr)) > 0 )		 
			aio_read(((struct aiocb*)siginfo->si_value.sival_ptr));
		else
			printf("-------------EOF in sensor #%d, %d remaining--------------------\n", ptemp+1, --NSENS);
    }
}
예제 #6
0
resultado Experimento(int V, double p) {
	int i, j;
	struct timespec M_dfs_ini, M_dfs_fim, M_bfs_ini, M_bfs_fim;
	struct timespec L_dfs_ini, L_dfs_fim, L_bfs_ini, L_bfs_fim;
	resultado ans;

	Digraph G = DIGRAPHinit(V);
	
	f (i, 0, V)
		f (j, 0, V)
			if (i != j && rand() <  p*RAND_MAX)
				DIGRAPHinsertA (G, i, j);

	clock_gettime(CLOCK_REALTIME, &M_dfs_ini);
	f (i, 0, 8)
		DIGRAPHdfsM (G);
	clock_gettime(CLOCK_REALTIME, &M_dfs_fim);
	ans.m_dfs = diff_timespec(M_dfs_fim, M_dfs_ini); 
	
	clock_gettime(CLOCK_REALTIME, &L_dfs_ini);
	f (i, 0, 8)
		DIGRAPHdfsL (G);
	clock_gettime(CLOCK_REALTIME, &L_dfs_fim);
	ans.l_dfs = diff_timespec(L_dfs_fim, L_dfs_ini);
	
	clock_gettime(CLOCK_REALTIME, &M_bfs_ini);
	f (i, 0, V)
		f(j, 0, 8)
			DIGRAPHbfsM(G, i);
	clock_gettime(CLOCK_REALTIME, &M_bfs_fim);
	ans.m_bfs = diff_timespec(M_bfs_fim, M_bfs_ini);
	
	clock_gettime(CLOCK_REALTIME, &L_bfs_ini);
	f (i, 0, V)
		f(j, 0, 8)
			DIGRAPHbfsL(G, i);
	clock_gettime(CLOCK_REALTIME, &L_bfs_fim);
	ans.l_bfs = diff_timespec(L_bfs_fim, L_bfs_ini);
	
	ans.arcos = G->A;
	
	DIGRAPHfree(G);
	
	return ans;
}
예제 #7
0
static void process_interval(void)
{
	struct timespec ts, rs;

	read_counters(false);

	clock_gettime(CLOCK_MONOTONIC, &ts);
	diff_timespec(&rs, &ts, &ref_time);

	print_counters(&rs, 0, NULL);
}
예제 #8
0
파일: profile.cpp 프로젝트: artemg/toolzlib
void end_profile_print(){
    clock_gettime(CLOCK_MONOTONIC_RAW, &t2);
    double res = diff_timespec(&t1, &t2);
    LOG(L_DEBUG, NULL, "Elapsed time: %fs.", res);
    
    char buf[20];
    time_t t;
    struct tm *tm;
    time(&t);
    tm = localtime(&t);
    strftime(buf, 20, "%F %T", tm);
    LOG(L_DEBUG, NULL, " (%s)\n", buf);
}
예제 #9
0
void
measure_clock_gettime(void) {
	struct timespec ta;
	struct timespec tb;
	
	int32_t granularity;
	int cnt = 0;
	
	clock_gettime(CLOCK_REALTIME, &ta);
	tb = ta;
	while(tb.tv_nsec == ta.tv_nsec) {
		clock_gettime(CLOCK_REALTIME, &ta);
		cnt++;
	}
	
	granularity = diff_timespec(&tb, &ta);
	
	printf("\tclock_gettime: %s%d ns\r\n", cnt == 1 ? "<=" : "", granularity);
}
예제 #10
0
파일: profile.cpp 프로젝트: artemg/toolzlib
void CProfilerTask::stop(){
    if(profile_enabled) {
        stat_it it;

        clock_gettime(CLOCK_MONOTONIC_RAW, &t_e);
        const double time_el = diff_timespec(&t, &t_e);
        it = stat.find(name);
        if( it != stat.end() ){
            it->second.counter++;
            it->second.time += time_el;
        } else {
            Eprofile x;
            x.counter = 1;
            x.time = time_el;
            stat[name] = x;
        }
        state_stoped = true;
    }
}
예제 #11
0
파일: raw_skew.c 프로젝트: 020gzh/linux
void get_monotonic_and_raw(struct timespec *mon, struct timespec *raw)
{
	struct timespec start, mid, end;
	long long diff = 0, tmp;
	int i;

	for (i = 0; i < 3; i++) {
		long long newdiff;

		clock_gettime(CLOCK_MONOTONIC, &start);
		clock_gettime(CLOCK_MONOTONIC_RAW, &mid);
		clock_gettime(CLOCK_MONOTONIC, &end);

		newdiff = diff_timespec(start, end);
		if (diff == 0 || newdiff < diff) {
			diff = newdiff;
			*raw = mid;
			tmp = (ts_to_nsec(start) + ts_to_nsec(end))/2;
			*mon = nsec_to_ts(tmp);
		}
	}
}
int main(void) {
	int retval = -1;
	fd_set rfds;
	int fdmax = 0;
	int n = 0;
	int i = 0;
	int k = 0;
	struct timespec sumOfDelays;
	struct timespec delay;
	struct timespec timeNow;
	int sensorDescriptors[10];
	Tmeas measurement;
	int eofArray[10];
	int eofCount = 0;
	int counter = 0;
	
	// Initialize struct timespec variables
	memset(&sumOfDelays, 0, sizeof(sumOfDelays));
	for (i = 0; i < 10; i++) {
		eofArray[i] = 1;
	}
	
	// Specify 5 values per sensor
	if (StartSimulator(sensorDescriptors, 5) < 0) {
		fprintf(stderr, "Error: Cannot initialize sensor simulator\n");
		exit(EXIT_FAILURE);
	}
	fdmax = findMaxFileDescriptor(sensorDescriptors, 10);
		
	do {
		FD_ZERO(&rfds);
		for (i = 0; i < 10; i++) {
			if (eofArray[i] != 0) 	// Add file descriptors that haven't reached EOF to the set 
				FD_SET(sensorDescriptors[i], &rfds);
		}
		n = select(fdmax+1, &rfds, NULL, NULL, NULL);
		if (n > 0) {
			for (i = 0; i < 10; i++) {
				if (FD_ISSET(sensorDescriptors[i], &rfds)) {
					k++;
					/*
					 *	Sensor descriptor is ready, but it is also ready on EOF
					 *	So check for EOF condition, if EOF, then don't read it
					 */
					if (eofArray[i] == 0) 	// 0 indicates EOF condition
						break;
					else {
						retval = read(sensorDescriptors[i], &measurement, sizeof(Tmeas));
						
						if (retval == 0) {
							eofArray[i] = 0;
							eofCount++;
						} else {
							counter++;
						}
						if (clock_gettime(CLOCK_REALTIME, &timeNow) == -1) {
							perror("clock gettime");
							exit(EXIT_FAILURE);
						}
						delay = diff_timespec(&measurement.moment, &timeNow);
						increment_timespec(&sumOfDelays, &delay);
					}
					
				}
				// All ready file descriptors have been processed
				// So it's not necessary for looping to the end of loop
				if (k == n)
					break;
			}
			k = 0;
		}
	} while (eofCount != 10);
	
	// Display the total delay
	printf("Sum of delay %ld s %ld ns\n", sumOfDelays.tv_sec, sumOfDelays.tv_nsec);
	printf("counter %d\n", counter);

	return EXIT_SUCCESS;
}
예제 #13
0
파일: profile.cpp 프로젝트: artemg/toolzlib
double end_profile(timespec *t1){
    timespec t2;
    clock_gettime(CLOCK_MONOTONIC_RAW, &t2);
    return diff_timespec(t1, &t2);
}
예제 #14
0
파일: profile.cpp 프로젝트: artemg/toolzlib
double end_profile(){
    clock_gettime(CLOCK_MONOTONIC_RAW, &t2);
    return diff_timespec(&t1, &t2);
}
예제 #15
0
int main(int argc, char **argv){
    char addr[32];

    if (argc < 8){
	printf("not enough input args\n");
	printf("usage: progname <cmd> <nbthreads> <server address> <nbquerys>\n");
	printf("    cmd            - 1 for query, 2 for file submission\n");
	printf("    nbthreads      - number of driver threads\n");
	printf("    arr            - ave inter-arrival time (millisecs)\n");
	printf("    server address - address of auscoutd,  e.g. \"localhost\"\n");
	printf("    sink address   - e.g. tcp://localhost:port\n");
	printf("    port           - port of the auscoutd server, e.g. 4005\n");
	printf("    nbquerys       - total number queries to submit\n");
	return 0;
    }

    /*args [cmd | nbthreads | arr | server address | nbquerys ] */
    const int cmd = (uint8_t)atoi(argv[1]);
    const int nbthreads = atoi(argv[2]);
    Arr = atoi(argv[3]);
    char *auscoutd_address = argv[4];
    char *ausink_address = argv[5];
    const int port = atoi(argv[6]);
    const int nbquerys = atoi(argv[7]);

    snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, port);

    void *ctx = zmq_init(1);
    assert(ctx);

    unsigned int nb_files_per_thread = nbquerys/nbthreads;
    unsigned int nb_files_last_thread = nbquerys%nbthreads;

    fprintf(stdout,"\nfiles per thread %u\n"   , nb_files_per_thread);
    fprintf(stdout, "files in last thread %u\n", nb_files_last_thread);
    fprintf(stdout, "nb threads %d\n\n"        , nbthreads);

    uint32_t **hashes = (uint32_t**)malloc(nbquerys*sizeof(uint32_t*));
    uint32_t *ptrNbframes = (uint32_t*)malloc(nbquerys*sizeof(uint32_t));;

    /* socket to send init signal to ausink */
    void *prepskt = socket_connect(ctx, ZMQ_PAIR, ausink_address);
    assert(prepskt);

    struct timespec seed;
    clock_gettime(CLOCK_REALTIME, &seed);
    srand(seed.tv_nsec);

    struct timespec start_ts, end_ts;
    
    AudioMetaData phonymdata;
    init_mdata(&phonymdata);
    phonymdata.composer = "composer";
    phonymdata.title2 = "title";
    phonymdata.tpe1 = "performer";
    phonymdata.date = "date";
    phonymdata.year = 2010;
    phonymdata.album = "album";
    phonymdata.genre = "genre";
    phonymdata.duration = 1000000;
    phonymdata.partofset = 1;
    
    char mdata_inlinestr[512];
    metadata_to_inlinestr(&phonymdata, mdata_inlinestr, 512);
   
    int i, err;
    if (cmd == 1 || cmd == 2){ /* querys */

	for (i = 0;i < nbquerys;i++){
	    uint32_t nbframes = rand()%12500;
	    uint32_t *hash    = (uint32_t*)malloc(nbframes*sizeof(uint32_t));
	    assert(hash);

	    hashes[i] = hash;
	    ptrNbframes[i] = nbframes;
	}

	/* start of send time*/
	clock_gettime(CLOCK_MONOTONIC, &start_ts);

	/* send init signal with number of files sending to ausc sink */
	uint32_t nb = nbquerys;
	send_msg_vsm(prepskt, &nb, sizeof(uint32_t));

       	fprintf(stdout, "send to auscoutd\n");
	ThrParam *thrparam;
	pthread_t *thrs = (pthread_t*)malloc((nbthreads+1)*sizeof(pthread_t));
	assert(thrs);
	for (i=0;i<nbthreads;i++){
	    thrparam = (ThrParam*)malloc(sizeof(ThrParam));
	    assert(thrparam);
	    thrparam->ctx = ctx;
	    thrparam->cmd = cmd;
	    thrparam->thrn = i;
	    thrparam->mdatastr = mdata_inlinestr;
	    thrparam->nbfiles = nb_files_per_thread;
	    thrparam->address = addr;
	    thrparam->hashes = hashes + i*nb_files_per_thread;
	    thrparam->nbframes = ptrNbframes + i*nb_files_per_thread;
	    assert(pthread_create(&thrs[i], NULL, query_thread, thrparam) == 0);
	}
	
	if (nb_files_last_thread){
	    thrparam = (ThrParam*)malloc(sizeof(ThrParam));
	    assert(thrparam);
	    thrparam->ctx = ctx;
	    thrparam->cmd = cmd;
	    thrparam->thrn = nbthreads;
	    thrparam->mdatastr = mdata_inlinestr;
	    thrparam->nbfiles = nb_files_last_thread;
	    thrparam->address = addr;
	    thrparam->hashes = hashes + nbthreads*nb_files_per_thread;
	    thrparam->nbframes = ptrNbframes + nbthreads*nb_files_per_thread;
	    assert(pthread_create(&thrs[nbthreads], NULL, query_thread, thrparam) == 0);
	}

	/* wait for threads */
	unsigned long long sum_ull, *ptr_ave = NULL;
	for (i=0;i < nbthreads;i++){
	    pthread_join(thrs[i], (void**)&ptr_ave);
	    sum_ull += *ptr_ave;
	}
	if (nb_files_last_thread){
	    pthread_join(thrs[nbthreads], (void**)&ptr_ave);
	    sum_ull += *ptr_ave;
	}

	/* end of sending */
	clock_gettime(CLOCK_MONOTONIC, &end_ts);

	struct timespec total_ts = diff_timespec(start_ts, end_ts);
	unsigned long long  total = 1000000000*total_ts.tv_sec + total_ts.tv_nsec;
	float total_secs = (float)total/1000000000.0f;
	float ave_latency  = (float)sum_ull/(float)nbquerys/1000000000.0f;
	float rate = (float)nbquerys/total_secs;
	fprintf(stdout,"ave latency, %f secs\n", ave_latency);
	fprintf(stdout,"rate: %f querys/sec\n", rate);
	fprintf(stdout,"total time, %f secs\n", total_secs);

    } else {
	fprintf(stdout,"unrecognized cmd, %u\n", cmd);
    }

    zmq_close(prepskt);
    zmq_term(ctx);
    return 0;
}
예제 #16
0
void* query_thread(void *arg){
    ThrParam *thrparam = (ThrParam*)arg;
    void *ctx = thrparam->ctx;
    char *mdatastr = thrparam->mdatastr;
    uint32_t **hashes = thrparam->hashes;
    uint32_t *pnbframes = thrparam->nbframes;
    unsigned int nbfiles = thrparam->nbfiles;
    uint8_t thrn = thrparam->thrn;
    uint8_t cmd = thrparam->cmd;

    void *skt = zmq_socket(ctx, ZMQ_REQ);
    assert(skt);
    fprintf(stdout,"thrn%d: connect to %s\n", thrn, thrparam->address);
    assert(zmq_connect(skt, thrparam->address)==0);

    unsigned int i,j;

    void *data;
    int64_t more;
    size_t msg_size, more_size=sizeof(int64_t);
    struct timespec t1_ts, t2_ts, diff_ts;
    unsigned long long latency, sum_ull = 0ULL;

    if (cmd == 1){ /* queries */
	for (i=0;i<nbfiles;i++){
	    clock_gettime(CLOCK_MONOTONIC, &t1_ts);

	    sendmore_msg_vsm(skt, &cmd, sizeof(uint8_t));
	    uint32_t snbframes = hosttonet32(pnbframes[i]);
	    sendmore_msg_vsm(skt, &snbframes, sizeof(uint32_t));
	    send_msg_data(skt, hashes[i], pnbframes[i]*sizeof(uint32_t), free_fn, NULL);
	    recieve_msg(skt, &msg_size, &more, &more_size, &data);
	    
	    clock_gettime(CLOCK_MONOTONIC, &t2_ts);
	    diff_ts = diff_timespec(t1_ts, t2_ts);
	    latency = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
	    sum_ull += latency;

	    fprintf(stdout,"thrd%d: query %u frames, recv:\"%s\" in %llu nsecs\n",\
                                                       thrn,pnbframes[i],(char*)data, latency);
	    free(data);

	    /* simulate interarrival */ 
	    unsigned int pause = Arr; /* = next_arrival(Arr);*/
	    usleep(1000*pause);
	}
    } else if (cmd == 2){ /* submissions */
	for (i=0;i<nbfiles;i++){
	    clock_gettime(CLOCK_MONOTONIC, &t1_ts);

	    sendmore_msg_vsm(skt, &cmd, sizeof(uint8_t));
	    uint32_t snbframes = hosttonet32(pnbframes[i]);
	    sendmore_msg_vsm(skt, &snbframes, sizeof(uint32_t));
	    sendmore_msg_data(skt, hashes[i], pnbframes[i]*sizeof(uint32_t), free_fn, NULL);
	    send_msg_data(skt, mdatastr, strlen(mdatastr)+1, NULL, NULL);

	    recieve_msg(skt, &msg_size, &more, &more_size, &data);
	    assert(msg_size == sizeof(uint32_t));
	    uint32_t uid;
	    memcpy(&uid, data, sizeof(uint32_t));
	    uid = nettohost32(uid);

	    clock_gettime(CLOCK_MONOTONIC, &t2_ts);

	    diff_ts = diff_timespec(t1_ts, t2_ts);
	    latency = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
	    sum_ull += latency;

	    fprintf(stdout,"thr%d: submit %u frames, recv %u=uid in %llu nsecs\n",\
                                                              thrn, pnbframes[i], uid, latency);

	    /* simulate interarrival */
	    unsigned int pause = Arr; /*next_arrival(Arr);*/
	    usleep(1000*pause);

	    free(data);
	}
    }

    free(thrparam);
    zmq_close(skt);

    /* return the sum of latency's */ 
    void *ptr = malloc(sizeof(unsigned long long));
    assert(ptr);
    memcpy(ptr, &sum_ull, sizeof(unsigned long long));
    pthread_exit(ptr);
}
예제 #17
0
파일: test_h.c 프로젝트: rrs42/gittest
int main( int argc, char ** argv )
{
	struct timespec start, end;
	char buffer[32] = {0};
	const int vals = 10000000;

	unsigned long *val = new unsigned long[vals];

	long int duration;

	long test_len;
	test_len = to_dec_c( 0xDEADBEEFDEADBEEF, buffer, 32 );
	buffer[test_len] = 0x00;
	printf( "Test 1 0xDEADBEEFDEADBEEF = %s\n", buffer );

	test_len = to_dec( 0xDEADBEEFDEADBEEF, buffer, 32 );
	buffer[test_len] = 0x00;
	printf( "Test 2 0xDEADBEEFDEADBEEF = %s\n", buffer );

	test_len = to_dec( 0xFFFFFFFFFFFFFFFF, buffer, 32 );
	buffer[test_len] = 0x00;
	printf( "Test 3 0xFFFFFFFFFFFFFFEF = %s\n", buffer );

	test_len = to_dec_c( 0xFFFFFFFFFFFFFFFF, buffer, 32 );
	buffer[test_len] = 0x00;
	printf( "Test 4 0xFFFFFFFFFFFFFFEF = %s\n", buffer );

	test_len = to_dec( (unsigned long)0xFFFFFFFF, buffer, 32 );
	buffer[test_len] = 0x00;
	printf( "Test 5 0xFFFFFFFF = %s\n", buffer );

	test_len = to_dec_c( (unsigned long)0xFFFFFFFF, buffer, 32 );
	buffer[test_len] = 0x00;
	printf( "Test 6 0xFFFFFFFF = %s\n", buffer );

	printf( "Array setup..." ); fflush(NULL);

	for( int x = 0; x < vals; x++ ) {
		val[x] = x;
	}

	printf( "done\n" );

	current_utc_time( &start );

	for( int x = 0; x < vals ; x++ ) {
		long len = to_dec( val[x], buffer, 32 );
	}

	current_utc_time( &end );

	duration = diff_timespec( start, end );

	printf( "to_dec, source is array\n" );
	printf( "Completed in %8.8f sec (%ld nsec avg)\n\n", (double)duration/nsec_per_sec, duration/vals );


	current_utc_time( &start );

	for( int x = 0; x < vals ; x++ ) {
		long len = to_dec( x, buffer, 32 );
	}

	current_utc_time( &end );

	duration = diff_timespec( start, end );

	printf( "to_dec, source is calculated\n" );
	printf( "Completed in %8.8f sec (%ld nsec avg)\n\n", (double)duration/(double)nsec_per_sec, duration/vals );

	current_utc_time( &start );

	for( int x = 0; x < vals ; x++ ) {
		long len = to_dec_c( val[x], buffer, 32 );
	}

	current_utc_time( &end );

	duration = diff_timespec( start, end );

	printf( "to_dec_c, source is array\n" );
	printf( "Completed in %8.8f sec (%ld nsec avg)\n\n", (double)duration/(double)nsec_per_sec, duration/vals );


	current_utc_time( &start );

	for( int x = 0; x < vals ; x++ ) {
		long len = to_dec_c( x, buffer, 32 );
	}


	current_utc_time( &end );
	duration = diff_timespec( start, end );

	printf( "to_dec_c, source is calculated\n" );
	printf( "Completed in %8.8f sec (%ld nsec avg)\n\n", (double)duration/(double)nsec_per_sec, duration/vals );


	return 0;
}
예제 #18
0
int main(int argc, char **argv){
    char addr[32];
    if (argc < 4){
	fprintf(stdout,"not enough args\n");
	fprintf(stdout,"usage: prog <auscoutd address>  <port> <port>\n");
	fprintf(stdout,"address - mock auscoud server address, e.g. \"localhost\"\n");
	fprintf(stdout,"port    - mock auscoutd server port e.g. 4005\n");
	fprintf(stdout,"port    - port to recieve init from auscout driver, e.g. 4009\n");
	return 0;
    }

    /* progname <auscoutd address> <auscoutd port> <driver port>*/
    const char *auscoutd_address = argv[1];
    const int port = atoi(argv[2]);
    const int driver_port = atoi(argv[3]);

    int subscr_port  = port + 2;
    int result_port = port + 3;
    int table_port  = port + 1;

    snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, table_port);
    fprintf(stdout,"register as table with %s\n", addr);

    void *ctx = zmq_init(1);
    assert(ctx);
    assert(register_table(ctx, addr) == 0);

    /* skt to recieve number of files to be sent from auscout driver program */
    snprintf(addr, 32, "tcp://*:%d", driver_port);
    void *prepskt = socket_bind(ctx, ZMQ_PAIR, addr);
    assert(prepskt);

    snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, subscr_port);
    void *subscr_skt = socket_connect(ctx, ZMQ_SUB, addr);
    assert(subscr_skt);
    assert(zmq_setsockopt(subscr_skt, ZMQ_SUBSCRIBE, "phash.", 6) == 0);

    snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, result_port);
    void *result_skt = socket_connect(ctx, ZMQ_REQ, addr);
    assert(result_skt);

    struct timespec seed_ts;
    clock_gettime(CLOCK_REALTIME, &seed_ts);
    srand(seed_ts.tv_nsec);

    uint8_t cmd, thrdnum, tblnum;
    struct timespec start_ts, end_ts, diff_ts;
    uint32_t uid, nbframes, count = 0, nbquerys;
    void *data;
    int64_t more;
    size_t msg_size, more_size = sizeof(int64_t);
    float cs = 0.05555f;
    fprintf(stdout,"\nready to recieve subscription messages from auscoutd ...\n\n");
    while (1){

	recieve_msg(prepskt, &msg_size, &more, &more_size, &data);
	assert(msg_size == sizeof(uint32_t));
	memcpy(&nbquerys, data, sizeof(uint32_t));
	free(data);
	fprintf(stdout,"expecting %d querys\n\n", nbquerys);

	clock_gettime(CLOCK_MONOTONIC, &start_ts);
	count = 0;
	do {
	    /* recieve topic */
	    recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
	    free(data);

	    /* recieve cmd */
	    recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
	    memcpy(&cmd, data, sizeof(uint8_t));
	    free(data);
	
	    recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
	    memcpy(&nbframes, data, sizeof(uint32_t));
	    nbframes = nettohost32(nbframes);
	    free(data);

	    /* recieve hash */
	    recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
	    free(data);

	    recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
	    memcpy(&thrdnum, data, sizeof(uint8_t));
	    free(data);

	    recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
	    memcpy(&uid, data, sizeof(uint32_t));
	    uid = nettohost32(uid);
	    free(data);

	    if (cmd == 1){
		/* recieved lookup */
		uid = 0;  /* send back random integer id*/
		cs =  0.5555;
		fprintf(stdout,"(%d) lookup: %u frames\n",count,nbframes);
		fprintf(stdout,"        reply : thrdnum %u | uid %u | cs %f\n\n",thrdnum,uid,cs);

		uid = hosttonet32(uid);
		cs = hosttonetf(cs);
		sendmore_msg_vsm(result_skt, &thrdnum, sizeof(uint8_t));
		sendmore_msg_vsm(result_skt, &uid, sizeof(uint32_t));
		send_msg_vsm(result_skt, &cs, sizeof(float));
		
		recieve_msg(result_skt, &msg_size, &more, &more_size, &data);
		free(data);
	    } else if (cmd == 2){
		tblnum = thrdnum;
		
		/* recieved submission */
		fprintf(stdout,"(%d) submit: %u frames | %u table\n",count,nbframes,tblnum);
		fprintf(stdout,"         no reply\n\n");
	    }
	    fprintf(stdout,"**************************************\n");


	} while (++count < nbquerys);
	
	clock_gettime(CLOCK_MONOTONIC, &end_ts);
	diff_ts = diff_timespec(start_ts, end_ts);

	unsigned long long total_ull = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
	float total_secs = (float)total_ull/1000000000.0f;
	float rate = (float)nbquerys/total_secs;

	fprintf(stdout,"recieved %d querys in %f secs - %f querys/sec\n",\
                                                            nbquerys, total_secs, rate);

    }

    zmq_close(subscr_skt);
    zmq_close(result_skt);
    zmq_close(prepskt);
    zmq_term(ctx);

    return 0;
}
예제 #19
0
파일: posix.c 프로젝트: CCoder123/nessDB
long long time_diff_ms(struct timespec start, struct timespec end)
{
	return millisec_elapsed(diff_timespec(start, end));
}
예제 #20
0
파일: App.cpp 프로젝트: Laizerox/TheLife
void TheLife::LoadLife() {

    
    struct timespec start;
    struct timespec end;
    struct timespec diff;
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_BEGIN"));
    
    pthread_t main, status;

    //Life Initialization
    sUI->lwin[0].buf[0] = 0x00;
    sUI->lwin[1].buf[0] = 0x00;
    
    // Init NCurses
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_CURSES"));
    initscr();
    start_color();
    use_default_colors();
    //noecho();
    keypad(stdscr, true);

    // Init colors
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_COLOR"));
    init_pair(1, 1, -1);
    init_pair(2, 2, -1);
    init_pair(3, 3, -1);
    init_pair(4, 4, -1);

    // Init UI
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_UI"));
    Interface::Load();
    
    sUI->SetHidden(false, WINDOW_CONSOLE);
    sUI->SetHidden(false, WINDOW_STATUS);    
    
    // Init Player
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_PLAYER"));
    FileHandler::PlayerInit();

    // Init SIGWICH (Console change signal) to SigHandler
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_SIGWINCH"));
    signal(SIGWINCH, TheLife::SigHandler);
    
    // Thread spawning
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_TH_SPAWN"));
    pthread_create(&status, NULL, Thread::Status, NULL);
    pthread_create(&main, NULL, Thread::Run, NULL);
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_TH_ADD"));
    sThread->AddThread(status);
    sThread->AddThread(main);
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_TH_JOIN"));
    pthread_join(status,NULL);
    pthread_join(main, NULL);    
    
    LogHandler::WriteLog(sLanguage->Get("LOG_LOAD_END"));
    clock_gettime(CLOCK_MONOTONIC, &end);
    diff = diff_timespec(start, end);
    Debug("Load took %lld milliseconds\n", millisec_elapsed(diff));
}