Ejemplo n.º 1
0
int test_memory()
{
	int i, j;
	value var, ten = value_set_long(10);
	value container = value_init_nil();

	printf("testing memory\n");
	
	var.type = VALUE_VAR;
	var.core.u_var = "x";
	
	for (i = 1; i < 10000000; i *= 2) {
		container = value_init(VALUE_MPZ);
		size_t start = usec();
		for (j = 0; j < i; ++j) {
			value_add_now(&container, ten);
		}
		
		
		value_clear(&container);
		size_t finish = usec();
		printf("time to do and clear %d elements: %ld usec\n", i, (unsigned long) finish - start);
	}
	
//	size_t time = usec();
//	while (usec() - time < 5000000) ;
	
	return 0;
}
Ejemplo n.º 2
0
int main(int argc, char *argv[])
{
	char fname[200];
	
	FILE *f;
	int bc = strtoul(argv[1], NULL, 0);
	static struct tspoint tp[20000];
	int i;

	snprintf(fname, sizeof(fname), "/sys/kernel/debug/cbmia/tspoints%d", bc);
	f = fopen(fname, "rb");
	fread(tp, sizeof(struct tspoint), 20000, f);
	printf("sizeof(tp) = %zd\n", sizeof(tp));

	printf("bc:%d    rti %18s %18s %18s %18s\n", bc, "strtx", "wrttx", "inttx", "endtx");
	for (i = 0; i < 20000; i++) {
		printf("bc:%u rti:%02u %10u.%06u %s %6u %6u %6u\n",
			bc, tp[i].rti,
			sec(tp[i].start_tx), usec(tp[i].start_tx),
			isotime(tp[i].start_tx),
			usec(tp[i].write_tx - tp[i].start_tx),
			usec(tp[i].int_tx - tp[i].write_tx),
			usec(tp[i].end_tx - tp[i].int_tx));
	}
	return 0;
}
Ejemplo n.º 3
0
int OTime::compare(const OTime& t) const {
	//if t is greater then return -1
	if(usec() < t.usec())
		return -1;
	//if t is less than return 1
	else if(usec() > t.usec())
		return 1;
	//else the two OTimes must be equal so return 0
	return 0;
}
Ejemplo n.º 4
0
// Main execution loop
void 
*runThread(void *thisC64) {
		
	assert(thisC64 != NULL);
	
	C64 *c64 = (C64 *)thisC64;
	c64->debug(1, "Execution thread started\n");
	c64->putMessage(MSG_RUN);
	
    c64->threadStartTime = usec();

    // Configure thread properties...
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
	pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
	pthread_cleanup_push(threadCleanup, thisC64);
	
	// Prepare to run...
	c64->cpu->clearErrorState();
	c64->floppy->cpu->clearErrorState();
	c64->restartTimer();
    
	while (1) {		
		if (!c64->executeOneLine())
			break;		

		if (c64->getRasterline() == 0 && c64->getFrame() % 8 == 0) {

			// Check if thread was requested to terminate
			pthread_testcancel();
		}
	}
	
	pthread_cleanup_pop(1);
	pthread_exit(NULL);	
}
Ejemplo n.º 5
0
void 
C64::synchronizeTiming()
{
    const uint64_t earlyWakeup = 1500000; /* 1.5 milliseconds */
    const uint64_t maxJitter = 1000000000; /* 1 second */

    // Convert usec into kernel unit and sleep
    uint64_t kernelTargetTime = nanos_to_abs(nanoTargetTime);
    int64_t jitter = sleepUntil(kernelTargetTime, earlyWakeup);

    // Update target time
    nanoTargetTime += vic->getFrameDelay();

    // debug(2, "Jitter = %d", jitter);
    if (jitter > maxJitter) {
        
        // The emulator did not keep up with the real time clock. Instead of
        // running behind for a long time, we reset the synchronization timer
        
        debug(2, "Jitter exceeds limit. Restarting synchronization timer.\n"); 
        restartTimer();
    }

#if 0
    // Old sleep
    // determine how long we should wait
    uint64_t timeToSleep = targetTime - usec();
    targetTime += vic->getFrameDelay() / 1000; // OLD
	if (timeToSleep > 0) {
		sleepMicrosec(timeToSleep);
	} else {
		restartTimer();
	}
#endif
}
Ejemplo n.º 6
0
ezio::Time_Value::
operator struct timeval() const
{
  struct timeval tv;
  tv.tv_sec = sec_;
  tv.tv_usec = usec();
  return tv;
}
Ejemplo n.º 7
0
int test_list()
{
	value list = value_init_nil();
	value num = value_set_long(10);
	long i, count;
	size_t start = usec();
	
	for (count = 0; count < 5; ++count) {
		for (i = 0; i < 10000000; ++i) {
			value_cons_now(num, &list);
		}
		value_clear(&list);
	}
	
	size_t finish = usec();
	printf("time to do %ld iterations: %ld\n", i, (long) (finish - start) / count);
	
	return 0;
}
Ejemplo n.º 8
0
  Time* Time::gettimeofday(STATE) {
    struct timeval tv;

    /* don't fill in the 2nd argument here. getting the timezone here
     * this way is not portable and broken anyway.
     */
    ::gettimeofday(&tv, NULL);

    sec( state, Integer::from(state, tv.tv_sec));
    usec(state, Integer::from(state, tv.tv_usec));
    return this;
  }
Ejemplo n.º 9
0
void stress(int pos, int num, int maxsize, int dnum) {
    int i,j,k;
    unsigned char *zl;
    char posstr[2][5] = { "HEAD", "TAIL" };
    long long start;
    for (i = 0; i < maxsize; i+=dnum) {
        zl = ziplistNew();
        for (j = 0; j < i; j++) {
            zl = ziplistPush(zl,(unsigned char*)"quux",4,ZIPLIST_TAIL);
        }

        /* Do num times a push+pop from pos */
        start = usec();
        for (k = 0; k < num; k++) {
            zl = ziplistPush(zl,(unsigned char*)"quux",4,pos);
            zl = ziplistDeleteRange(zl,0,1);
        }
        printf("List size: %8d, bytes: %8d, %dx push+pop (%s): %6lld usec\n",
            i,intrev32ifbe(ZIPLIST_BYTES(zl)),num,posstr[pos],usec()-start);
        zfree(zl);
    }
}
Ejemplo n.º 10
0
Archivo: hwlog.c Proyecto: aosm/X11
void hwMsg(int l, const char *format, ...)
{
  va_list ap;
  va_start(ap, format);

  if (l <= hwlog.level) {
    if (hwIsLogReady()) {
      int t = usec();

      hwLog(l, "%6i:", t - hwlog.timeTemp);
      hwlog.timeTemp = t;
      hwLogv(l, format, ap);
    } else {
      fprintf(stderr, hwlog.prefix);
      vfprintf(stderr, format, ap);
    }
  }

  va_end(ap);
}
Ejemplo n.º 11
0
/** Note that a XSync() was just done on \a dmxScreen with the \a start
 * and \a stop times (from gettimeofday()) and the number of
 * pending-but-not-yet-processed XSync requests.  This routine is called
 * from #dmxDoSync in #dmxsync.c */
void dmxStatSync(DMXScreenInfo *dmxScreen,
                 struct timeval *stop, struct timeval *start,
                 unsigned long pending)
{
    DMXStatInfo   *s      = dmxScreen->stat;
    unsigned long elapsed = usec(stop, start);
    unsigned long thresh;
    int           i;

    ++s->syncCount;
    dmxStatValue(&s->usec, elapsed);
    dmxStatValue(&s->pending, pending);
    
    for (i = 0, thresh = DMX_STAT_BIN0; i < DMX_STAT_BINS-1; i++) {
        if (elapsed < thresh) {
            ++s->bins[i];
            break;
        }
        thresh *= DMX_STAT_BINMULT;
    }
    if (i == DMX_STAT_BINS-1) ++s->bins[i];
}
Ejemplo n.º 12
0
int main(int argc, char **argv) {
    uint8_t success;
    int i;
    intset *is;
    sranddev();

    printf("Value encodings: "); {
        assert(_intsetValueEncoding(-32768) == INTSET_ENC_INT16);
        assert(_intsetValueEncoding(+32767) == INTSET_ENC_INT16);
        assert(_intsetValueEncoding(-32769) == INTSET_ENC_INT32);
        assert(_intsetValueEncoding(+32768) == INTSET_ENC_INT32);
        assert(_intsetValueEncoding(-2147483648) == INTSET_ENC_INT32);
        assert(_intsetValueEncoding(+2147483647) == INTSET_ENC_INT32);
        assert(_intsetValueEncoding(-2147483649) == INTSET_ENC_INT64);
        assert(_intsetValueEncoding(+2147483648) == INTSET_ENC_INT64);
        assert(_intsetValueEncoding(-9223372036854775808ull) == INTSET_ENC_INT64);
        assert(_intsetValueEncoding(+9223372036854775807ull) == INTSET_ENC_INT64);
        ok();
    }

    printf("Basic adding: "); {
        is = intsetNew();
        is = intsetAdd(is,5,&success); assert(success);
        is = intsetAdd(is,6,&success); assert(success);
        is = intsetAdd(is,4,&success); assert(success);
        is = intsetAdd(is,4,&success); assert(!success);
        ok();
    }

    printf("Large number of random adds: "); {
        int inserts = 0;
        is = intsetNew();
        for (i = 0; i < 1024; i++) {
            is = intsetAdd(is,rand()%0x800,&success);
            if (success) inserts++;
        }
        assert(is->length == inserts);
        checkConsistency(is);
        ok();
    }

    printf("Upgrade from int16 to int32: "); {
        is = intsetNew();
        is = intsetAdd(is,32,NULL);
        assert(is->encoding == INTSET_ENC_INT16);
        is = intsetAdd(is,65535,NULL);
        assert(is->encoding == INTSET_ENC_INT32);
        assert(intsetFind(is,32));
        assert(intsetFind(is,65535));
        checkConsistency(is);

        is = intsetNew();
        is = intsetAdd(is,32,NULL);
        assert(is->encoding == INTSET_ENC_INT16);
        is = intsetAdd(is,-65535,NULL);
        assert(is->encoding == INTSET_ENC_INT32);
        assert(intsetFind(is,32));
        assert(intsetFind(is,-65535));
        checkConsistency(is);
        ok();
    }

    printf("Upgrade from int16 to int64: "); {
        is = intsetNew();
        is = intsetAdd(is,32,NULL);
        assert(is->encoding == INTSET_ENC_INT16);
        is = intsetAdd(is,4294967295,NULL);
        assert(is->encoding == INTSET_ENC_INT64);
        assert(intsetFind(is,32));
        assert(intsetFind(is,4294967295));
        checkConsistency(is);

        is = intsetNew();
        is = intsetAdd(is,32,NULL);
        assert(is->encoding == INTSET_ENC_INT16);
        is = intsetAdd(is,-4294967295,NULL);
        assert(is->encoding == INTSET_ENC_INT64);
        assert(intsetFind(is,32));
        assert(intsetFind(is,-4294967295));
        checkConsistency(is);
        ok();
    }

    printf("Upgrade from int32 to int64: "); {
        is = intsetNew();
        is = intsetAdd(is,65535,NULL);
        assert(is->encoding == INTSET_ENC_INT32);
        is = intsetAdd(is,4294967295,NULL);
        assert(is->encoding == INTSET_ENC_INT64);
        assert(intsetFind(is,65535));
        assert(intsetFind(is,4294967295));
        checkConsistency(is);

        is = intsetNew();
        is = intsetAdd(is,65535,NULL);
        assert(is->encoding == INTSET_ENC_INT32);
        is = intsetAdd(is,-4294967295,NULL);
        assert(is->encoding == INTSET_ENC_INT64);
        assert(intsetFind(is,65535));
        assert(intsetFind(is,-4294967295));
        checkConsistency(is);
        ok();
    }

    printf("Stress lookups: "); {
        long num = 100000, size = 10000;
        int i, bits = 20;
        long long start;
        is = createSet(bits,size);
        checkConsistency(is);

        start = usec();
        for (i = 0; i < num; i++) intsetSearch(is,rand() % ((1<<bits)-1),NULL);
        printf("%ld lookups, %ld element set, %lldusec\n",num,size,usec()-start);
    }

    printf("Stress add+delete: "); {
        int i, v1, v2;
        is = intsetNew();
        for (i = 0; i < 0xffff; i++) {
            v1 = rand() % 0xfff;
            is = intsetAdd(is,v1,NULL);
            assert(intsetFind(is,v1));

            v2 = rand() % 0xfff;
            is = intsetRemove(is,v2,NULL);
            assert(!intsetFind(is,v2));
        }
        checkConsistency(is);
        ok();
    }
}
Ejemplo n.º 13
0
 void start() {
   t0 = usec();
 }
Ejemplo n.º 14
0
uint32_t Timer::value(void){
	return usec();
}
Ejemplo n.º 15
0
static void test_throughput(void) {
    int i, num;
    long long t1, t2;
    redisContext *c = blocking_context;
    redisReply **replies;

    test("Throughput:\n");
    for (i = 0; i < 500; i++)
        freeReplyObject(redisCommand(c,"LPUSH mylist foo"));

    num = 1000;
    replies = malloc(sizeof(redisReply*)*num);
    t1 = usec();
    for (i = 0; i < num; i++) {
        replies[i] = redisCommand(c,"PING");
        assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_STATUS);
    }
    t2 = usec();
    for (i = 0; i < num; i++) freeReplyObject(replies[i]);
    free(replies);
    printf("\t(%dx PING: %.3fs)\n", num, (t2-t1)/1000000.0);

    replies = malloc(sizeof(redisReply*)*num);
    t1 = usec();
    for (i = 0; i < num; i++) {
        replies[i] = redisCommand(c,"LRANGE mylist 0 499");
        assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_ARRAY);
        assert(replies[i] != NULL && replies[i]->elements == 500);
    }
    t2 = usec();
    for (i = 0; i < num; i++) freeReplyObject(replies[i]);
    free(replies);
    printf("\t(%dx LRANGE with 500 elements: %.3fs)\n", num, (t2-t1)/1000000.0);

    num = 10000;
    replies = malloc(sizeof(redisReply*)*num);
    for (i = 0; i < num; i++)
        redisAppendCommand(c,"PING");
    t1 = usec();
    for (i = 0; i < num; i++) {
        assert(redisGetReply(c, (void*)&replies[i]) == REDIS_OK);
        assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_STATUS);
    }
    t2 = usec();
    for (i = 0; i < num; i++) freeReplyObject(replies[i]);
    free(replies);
    printf("\t(%dx PING (pipelined): %.3fs)\n", num, (t2-t1)/1000000.0);

    replies = malloc(sizeof(redisReply*)*num);
    for (i = 0; i < num; i++)
        redisAppendCommand(c,"LRANGE mylist 0 499");
    t1 = usec();
    for (i = 0; i < num; i++) {
        assert(redisGetReply(c, (void*)&replies[i]) == REDIS_OK);
        assert(replies[i] != NULL && replies[i]->type == REDIS_REPLY_ARRAY);
        assert(replies[i] != NULL && replies[i]->elements == 500);
    }
    t2 = usec();
    for (i = 0; i < num; i++) freeReplyObject(replies[i]);
    free(replies);
    printf("\t(%dx LRANGE with 500 elements (pipelined): %.3fs)\n", num, (t2-t1)/1000000.0);
}
Ejemplo n.º 16
0
int main (int argc, char ** argv) {

	u8  ** board[2];

	u32 numberOfSamples     = NUMBEROFSAMPLES;
	u32 numberOfChannels    = NUMBEROFCHANNELS;
	u32 samplePeriodDivisor = SAMPLEPERIODDIVISOR;
	tBoolean continuous     = kTrue;

	int fd, fd2, ic;

	struct timeval origin, before, after[8];

	opterr = 0;
	char c;
	int opt_D=0, opt_o=0, D=0, opt_F=0, opt_T=0, opt_r=80;
	int opt_e=0, opt_I=0, opt_b=-1, opt_B=-1, opt_i=0, adc_range=0;
	int opt_M=0, opt_R=0, opt_at=0, opt_p=1;

	i32 value[8];
	f32 scaled;
	i32 rescaled;
	u32 n = 0;
	int j;
	FILE * param, * calibr[2]={NULL,NULL};
	int cadence;
	struct dma_channel dma;
	static struct scale_table adc_scale, dac_scale[2][2];
        int scan_fd;

	dma.status = DMA_IDLE;

	printf("niconf - starting ...\n");

        /*
         *   get some setup values
         */

        param = fopen(CHANNELS, "r");
                if (!param || fscanf (param, "%d", &numberOfChannels) != 1) {
                        printf ("niconf: could not get channels value\n");
                        exit (-1);
                }
 

	while ((c = getopt (argc, argv, "c:d:r:p:s:x:ItiDoeMRFTb:B:vh")) != -1)
		switch (c)
		{
		case 'c':
			if (optarg) numberOfChannels = atoi(optarg);
			break;
		case 'd':
			if (optarg) samplePeriodDivisor = atoi(optarg);
			break;
		case 'r':
			if (optarg) opt_r = atoi(optarg);
			break;
		case 'I':
			if (opt_i) {
				printf ("%s - the interrupt system will not "
					"be enabled\n", NAM);
				exit (-1);
			}
			opt_I = 1;
			break;
		case 't':
                        opt_at = 1;
                        break;
		case 'i':
			if (opt_I) {
				printf ("%s - the interrupt system will "
					"not be enabled\n", NAM);
				exit (-1);
			}
			opt_i = 1;
			break;
		case 'D':
			opt_D = 1;
			break;
		case 'o':
			opt_o = 1;
			break;
		case 's':
			if (optarg) numberOfSamples = atoi(optarg);
			break;
		case 'p':
			if (optarg) opt_p = atoi(optarg);
			break;
		case 'x':
			if (optarg) adc_range = atoi(optarg);
			break;
		case 'e':
			opt_e = 1;
			break;
		case 'M':
                        opt_M = 1;
                        break;
                case 'R':
                        opt_R = 1;
                        break;
		case 'F':
			opt_F = 1;
			break;
		case 'T':
			opt_T = 1;
			break;
		case 'b':
			opt_b = strtol(optarg, NULL, 0);
			break;
		case 'B':
			opt_B = strtol(optarg, NULL, 0);
			break;
		case 'v':
			D += 1;
			break;
		case 'h':
		default:
			if (c != 'h') {
				fprintf (stderr, "### Unknown option: -%c.\n",
					 optopt);
				fprintf (stderr, display); exit (-1);
			}
			fprintf (stderr, display);
			exit (0);
		}

	/*
	 *    We need get a lock on /dev/spm/scan so nobody can
	 *    modify irq parameters during board configuration.
         *    The lock will be released when niconf exits.
	 */

	scan_fd = open("/dev/spm/scan", O_RDWR | O_NONBLOCK);
        if (scan_fd < 0) {
                printf ("niconf: could not obtain lock on scan: %d\n",
                        scan_fd);
                exit (-1);
        }

	/*
	 *   find and activate the board
	 */

	board[0] = acquire_board("/dev/spm/nibac0", D, &fd);
	if (board[0]) {
		printf ("%s - Found master board as nibac0\n", NAM);

		dma.fd = fd;
		dma.memap[0] = board[0][2] + DMA_CHANNEL_1;
		dma.memap[1] = board[0][3] + DMA_CHANNEL_1;
                if (D>1) {
                        printf ("%s - board mapped at: %p %p %p %p %p\n", NAM,
                                board[0][0], board[0][1], board[0][2],
                                board[0][3], board[0][4]);
                }
        }

	board[1] = acquire_board("/dev/spm/nibac1", D, &fd2);
	if (board[1]) {
		printf ("%s - Found slave board as nibac1\n", NAM);
                if (D>1) {
                        printf ("%s - board mapped at: %p %p %p %p %p\n", NAM,
                                board[1][0], board[1][1], board[1][2],
                                board[1][3], board[1][4]);
                }
	}

        if (board[0] == 0 && board[1] == 0) exit (-1);

	/*
	 *    configure the board
	 */

	if (opt_F || opt_I) {

		/*
		 *   Master board configuration
		 */

                if (board[0]) {

                        /* disable all board interrupts */

                        write32(board[0][2], 0x10, 0x40150000);
		
                        /* stop DMA operation */
		
                        NIBIT (dma.memap, ChannelOperation, write, Stop, 1);
                        gettimeofday(&before, NULL);
                        while (NIBIT(dma.memap, ChannelStatus, read, DmaDone)
                               != 1) {
                                gettimeofday(&origin, NULL);
                                if (usec(&origin, &before) > 100000) {
                                        printf ("Could not get DMA stopped\n");
                                        exit (-1);
                                }
                        }	

                        NIREG (board[0], Interrupt_A_Enable,write, 0);

                        NIBIT (board[0], G0_DMA_Config, set, G0_DMA_Enable, 0);
                        NIBIT (board[0], G0_DMA_Config, write,
                               G0_DMA_Int_Enable, 0);

                        /* disarm board and reset DMA */

                        ai_disarm (board[0]);

                        NIBIT (dma.memap, ChannelOperation, write, Stop, 1);
                        dma.state = DMA_STOPPED; 

                        NIBIT (board[0], AI_AO_Select,set,AI_DMA_Select,0);
                        NIREG (board[0], AI_AO_Select, flush);

                        /* Analog Input reset and configure */

                        board_reset(board[0]);
                        configure_timebase (board[0]);
                        pll_reset (board[0]);
                        analog_trigger_reset (board[0]);
                        ai_reset (board[0]);

                        if (D) printf ("%s - reset and configure completed\n",
                                       NAM);

                        /* setup for adc input */

                        ai_personalize (board[0],
                                        _kAI_CONVERT_Output_SelectActive_High);
                        ai_clear_fifo (board[0]);

                        ai_disarm (board[0]);
    
                        ai_clear_configuration_memory (board[0]);

                        u32 i;
    
                        for (i = 0; i < numberOfChannels; i++) {
                                ai_configure_channel
                                        (board[0], 
                                         i,  /* channel number */
                                         adc_range,  /* gain */
                                         _kAI_Config_PolarityBipolar,
                                         _kAI_Config_Channel_TypeDifferential, 
                                         /* last channel? */
                                         (i == numberOfChannels-1)?
                                         kTrue:kFalse);
                        }

                        ai_set_fifo_request_mode (board[0]);    
    
                        ai_environmentalize (board[0]);
    
                        ai_hardware_gating (board[0]);
    
                        ai_trigger (board[0],
                                    _kAI_START1_SelectPulse,
                                    _kAI_START1_PolarityRising_Edge,
                                    _kAI_START2_SelectPulse,
                                    _kAI_START2_PolarityRising_Edge);
    
                        ai_sample_stop (board[0], (numberOfChannels > 1)?
                                        kTrue:kFalse); /* multi channel? */

                        if (!opt_e) continuous = kFalse;
                        ai_number_of_samples
                                (board[0],
                                 numberOfSamples, /* postrigger samples */
                                 0,               /* pretrigger samples */
                                 continuous);     /* continuous? */

                        param = fopen(
                                "/sys/module/spm_dev/parameters/cadence_usec",
                                "r");
                        if (param) {
                                if (fscanf (param, "%d", &cadence) != 1)
                                        cadence = 0;
                                fclose (param);

                                if (cadence) {
                                        samplePeriodDivisor = cadence * 20;
                                        if (D) printf (
                                                "%s - using divisor %d -> %d"
                                                "usec from cadence_usec\n",
                                                NAM,
                                                samplePeriodDivisor, cadence);
                                }
                        } else {
                                if (D) printf (
                                        "%s - using divisor %d -> %d usec\n",
                                        NAM, samplePeriodDivisor,
                                        samplePeriodDivisor/20);
                        }

                        ai_sample_start (
                                board[0], 
                                samplePeriodDivisor,   /* period divisor */
                                samplePeriodDivisor,   /* 3 , delay divisor */
                                _kAI_START_SelectSI_TC,
                                _kAI_START_PolarityRising_Edge);

                        ai_convert (
                                board[0], 
                                opt_r,  /* 280 */     // convert period divisor
                                3,      // convert delay divisor 
                                kFalse); // external sample clock?

                        ai_clear_fifo (board[0]);

                        if (D) printf ("%s - adc setup completed\n", NAM);

                }

		/*
		 *   read calibration data and configure DAC and digital lines
		 *   on both boards
		 */

		for ( j=0 ; j<2 ; j++ ) {
			if (board[j] == 0) continue;

			/*
			 * read eeprom for calibration information
			 */

			u32 eeprom_size = 1024;

			eeprom_read_MSeries (board[j], board[j][4],
					     eeprom_size);

			if (D>=2) {
                                printf ("\n%s - %s\n\n", NAM,
                                        "Calibration memory content");
				dump_memory (board[j][4], eeprom_size);
			}
                        
			if (D) printf ("%s - eeprom reading completed\n",
					 NAM);

			/*
			 *   analog output reset
			 */

			ao_reset (board[j]);
			ao_personalize (board[j]);
			ao_reset_waveform_channels (board[j]);
			ao_clear_fifo (board[j]);

			/*
			 *   unground AO reference
			 */

			NIBIT(board[j],AO_Calibration,write,
			      AO_RefGround,kFalse);

			/*
			 *   analog output configure
			 */

			ao_configure_dac (board[j],
					  0,
					  0xF,
					  _kAO_DAC_PolarityBipolar,
					  _kAO_Update_ModeImmediate);

			ao_configure_dac (board[j],
					  1,
					  0xF,
					  _kAO_DAC_PolarityBipolar,
					  _kAO_Update_ModeImmediate);

			if (D) printf ("%s - DAC configuration completed "
					 "on board %d at %p\n", NAM, j,
					 board[j]);

			/*
			 *    configure digital IO
			 */

			NIREG (board[j], DIO_Direction, write, 0xff);
		}
        }
        
        /*
         *   configure DMA
         */

        if (opt_R) {
                param = fopen(DMA_USE, "r");
                if (!param || fscanf (param, "%d", &opt_M) != 1) {
                        printf ("niconf: could not get dma_use value\n");
                        exit (-1);
                }
                fclose (param);
		printf ("Keeping DMA channel to state: %d\n", opt_M);

		param = fopen(SAMPLES_PP, "r");
                if (!param || fscanf (param, "%d", &opt_p) != 1) {
                        printf ("niconf: could not get samples value\n");
                        exit (-1);
                }
                fclose (param);
		printf ("Keeping samples to value: %d\n", opt_p);

	}

        if (board[0]) {
                if (opt_I && opt_M) {

                        printf ("%s - starting DMA configuration\n", NAM);

                        NIBIT (board[0], AI_AO_Select,set,AI_DMA_Select,1);

                        NIREG (board[0], AI_AO_Select, flush);

                        dma.mode = DMA_RING;
                        dma.direction = DMA_IN;
                        dma.drq = 0;
                        dma.size = 2 * numberOfChannels * opt_p;
			if (dma.size > 4095) {
                                printf ("niconf: huge DMA buffer! "
                                        "Please, reduce!\n");
                                exit (-1);
                        }
                        dma.transfer_width = DMA_16_BIT;

                        /* read from module parameters the physical address
                           of dma buffer */

                        param = fopen(PHYSICAL_ADDRESS, "r");
                        if (!param || 
                            fscanf (param, "%u",
                                    (u32 *) &dma.physical_address) != 1) {
                                printf ("niconf: dma address not available\n");
                                exit (-1);
                        }
                        fclose (param);

                        dma_configure (&dma);

                        NIBIT (dma.memap, ChannelOperation, write, Start, 1);
                        dma.state = DMA_STARTED;

                        printf ("%s - dma configuration complete\n", NAM);

                } else if (opt_I || opt_F) {              /* deactivate DMA */

                        NIBIT (dma.memap, ChannelOperation, write, Stop, 1);
                        dma.state = DMA_STOPPED; 
                        
                        NIBIT (board[0], AI_AO_Select,set,AI_DMA_Select,0);
                        NIREG (board[0], AI_AO_Select, flush);
                }
        }

        /*
         *   set dma_use flag in module parameters
         */

        if (opt_I || opt_F) {

                param = fopen(DMA_USE, "w");
                if (!param || 
                    fprintf (param, "%c\n", opt_M ? '1' : '0') != 2) {
                        printf ("niconf: could not set dma_use flag\n");
                        exit (-1);
                }
                fclose (param);
        }
        
        /*
         *    activate the interrupt system
         */

        if (opt_I && board[0]) {

                printf ("%s - Activating the interrupt system\n", NAM);
                
                /* enable Mite interrupt IO=1 */
                write32(board[0][2], 0x08, 0x01000000);

		if (opt_M) {

                	/* enable board and DMA interrupt */
                	write32(board[0][2], 0x10, 0x80020000);
                	
//                	NIBIT (board[0], G0_DMA_Config, set, G0_DMA_Enable, 1);
//                	NIBIT (board[0], G0_DMA_Config, write,
//                		G0_DMA_Int_Enable, 1);
                		
		} else {

                	/* enable board interrupt */
                	write32(board[0][2], 0x10, 0x80000000);
                	
	                NIBIT (board[0], Interrupt_Control, write,
        	               Interrupt_Group_A_Enable, 1);

        	        NIBIT (board[0], Interrupt_A_Enable,write,
        	               AI_STOP_Interrupt_Enable, 1);
        	        NIREG (board[0], Interrupt_B_Enable,write, 0);
		}
		
		if (D) printf ("%s - interrupt activation "
        	                       "completed\n", NAM);
	}

 	/*
	 *    read ADC and DAC scale coefficients
	 *
	 */

        if (board[0]) {

                calibr[0] = fopen("/tmp/spm.calibration.master", "w");
                if (!calibr[0]) {
                        printf ("niconf: could not open %s\n",
                                "spm.calibration.master");
                        exit (-1);
                }

                ai_get_scaling_coefficients (board[0][4], adc_range == 4 ? 3 
                                             : adc_range, 0, 0, &adc_scale);

                fprintf (calibr[0], "ADC nibac %d %g  %g  %g  %g\n",
			 adc_scale.order,
                         adc_scale.c[0],adc_scale.c[1],
                         adc_scale.c[2],adc_scale.c[3]);

                if (D>1) printf (
                        "%s - adc scaling coefficients: %d  %g  %g  %g  %g\n",
                        NAM, adc_scale.order,
                        adc_scale.c[0],adc_scale.c[1],
                        adc_scale.c[2],adc_scale.c[3]);
        }

	for ( j=0 ; j<2 ; j++ ) {

                if (D>1) printf ("%s - DAC scale for board %d: %p\n",
                                 NAM, j, board[j]);

		if (board[j] == 0) continue;

                if (j == 1) {
                        calibr[1] = fopen("/tmp/spm.calibration.slave", "w");
                        if (!calibr[1]) {
                                printf ("niconf: could not open %s\n",
                                        "spm.calibration.slave");
                                exit (-1);
                        }
                }

		ao_get_scaling_coefficients (board[j][4], 0, 0, 0,
					     &dac_scale[j][0]);
		ao_get_scaling_coefficients (board[j][4], 0, 0, 1,
					     &dac_scale[j][1]);

                fprintf (calibr[j], "DAC nibac %d  %g  %g  %g  %g\n",
                        dac_scale[j][0].order,
                        dac_scale[j][0].c[0], dac_scale[j][0].c[1],
                        dac_scale[j][0].c[2], dac_scale[j][0].c[3]);

                fprintf (calibr[j], "DAC nibac %d  %g  %g  %g  %g\n",
                        dac_scale[j][1].order,
                        dac_scale[j][1].c[0], dac_scale[j][1].c[1],
                        dac_scale[j][1].c[2], dac_scale[j][1].c[3]);

		printf ("%s - dac 0 scaling coefficients: %d  %g  %g\n",
				NAM, dac_scale[j][0].order,
				dac_scale[j][0].c[0], dac_scale[j][0].c[1]);

		printf ("%s - dac 1 scaling coefficients: %d  %g  %g\n",
				NAM, dac_scale[j][1].order, 
				dac_scale[j][1].c[0], dac_scale[j][1].c[1]);
	}

	if (D>1) printf ("%s - scale coefficients completed\n", NAM);

        if (calibr[0]) fclose (calibr[0]);
	if (calibr[1]) fclose (calibr[1]);

	/*
	 *
	 *    put out bits to digital lines
	 *
	 */

	if (opt_b >= 0 ) {
                if (board[0]) {
                        NIREG (board[0], Static_Digital_Output, write,
                               (u8) 0xff & opt_b);
                        printf ("%s - wrote digital output: 0x%x\n", NAM,
                                NIREG (board[0], Static_Digital_Input, read));
                } else {
                        printf ("%s - %s\n", NAM,
                                "sorry, '-b' option requires a master board");
                }
        }

	if (opt_B >= 0) {
                if (board[1]) {
                        NIREG (board[1], Static_Digital_Output, write,
                               (u8) 0xff & opt_b);
                        printf ("%s - wrote digital output: 0x%x\n", NAM,
                                NIREG (board[1], Static_Digital_Input, read));
                } else {
                        printf ("%s - %s\n", NAM,
                                "sorry, '-B' option requires a second board");
                }
        }

        /*
         *     all done - arm and start the board
         */

        if (opt_at && board[0]) {
                ai_arm (board[0], kTrue);
                ai_start (board[0]);
        }

	/*
	 *
	 *    read adc data from board
	 *
	 */

	if (opt_i && board[0]) {         /* read data polling fifo */

		printf ("%s - going to read ADC from user space\n", NAM);

		/* disable the board interrupt */
		write32(board[0][2], 0x10, 0x40000000);
		usleep (100);

		if (opt_o) printf ("\n");

		gettimeofday(&origin, NULL);
		before = origin;

		while (opt_e || !numberOfSamples ||
		       (n < numberOfChannels*numberOfSamples)) {

			for ( ic=0 ; ic<numberOfChannels ; ic++ ) {
				while (NIBIT(board[0],AI_Status_1,read,
					     AI_FIFO_Empty_St)) {}
				gettimeofday(after+ic, NULL);
				value[ic] = NIREG(board[0],AI_FIFO_Data,read);
			}

			if (!opt_o) printf ("\n");
			printf ("\r%4d     %6.3f  %8ld ",
				n/numberOfChannels,
				msec(&after[0], &origin)/1000.,
				usec(after, &before));
    
			for ( ic=0 ; ic<numberOfChannels ; ic++ ) {
				ai_polynomial_scaler (value+ic, &scaled,
						      &adc_scale);

				if (opt_T && ic)
					printf ("%6ld", usec(after+ic,
							     after+ic-1));

				printf ("%9.3f", scaled);

				if (opt_D && ic < 2) {     /* loop to DAC */ 
					ao_linear_scaler (&rescaled, &scaled,
							  &dac_scale[0][ic]);
					NIREG(board[0], DAC_Direct_Data, ic,
					      write,(*( value+ic))/2);
				}

				n++;

				fflush(NULL);
			}
			before = after[0];
		}
		printf ("\n\n");
	}
        close (scan_fd);
	return 0; 
}
Ejemplo n.º 17
0
	void sleep_sync(unsigned long int t) {
		t *= 1000;
		unsigned long int u = usec();
		usleep(t - (u % t));
	}
Ejemplo n.º 18
0
void delay(int n) {
  std::chrono::microseconds usec(n * timeFactor);
  usleep(usec.count());
}
Ejemplo n.º 19
0
		void USec::normalize()
		{
			*this = USec( usec() );
		}
Ejemplo n.º 20
0
Archivo: bench.c Proyecto: RAttab/ilka
static double nsec() { return usec() / 1000; }
Ejemplo n.º 21
0
/*-----------------------------------------------------------------------------
 * Service MAVlink protocol message routine
 */
void Timer1_IRQHandler() {
    mavlink_message_t msg;

    MadgwickAHRSupdateIMU(
               DEG_TO_RAD(params[PARAM_GX].val),
               DEG_TO_RAD(params[PARAM_GY].val),
               DEG_TO_RAD(params[PARAM_GZ].val),
                          params[PARAM_AX].val,
                          params[PARAM_AY].val,
                          params[PARAM_AZ].val);

    mavlink_msg_heartbeat_pack(
            mavlink_system.sysid,
            mavlink_system.compid,
            &msg,
            MAV_TYPE_GROUND_ROVER,
            MAV_AUTOPILOT_GENERIC,
            mavlink_sys_mode,
            0,
            mavlink_sys_state);
    mavlink_send_msg(&msg);

    mavlink_msg_sys_status_pack(
            mavlink_system.sysid,
            mavlink_system.compid,
            &msg,
            MAV_SYS_STATUS_SENSOR_3D_GYRO
            | MAV_SYS_STATUS_SENSOR_3D_ACCEL
            | MAV_SYS_STATUS_SENSOR_3D_MAG
            | MAV_SYS_STATUS_SENSOR_ABSOLUTE_PRESSURE
            | MAV_SYS_STATUS_SENSOR_GPS,
            MAV_SYS_STATUS_SENSOR_3D_GYRO
            | MAV_SYS_STATUS_SENSOR_3D_ACCEL
            | MAV_SYS_STATUS_SENSOR_3D_MAG,
            MAV_SYS_STATUS_SENSOR_3D_GYRO
            | MAV_SYS_STATUS_SENSOR_3D_ACCEL
            | MAV_SYS_STATUS_SENSOR_3D_MAG
            | MAV_SYS_STATUS_SENSOR_ABSOLUTE_PRESSURE
            | MAV_SYS_STATUS_SENSOR_GPS,
            50,                             // TODO remove hardoded values
            0,
            -1,
            -1,
            0,
            0,
            0,
            0,
            0,
            0);
    mavlink_send_msg(&msg);

    mavlink_msg_autopilot_version_pack(
            mavlink_system.sysid,
            mavlink_system.compid,
            &msg,
            0, // No capabilities (MAV_PROTOCOL_CAPABILITY). TBD
            42,
            42,
            42,
            42,
            "DEADBEEF",
            "DEADBEEF",
            "DEADBEEF",
            42,
            42,
            42);
    mavlink_send_msg(&msg);

    mavlink_msg_highres_imu_pack(
            mavlink_system.sysid,
            mavlink_system.compid,
            &msg,
            usec(),
            params[PARAM_AX].val,
            params[PARAM_AY].val,
            params[PARAM_AZ].val,
            params[PARAM_GX].val,
            params[PARAM_GY].val,
            params[PARAM_GZ].val,
            params[PARAM_MX].val,
            params[PARAM_MY].val,
            params[PARAM_MZ].val,
            0,
            0,
            0,
            params[PARAM_T].val,
            (1 << 12) | ((1 << 9) - 1));
    mavlink_send_msg(&msg);

    mavlink_msg_attitude_quaternion_pack(
            mavlink_system.sysid,
            mavlink_system.compid,
            &msg,
            usec(),
            q0,
            q1,
            q2,
            q3,
            DEG_TO_RAD(params[PARAM_GX].val),
            DEG_TO_RAD(params[PARAM_GY].val),
            DEG_TO_RAD(params[PARAM_GZ].val));
    mavlink_send_msg(&msg);

    usec_service_routine();

    MSS_TIM1_clear_irq();
}
Ejemplo n.º 22
0
/* 
 * For 32,000 elements
 * NIL: 0.01 sec
 * all: 0.17 sec
 * MPZ: 0.21 sec
 * MPF: 0.19 sec
 * STR: 0.24 sec
 * ID : 0.18 sec
 * LST: 0.04 sec
 * 
 * 
 */ 
int test_hash()
{
#define NUMBER ((1 << 15) + 1)
#define REPEATS 20
	
	value x = value_init_nil();
	
	value val = value_set_str("result");
	size_t i, j, k, start, finish;
	
	value keys[NUMBER];
	char *skeys[NUMBER];
	for (i = 0; i < NUMBER; ++i) {
		skeys[i] = value_malloc(NULL, 30);
		sprintf(skeys[i], "%ld", (long) i);
		
		value num = value_set_long(i);
		
		switch (i % 4) {
			case 0:
				keys[i] = value_set(num);
				break;
			case 1:
				keys[i] = value_set_double(i);
				break;
			case 2:
				keys[i] = value_cast(num, VALUE_STR);
				break;
			case 3:
				keys[i] = value_cast(num, VALUE_STR);
				keys[i].type = VALUE_ID;
				break;
			case 4:
				keys[i] = value_init(VALUE_LST);
				value_cons_now2(&num, &keys[i]);
				break;
			default:
				keys[i] = value_init_nil();
				break;
		}
		
		value_clear(&num);
		
		// This overrides the setting done above.
//		keys[i] = value_cast(value_set_long(i), VALUE_STR);
	}
	
	for (i = 1 << 4; i < NUMBER; i <<= 1) {
		long average = 0;
		long difference = 0;
		
		for (j = 0; j < REPEATS; ++j) {
			x = value_init(VALUE_HSH);
//			StrMap *map = strmap_new(HASH_DEFAULT_CAPACITY);
			
			start = usec();
			
			for (k = 0; k < i; ++k)
				value_hash_put(&x, keys[k], val);
//				strmap_put(map, skeys[k], sval);
			
			finish = usec();
			average += finish - start;
			if (labs((long) (average / (j+1)) - (finish - start)) > difference)
				difference = labs((long) (average / (j+1)) - (finish - start));

			value_clear(&x);
//			strmap_delete(map);
		}
		
		printf("time for %ld elements: %ld usec +/= %ld\n", (long) i, average / j, difference);
	}

#undef NUMBER
#undef REPEATS

	return 0;
}
Ejemplo n.º 23
0
int main(int argc, char **argv)
{
    int            c;
    int            r  = 0;
    int            fd = -1;
    drm_handle_t      handle;
    void           *address;
    char           *pt;
    unsigned long  count;
    unsigned long  offset;
    unsigned long  size;
    drm_context_t  context;
    int            loops;
    char           buf[1024];
    int            i;
    drmBufInfoPtr  info;
    drmBufMapPtr   bufs;
    drmLockPtr     lock;
    int            secs;

    while ((c = getopt(argc, argv,
		       "lc:vo:O:f:s:w:W:b:r:R:P:L:C:XS:B:F:")) != EOF)
	switch (c) {
	case 'F':
	    count  = strtoul(optarg, NULL, 0);
	    if (!fork()) {
		dup(fd);
		sleep(count);
	    }
	    close(fd);
	    break;
	case 'v': getversion(fd);                                        break;
	case 'X':
	    if ((r = drmCreateContext(fd, &context))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    printf( "Got %d\n", context);
	    break;
	case 'S':
	    process_sigio(optarg);
	    break;
	case 'C':
	    if ((r = drmSwitchToContext(fd, strtoul(optarg, NULL, 0)))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    break;
	case 'c':
	    if ((r = drmSetBusid(fd,optarg))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    break;
	case 'o':
	    if ((fd = drmOpen(optarg, NULL)) < 0) {
		drmError(fd, argv[0]);
		return 1;
	    }
	    break;
	case 'O':
	    if ((fd = drmOpen(NULL, optarg)) < 0) {
		drmError(fd, argv[0]);
		return 1;
	    }
	    break;
	case 'B':		/* Test buffer allocation */
	    count  = strtoul(optarg, &pt, 0);
	    size   = strtoul(pt+1, &pt, 0);
	    secs   = strtoul(pt+1, NULL, 0);
	    {
		drmDMAReq      dma;
		int            *indices, *sizes;

		indices = alloca(sizeof(*indices) * count);
		sizes   = alloca(sizeof(*sizes)   * count);
		dma.context         = context;
		dma.send_count      = 0;
		dma.request_count   = count;
		dma.request_size    = size;
		dma.request_list    = indices;
		dma.request_sizes   = sizes;
		dma.flags           = DRM_DMA_WAIT;
		if ((r = drmDMA(fd, &dma))) {
		    drmError(r, argv[0]);
		    return 1;
		}
		for (i = 0; i < dma.granted_count; i++) {
		    printf("%5d: index = %d, size = %d\n",
			   i, dma.request_list[i], dma.request_sizes[i]);
		}
		sleep(secs);
		drmFreeBufs(fd, dma.granted_count, indices);
	    }
	    break;
	case 'b':
	    count   = strtoul(optarg, &pt, 0);
	    size    = strtoul(pt+1, NULL, 0);
	    if ((r = drmAddBufs(fd, count, size, 0, 65536)) < 0) {
		drmError(r, argv[0]);
		return 1;
	    }
	    if (!(info = drmGetBufInfo(fd))) {
		drmError(0, argv[0]);
		return 1;
	    }
	    for (i = 0; i < info->count; i++) {
		printf("%5d buffers of size %6d (low = %d, high = %d)\n",
		       info->list[i].count,
		       info->list[i].size,
		       info->list[i].low_mark,
		       info->list[i].high_mark);
	    }
	    if ((r = drmMarkBufs(fd, 0.50, 0.80))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    if (!(info = drmGetBufInfo(fd))) {
		drmError(0, argv[0]);
		return 1;
	    }
	    for (i = 0; i < info->count; i++) {
		printf("%5d buffers of size %6d (low = %d, high = %d)\n",
		       info->list[i].count,
		       info->list[i].size,
		       info->list[i].low_mark,
		       info->list[i].high_mark);
	    }
	    printf("===== /proc/dri/0/mem =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/mem");
	    system(buf);
#if 1
	    if (!(bufs = drmMapBufs(fd))) {
		drmError(0, argv[0]);
		return 1;
	    }
	    printf("===============================\n");
	    printf( "%d bufs\n", bufs->count);
	    for (i = 0; i < bufs->count; i++) {
		printf( "  %4d: %8d bytes at %p\n",
			i,
			bufs->list[i].total,
			bufs->list[i].address);
	    }
	    printf("===== /proc/dri/0/vma =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/vma");
	    system(buf);
#endif
	    break;
	case 'f':
	    offset  = strtoul(optarg, &pt, 0);
	    size    = strtoul(pt+1, NULL, 0);
	    handle  = 0;
	    if ((r = drmAddMap(fd, offset, size,
			       DRM_FRAME_BUFFER, 0, &handle))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    printf("0x%08lx:0x%04lx added\n", offset, size);
	    printf("===== /proc/dri/0/mem =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/mem");
	    system(buf);
	    break;
	case 'r':
	case 'R':
	    offset  = strtoul(optarg, &pt, 0);
	    size    = strtoul(pt+1, NULL, 0);
	    handle  = 0;
	    if ((r = drmAddMap(fd, offset, size,
			       DRM_REGISTERS,
			       c == 'R' ? DRM_READ_ONLY : 0,
			       &handle))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    printf("0x%08lx:0x%04lx added\n", offset, size);
	    printf("===== /proc/dri/0/mem =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/mem");
	    system(buf);
	    break;
	case 's':
	    size = strtoul(optarg, &pt, 0);
	    handle = 0;
	    if ((r = drmAddMap(fd, 0, size,
			       DRM_SHM, DRM_CONTAINS_LOCK,
			       &handle))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    printf("0x%04lx byte shm added at 0x%08lx\n", size, handle);
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/vm");
	    system(buf);
	    break;
	case 'P':
	    offset  = strtoul(optarg, &pt, 0);
	    size    = strtoul(pt+1, NULL, 0);
	    address = NULL;
	    if ((r = drmMap(fd, offset, size, &address))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    printf("0x%08lx:0x%04lx mapped at %p for pid %d\n",
		   offset, size, address, getpid());
	    printf("===== /proc/dri/0/vma =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/vma");
	    system(buf);
	    mprotect((void *)offset, size, PROT_READ);
	    printf("===== /proc/dri/0/vma =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/vma");
	    system(buf);
	    break;
	case 'w':
	case 'W':
	    offset  = strtoul(optarg, &pt, 0);
	    size    = strtoul(pt+1, NULL, 0);
	    address = NULL;
	    if ((r = drmMap(fd, offset, size, &address))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    printf("0x%08lx:0x%04lx mapped at %p for pid %d\n",
		   offset, size, address, getpid());
	    printf("===== /proc/%d/maps =====\n", getpid());
	    snprintf(buf, sizeof(buf), "cat /proc/%d/maps", getpid());
	    system(buf);
	    printf("===== /proc/dri/0/mem =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/mem");
	    system(buf);
	    printf("===== /proc/dri/0/vma =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/vma");
	    system(buf);
	    printf("===== READING =====\n");
	    for (i = 0; i < 0x10; i++)
		printf("%02x ", (unsigned int)((unsigned char *)address)[i]);
	    printf("\n");
	    if (c == 'w') {
		printf("===== WRITING =====\n");
		for (i = 0; i < size; i+=2) {
		    ((char *)address)[i]   = i & 0xff;
		    ((char *)address)[i+1] = i & 0xff;
		}
	    }
	    printf("===== READING =====\n");
	    for (i = 0; i < 0x10; i++)
		printf("%02x ", (unsigned int)((unsigned char *)address)[i]);
	    printf("\n");
	    printf("===== /proc/dri/0/vma =====\n");
	    snprintf(buf, sizeof(buf), "cat /proc/dri/0/vma");
	    system(buf);
	    break;
	case 'L':
	    context = strtoul(optarg, &pt, 0);
	    offset  = strtoul(pt+1, &pt, 0);
	    size    = strtoul(pt+1, &pt, 0);
	    loops   = strtoul(pt+1, NULL, 0);
	    address = NULL;
	    if ((r = drmMap(fd, offset, size, &address))) {
		drmError(r, argv[0]);
		return 1;
	    }
	    lock       = address;
#if 1
	    {
		int            counter = 0;
		struct timeval loop_start, loop_end;
		struct timeval lock_start, lock_end;
		double         wt;
#define HISTOSIZE 9
		int            histo[HISTOSIZE];
		int            output = 0;
		int            fast   = 0;

		if (loops < 0) {
		    loops = -loops;
		    ++output;
		}

		for (i = 0; i < HISTOSIZE; i++) histo[i] = 0;

		gettimeofday(&loop_start, NULL);
		for (i = 0; i < loops; i++) {
		    gettimeofday(&lock_start, NULL);
		    DRM_LIGHT_LOCK_COUNT(fd,lock,context,fast);
		    gettimeofday(&lock_end, NULL);
		    DRM_UNLOCK(fd,lock,context);
		    ++counter;
		    wt = usec(&lock_end, &lock_start);
		    if      (wt <=      2.5) ++histo[8];
		    if      (wt <       5.0) ++histo[0];
		    else if (wt <      50.0) ++histo[1];
		    else if (wt <     500.0) ++histo[2];
		    else if (wt <    5000.0) ++histo[3];
		    else if (wt <   50000.0) ++histo[4];
		    else if (wt <  500000.0) ++histo[5];
		    else if (wt < 5000000.0) ++histo[6];
		    else                     ++histo[7];
		    if (output) printf( "%.2f uSec, %d fast\n", wt, fast);
		}
		gettimeofday(&loop_end, NULL);
		printf( "Average wait time = %.2f usec, %d fast\n",
			usec(&loop_end, &loop_start) /  counter, fast);
		printf( "%9d <=     2.5 uS\n", histo[8]);
		printf( "%9d <        5 uS\n", histo[0]);
		printf( "%9d <       50 uS\n", histo[1]);
		printf( "%9d <      500 uS\n", histo[2]);
		printf( "%9d <     5000 uS\n", histo[3]);
		printf( "%9d <    50000 uS\n", histo[4]);
		printf( "%9d <   500000 uS\n", histo[5]);
		printf( "%9d <  5000000 uS\n", histo[6]);
		printf( "%9d >= 5000000 uS\n", histo[7]);
	    }
#else
	    printf( "before lock: 0x%08x\n", lock->lock);
	    printf( "lock: 0x%08x\n", lock->lock);
	    sleep(5);
	    printf( "unlock: 0x%08x\n", lock->lock);
#endif
	    break;
	default:
	    fprintf( stderr, "Usage: drmstat [options]\n" );
	    return 1;
	}

    return r; 
}
Ejemplo n.º 24
0
 void stop() {
   elapsed += usec() - t0;
 }
Ejemplo n.º 25
0
BOOST_FIXTURE_TEST_CASE( is_default_constructable, bluetoe::link_layer::delta_time )
{
    BOOST_CHECK_EQUAL( usec(), 0 );
    BOOST_CHECK_EQUAL( bluetoe::link_layer::delta_time::now().usec(), 0 );
}
Ejemplo n.º 26
0
int64_t OTime::msec() const {
	return usec()/(int64_t)1000;
}